2 * Copyright (C) 2006-2007 Imendio AB
3 * Copyright (C) 2007-2011 Collabora Ltd.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation; either version 2 of the
8 * License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public
16 * License along with this program; if not, write to the
17 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
18 * Boston, MA 02110-1301 USA
20 * Authors: Martyn Russell <martyn@imendio.com>
21 * Xavier Claessens <xclaesse@gmail.com>
22 * Emilio Pozuelo Monfort <emilio.pozuelo@collabora.co.uk>
27 #include <glib/gi18n-lib.h>
28 #include <webkit/webkit.h>
30 #include <telepathy-glib/proxy-subclass.h>
32 #include "extensions.h"
34 #include "action-chain-internal.h"
35 #include "empathy-camera-monitor.h"
36 #include "empathy-gsettings.h"
37 #include "empathy-request-util.h"
38 #include "empathy-utils.h"
40 #include "empathy-log-window.h"
41 #include "empathy-account-chooser.h"
42 #include "empathy-call-utils.h"
43 #include "empathy-individual-information-dialog.h"
44 #include "empathy-images.h"
45 #include "empathy-theme-manager.h"
46 #include "empathy-ui-utils.h"
47 #include "empathy-webkit-utils.h"
48 #include "empathy-geometry.h"
50 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
51 #include "empathy-debug.h"
53 #define EMPATHY_NS "http://live.gnome.org/Empathy"
55 G_DEFINE_TYPE (EmpathyLogWindow, empathy_log_window, GTK_TYPE_WINDOW);
57 struct _EmpathyLogWindowPriv
61 GtkWidget *button_profile;
62 GtkWidget *button_chat;
63 GtkWidget *button_call;
64 GtkWidget *button_video;
66 GtkWidget *search_entry;
71 GtkWidget *treeview_who;
72 GtkWidget *treeview_what;
73 GtkWidget *treeview_when;
76 GtkTreeStore *store_events;
78 GtkWidget *account_chooser;
82 /* List of selected GDates, free with g_list_free_full (l, g_date_free) */
85 TplActionChain *chain;
86 TplLogManager *log_manager;
88 /* Hash of TpChannel<->TpAccount for use by the observer until we can
89 * get a TpAccount from a TpConnection or wherever */
91 TpBaseClient *observer;
93 EmpathyContact *selected_contact;
94 EmpathyContact *events_contact;
96 EmpathyCameraMonitor *camera_monitor;
97 GBinding *button_video_binding;
99 /* Used to cancel logger calls when no longer needed */
102 /* List of owned TplLogSearchHits, free with tpl_log_search_hit_free */
106 /* Only used while waiting for the account chooser to be ready */
107 TpAccount *selected_account;
108 gchar *selected_chat_id;
109 gboolean selected_is_chatroom;
111 GSettings *gsettings_chat;
112 GSettings *gsettings_desktop;
115 static void log_window_search_entry_changed_cb (GtkWidget *entry,
116 EmpathyLogWindow *self);
117 static void log_window_search_entry_activate_cb (GtkWidget *widget,
118 EmpathyLogWindow *self);
119 static void log_window_search_entry_icon_pressed_cb (GtkEntry *entry,
120 GtkEntryIconPosition icon_pos,
123 static void log_window_who_populate (EmpathyLogWindow *self);
124 static void log_window_who_setup (EmpathyLogWindow *self);
125 static void log_window_when_setup (EmpathyLogWindow *self);
126 static void log_window_what_setup (EmpathyLogWindow *self);
127 static void log_window_events_setup (EmpathyLogWindow *self);
128 static void log_window_chats_accounts_changed_cb (GtkWidget *combobox,
129 EmpathyLogWindow *self);
130 static void log_window_chats_set_selected (EmpathyLogWindow *self);
131 static void log_window_chats_get_messages (EmpathyLogWindow *self,
132 gboolean force_get_dates);
133 static void log_window_when_changed_cb (GtkTreeSelection *selection,
134 EmpathyLogWindow *self);
135 static void log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem,
136 EmpathyLogWindow *self);
137 static void start_spinner (void);
139 static void log_window_create_observer (EmpathyLogWindow *window);
140 static gboolean log_window_events_button_press_event (GtkWidget *webview,
141 GdkEventButton *event, EmpathyLogWindow *self);
142 static void log_window_update_buttons_sensitivity (EmpathyLogWindow *self);
145 empathy_account_chooser_filter_has_logs (TpAccount *account,
146 EmpathyAccountChooserFilterResultCallback callback,
147 gpointer callback_data,
169 COL_WHO_NAME_SORT_KEY,
198 COL_EVENTS_PRETTY_DATE,
207 #define CALENDAR_ICON "stock_calendar"
209 /* Seconds between two messages to be considered one conversation */
210 #define MAX_GAP 30*60
212 #define WHAT_TYPE_SEPARATOR -1
216 EVENT_CALL_INCOMING = 1 << 0,
217 EVENT_CALL_OUTGOING = 1 << 1,
218 EVENT_CALL_MISSED = 1 << 2,
219 EVENT_CALL_ALL = 1 << 3,
223 log_window_get_selected (EmpathyLogWindow *window,
228 TplEventTypeMask *event_mask,
229 EventSubtype *subtype);
231 static EmpathyLogWindow *log_window = NULL;
233 static gboolean has_element;
236 #define _date_copy(d) g_date_new_julian (g_date_get_julian (d))
241 EmpathyLogWindow *self;
245 TplEventTypeMask event_mask;
246 EventSubtype subtype;
251 ctx_new (EmpathyLogWindow *self,
255 TplEventTypeMask event_mask,
256 EventSubtype subtype,
259 Ctx *ctx = g_slice_new0 (Ctx);
263 ctx->account = g_object_ref (account);
265 ctx->entity = g_object_ref (entity);
267 ctx->date = _date_copy (date);
268 ctx->event_mask = event_mask;
269 ctx->subtype = subtype;
278 tp_clear_object (&ctx->account);
279 tp_clear_object (&ctx->entity);
280 tp_clear_pointer (&ctx->date, g_date_free);
282 g_slice_free (Ctx, ctx);
286 select_account_once_ready (EmpathyLogWindow *self,
288 const gchar *chat_id,
289 gboolean is_chatroom)
291 EmpathyAccountChooser *account_chooser;
293 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
295 tp_clear_object (&self->priv->selected_account);
296 self->priv->selected_account = g_object_ref (account);
298 g_free (self->priv->selected_chat_id);
299 self->priv->selected_chat_id = g_strdup (chat_id);
301 self->priv->selected_is_chatroom = is_chatroom;
303 empathy_account_chooser_set_account (account_chooser,
304 self->priv->selected_account);
308 toolbutton_profile_clicked (GtkToolButton *toolbutton,
309 EmpathyLogWindow *self)
311 FolksIndividual *individual;
313 g_return_if_fail (self != NULL);
314 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
316 individual = empathy_ensure_individual_from_tp_contact (
317 empathy_contact_get_tp_contact (self->priv->selected_contact));
319 empathy_display_individual_info (individual);
321 g_object_unref (individual);
325 toolbutton_chat_clicked (GtkToolButton *toolbutton,
326 EmpathyLogWindow *self)
328 g_return_if_fail (self != NULL);
329 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
331 empathy_chat_with_contact (self->priv->selected_contact,
332 gtk_get_current_event_time ());
336 toolbutton_av_clicked (GtkToolButton *toolbutton,
337 EmpathyLogWindow *self)
341 g_return_if_fail (self != NULL);
342 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
344 video = (GTK_WIDGET (toolbutton) == self->priv->button_video);
346 empathy_call_new_with_streams (
347 empathy_contact_get_id (self->priv->selected_contact),
348 empathy_contact_get_account (self->priv->selected_contact),
349 TRUE, video, gtk_get_current_event_time ());
353 insert_or_change_row (EmpathyLogWindow *self,
359 char *str = gtk_tree_path_to_string (path);
360 char *script, *text, *date, *stock_icon;
363 gtk_tree_model_get (model, iter,
364 COL_EVENTS_TEXT, &text,
365 COL_EVENTS_PRETTY_DATE, &date,
366 COL_EVENTS_ICON, &stock_icon,
369 if (!tp_str_empty (stock_icon))
371 GtkIconInfo *icon_info = gtk_icon_theme_lookup_icon (
372 gtk_icon_theme_get_default (),
374 GTK_ICON_SIZE_MENU, 0);
376 if (icon_info != NULL)
377 icon = g_strdup (gtk_icon_info_get_filename (icon_info));
379 gtk_icon_info_free (icon_info);
382 script = g_strdup_printf ("javascript:%s([%s], '%s', '%s', '%s');",
384 g_strdelimit (str, ":", ','),
386 icon != NULL ? icon : "",
389 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
401 store_events_row_inserted (GtkTreeModel *model,
404 EmpathyLogWindow *self)
406 insert_or_change_row (self, "insertRow", model, path, iter);
410 store_events_row_changed (GtkTreeModel *model,
413 EmpathyLogWindow *self)
415 insert_or_change_row (self, "changeRow", model, path, iter);
419 store_events_row_deleted (GtkTreeModel *model,
421 EmpathyLogWindow *self)
423 char *str = gtk_tree_path_to_string (path);
426 script = g_strdup_printf ("javascript:deleteRow([%s]);",
427 g_strdelimit (str, ":", ','));
429 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
437 store_events_has_child_rows (GtkTreeModel *model,
440 EmpathyLogWindow *self)
442 char *str = gtk_tree_path_to_string (path);
445 script = g_strdup_printf ("javascript:hasChildRows([%s], %u);",
446 g_strdelimit (str, ":", ','),
447 gtk_tree_model_iter_has_child (model, iter));
449 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
457 store_events_rows_reordered (GtkTreeModel *model,
461 EmpathyLogWindow *self)
463 char *str = gtk_tree_path_to_string (path);
464 int i, children = gtk_tree_model_iter_n_children (model, iter);
465 char **new_order_strv, *new_order_s;
468 new_order_strv = g_new0 (char *, children + 1);
470 for (i = 0; i < children; i++)
471 new_order_strv[i] = g_strdup_printf ("%i", new_order[i]);
473 new_order_s = g_strjoinv (",", new_order_strv);
475 script = g_strdup_printf ("javascript:reorderRows([%s], [%s]);",
476 str == NULL ? "" : g_strdelimit (str, ":", ','),
479 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
484 g_free (new_order_s);
485 g_strfreev (new_order_strv);
489 events_webview_handle_navigation (WebKitWebView *webview,
490 WebKitWebFrame *frame,
491 WebKitNetworkRequest *request,
492 WebKitWebNavigationAction *navigation_action,
493 WebKitWebPolicyDecision *policy_decision,
494 EmpathyLogWindow *window)
496 empathy_url_show (GTK_WIDGET (webview),
497 webkit_network_request_get_uri (request));
499 webkit_web_policy_decision_ignore (policy_decision);
504 empathy_log_window_constructor (GType type,
506 GObjectConstructParam *props)
510 if (log_window != NULL)
512 retval = (GObject *) log_window;
516 retval = G_OBJECT_CLASS (empathy_log_window_parent_class)
517 ->constructor (type, n_props, props);
519 log_window = EMPATHY_LOG_WINDOW (retval);
520 g_object_add_weak_pointer (retval, (gpointer) &log_window);
527 empathy_log_window_dispose (GObject *object)
529 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (object);
531 if (self->priv->source != 0)
533 g_source_remove (self->priv->source);
534 self->priv->source = 0;
537 if (self->priv->current_dates != NULL)
539 g_list_free_full (self->priv->current_dates,
540 (GDestroyNotify) g_date_free);
541 self->priv->current_dates = NULL;
544 tp_clear_pointer (&self->priv->chain, _tpl_action_chain_free);
545 tp_clear_pointer (&self->priv->channels, g_hash_table_unref);
547 tp_clear_object (&self->priv->observer);
548 tp_clear_object (&self->priv->log_manager);
549 tp_clear_object (&self->priv->selected_account);
550 tp_clear_object (&self->priv->selected_contact);
551 tp_clear_object (&self->priv->events_contact);
552 tp_clear_object (&self->priv->camera_monitor);
554 tp_clear_object (&self->priv->gsettings_chat);
555 tp_clear_object (&self->priv->gsettings_desktop);
557 tp_clear_object (&self->priv->store_events);
559 G_OBJECT_CLASS (empathy_log_window_parent_class)->dispose (object);
563 empathy_log_window_finalize (GObject *object)
565 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (object);
567 g_free (self->priv->last_find);
568 g_free (self->priv->selected_chat_id);
570 G_OBJECT_CLASS (empathy_log_window_parent_class)->finalize (object);
574 empathy_log_window_class_init (
575 EmpathyLogWindowClass *empathy_log_window_class)
577 GObjectClass *object_class = G_OBJECT_CLASS (empathy_log_window_class);
579 g_type_class_add_private (empathy_log_window_class,
580 sizeof (EmpathyLogWindowPriv));
582 object_class->constructor = empathy_log_window_constructor;
583 object_class->dispose = empathy_log_window_dispose;
584 object_class->finalize = empathy_log_window_finalize;
588 empathy_log_window_init (EmpathyLogWindow *self)
590 EmpathyAccountChooser *account_chooser;
594 GtkWidget *vbox, *accounts, *search, *label, *closeitem;
595 GtkWidget *scrolledwindow_events;
598 self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
599 EMPATHY_TYPE_LOG_WINDOW, EmpathyLogWindowPriv);
601 self->priv->chain = _tpl_action_chain_new_async (NULL, NULL, NULL);
603 self->priv->camera_monitor = empathy_camera_monitor_dup_singleton ();
605 self->priv->log_manager = tpl_log_manager_dup_singleton ();
607 self->priv->gsettings_chat = g_settings_new (EMPATHY_PREFS_CHAT_SCHEMA);
608 self->priv->gsettings_desktop = g_settings_new (
609 EMPATHY_PREFS_DESKTOP_INTERFACE_SCHEMA);
611 gtk_window_set_title (GTK_WINDOW (self), _("History"));
612 gtk_widget_set_can_focus (GTK_WIDGET (self), FALSE);
613 gtk_window_set_default_size (GTK_WINDOW (self), 800, 600);
615 filename = empathy_file_lookup ("empathy-log-window.ui", "libempathy-gtk");
616 gui = empathy_builder_get_file (filename,
617 "vbox1", &self->priv->vbox,
618 "toolbutton_profile", &self->priv->button_profile,
619 "toolbutton_chat", &self->priv->button_chat,
620 "toolbutton_call", &self->priv->button_call,
621 "toolbutton_video", &self->priv->button_video,
622 "toolbutton_accounts", &accounts,
623 "toolbutton_search", &search,
624 "imagemenuitem_close", &closeitem,
625 "treeview_who", &self->priv->treeview_who,
626 "treeview_what", &self->priv->treeview_what,
627 "treeview_when", &self->priv->treeview_when,
628 "scrolledwindow_events", &scrolledwindow_events,
629 "notebook", &self->priv->notebook,
630 "spinner", &self->priv->spinner,
634 empathy_builder_connect (gui, self,
635 "toolbutton_profile", "clicked", toolbutton_profile_clicked,
636 "toolbutton_chat", "clicked", toolbutton_chat_clicked,
637 "toolbutton_call", "clicked", toolbutton_av_clicked,
638 "toolbutton_video", "clicked", toolbutton_av_clicked,
639 "imagemenuitem_delete", "activate", log_window_delete_menu_clicked_cb,
642 gtk_container_add (GTK_CONTAINER (self), self->priv->vbox);
644 g_object_unref (gui);
646 g_signal_connect_swapped (closeitem, "activate",
647 G_CALLBACK (gtk_widget_destroy), self);
649 /* Account chooser for chats */
650 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
652 self->priv->account_chooser = empathy_account_chooser_new ();
653 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
654 empathy_account_chooser_set_has_all_option (account_chooser, TRUE);
655 empathy_account_chooser_set_filter (account_chooser,
656 empathy_account_chooser_filter_has_logs, NULL);
657 empathy_account_chooser_set_all (account_chooser);
659 gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->account_chooser),
660 GTK_STYLE_CLASS_RAISED);
662 g_signal_connect (self->priv->account_chooser, "changed",
663 G_CALLBACK (log_window_chats_accounts_changed_cb),
666 label = gtk_label_new (_("Show"));
668 gtk_box_pack_start (GTK_BOX (vbox),
669 self->priv->account_chooser,
672 gtk_box_pack_start (GTK_BOX (vbox),
676 gtk_widget_show_all (vbox);
677 gtk_container_add (GTK_CONTAINER (accounts), vbox);
680 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
682 self->priv->search_entry = gtk_entry_new ();
683 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
684 GTK_ENTRY_ICON_SECONDARY, "edit-find-symbolic");
685 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
686 GTK_ENTRY_ICON_SECONDARY, FALSE);
688 label = gtk_label_new (_("Search"));
690 gtk_box_pack_start (GTK_BOX (vbox),
691 self->priv->search_entry,
694 gtk_box_pack_start (GTK_BOX (vbox),
698 gtk_widget_show_all (vbox);
699 gtk_container_add (GTK_CONTAINER (search), vbox);
701 g_signal_connect (self->priv->search_entry, "changed",
702 G_CALLBACK (log_window_search_entry_changed_cb),
705 g_signal_connect (self->priv->search_entry, "activate",
706 G_CALLBACK (log_window_search_entry_activate_cb),
709 g_signal_connect (self->priv->search_entry, "icon-press",
710 G_CALLBACK (log_window_search_entry_icon_pressed_cb),
714 log_window_events_setup (self);
715 log_window_who_setup (self);
716 log_window_what_setup (self);
717 log_window_when_setup (self);
719 log_window_create_observer (self);
721 log_window_who_populate (self);
724 self->priv->webview = webkit_web_view_new ();
725 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow_events),
726 GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
727 gtk_container_add (GTK_CONTAINER (scrolledwindow_events),
728 self->priv->webview);
729 gtk_widget_show (self->priv->webview);
731 empathy_webkit_bind_font_setting (WEBKIT_WEB_VIEW (self->priv->webview),
732 self->priv->gsettings_desktop,
733 EMPATHY_PREFS_DESKTOP_INTERFACE_FONT_NAME);
735 filename = empathy_file_lookup ("empathy-log-window.html", "data");
736 gfile = g_file_new_for_path (filename);
739 uri = g_file_get_uri (gfile);
740 webkit_web_view_load_uri (WEBKIT_WEB_VIEW (self->priv->webview), uri);
741 g_object_unref (gfile);
744 /* handle all navigation externally */
745 g_signal_connect (self->priv->webview, "navigation-policy-decision-requested",
746 G_CALLBACK (events_webview_handle_navigation), self);
748 /* listen to changes to the treemodel */
749 g_signal_connect (self->priv->store_events, "row-inserted",
750 G_CALLBACK (store_events_row_inserted), self);
751 g_signal_connect (self->priv->store_events, "row-changed",
752 G_CALLBACK (store_events_row_changed), self);
753 g_signal_connect (self->priv->store_events, "row-deleted",
754 G_CALLBACK (store_events_row_deleted), self);
755 g_signal_connect (self->priv->store_events, "rows-reordered",
756 G_CALLBACK (store_events_rows_reordered), self);
757 g_signal_connect (self->priv->store_events, "row-has-child-toggled",
758 G_CALLBACK (store_events_has_child_rows), self);
760 /* track clicked row */
761 g_signal_connect (self->priv->webview, "button-press-event",
762 G_CALLBACK (log_window_events_button_press_event), self);
764 log_window_update_buttons_sensitivity (self);
765 gtk_widget_show (GTK_WIDGET (self));
767 empathy_geometry_bind (GTK_WINDOW (self), "log-window");
771 empathy_log_window_show (TpAccount *account,
772 const gchar *chat_id,
773 gboolean is_chatroom,
776 log_window = g_object_new (EMPATHY_TYPE_LOG_WINDOW, NULL);
778 gtk_window_present (GTK_WINDOW (log_window));
780 if (account != NULL && chat_id != NULL)
781 select_account_once_ready (log_window, account, chat_id, is_chatroom);
784 gtk_window_set_transient_for (GTK_WINDOW (log_window),
785 GTK_WINDOW (parent));
787 return GTK_WIDGET (log_window);
791 account_equal (TpAccount *a,
794 return g_str_equal (tp_proxy_get_object_path (a),
795 tp_proxy_get_object_path (b));
799 entity_equal (TplEntity *a,
802 return g_str_equal (tpl_entity_get_identifier (a),
803 tpl_entity_get_identifier (b));
807 is_same_confroom (TplEvent *e1,
810 TplEntity *sender1 = tpl_event_get_sender (e1);
811 TplEntity *receiver1 = tpl_event_get_receiver (e1);
812 TplEntity *sender2 = tpl_event_get_sender (e2);
813 TplEntity *receiver2 = tpl_event_get_receiver (e2);
814 TplEntity *room1, *room2;
816 if (receiver1 == NULL || receiver2 == NULL)
819 if (tpl_entity_get_entity_type (sender1) == TPL_ENTITY_ROOM)
821 else if (tpl_entity_get_entity_type (receiver1) == TPL_ENTITY_ROOM)
826 if (tpl_entity_get_entity_type (sender2) == TPL_ENTITY_ROOM)
828 else if (tpl_entity_get_entity_type (receiver2) == TPL_ENTITY_ROOM)
833 return g_str_equal (tpl_entity_get_identifier (room1),
834 tpl_entity_get_identifier (room2));
838 maybe_refresh_logs (TpChannel *channel,
841 GList *accounts = NULL, *entities = NULL, *dates = NULL;
843 TplEventTypeMask event_mask;
844 GDate *anytime = NULL, *today = NULL;
845 GDateTime *now = NULL;
846 gboolean refresh = FALSE;
850 if (!log_window_get_selected (log_window,
851 &accounts, &entities, &anyone, &dates, &event_mask, NULL))
853 DEBUG ("Could not get selected rows");
857 type = tp_channel_get_channel_type (channel);
859 /* If the channel type is not in the What pane, whatever has happened
860 * won't be displayed in the events pane. */
861 if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_TEXT) &&
862 !(event_mask & TPL_EVENT_MASK_TEXT))
864 if ((!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA) ||
865 !tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_CALL)) &&
866 !(event_mask & TPL_EVENT_MASK_CALL))
869 anytime = g_date_new_dmy (2, 1, -1);
870 now = g_date_time_new_now_local ();
871 today = g_date_new_dmy (g_date_time_get_day_of_month (now),
872 g_date_time_get_month (now),
873 g_date_time_get_year (now));
875 /* If Today (or anytime) isn't selected, anything that has happened now
876 * won't be displayed. */
877 if (!g_list_find_custom (dates, anytime, (GCompareFunc) g_date_compare) &&
878 !g_list_find_custom (dates, today, (GCompareFunc) g_date_compare))
887 for (acc = accounts, ent = entities;
888 acc != NULL && ent != NULL;
889 acc = g_list_next (acc), ent = g_list_next (ent))
891 if (!account_equal (account, acc->data))
894 if (!tp_strdiff (tp_channel_get_identifier (channel),
895 tpl_entity_get_identifier (ent->data)))
903 tp_clear_pointer (&anytime, g_date_free);
904 tp_clear_pointer (&today, g_date_free);
905 tp_clear_pointer (&now, g_date_time_unref);
906 g_list_free_full (accounts, g_object_unref);
907 g_list_free_full (entities, g_object_unref);
908 g_list_free_full (dates, (GFreeFunc) g_date_free);
912 DEBUG ("Refreshing logs after received event");
914 /* FIXME: We need to populate the entities in case we
915 * didn't have any previous logs with this contact. */
916 log_window_chats_get_messages (log_window, FALSE);
921 on_msg_sent (TpTextChannel *channel,
922 TpSignalledMessage *message,
925 EmpathyLogWindow *self)
927 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
929 maybe_refresh_logs (TP_CHANNEL (channel), account);
933 on_msg_received (TpTextChannel *channel,
934 TpSignalledMessage *message,
935 EmpathyLogWindow *self)
937 TpMessage *msg = TP_MESSAGE (message);
938 TpChannelTextMessageType type = tp_message_get_message_type (msg);
939 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
941 if (type != TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL &&
942 type != TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION)
945 maybe_refresh_logs (TP_CHANNEL (channel), account);
949 on_channel_ended (TpChannel *channel,
953 EmpathyLogWindow *self)
955 if (self->priv->channels != NULL)
956 g_hash_table_remove (self->priv->channels, channel);
960 on_call_ended (TpChannel *channel,
964 EmpathyLogWindow *self)
966 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
968 maybe_refresh_logs (channel, account);
970 if (self->priv->channels != NULL)
971 g_hash_table_remove (self->priv->channels, channel);
975 observe_channels (TpSimpleObserver *observer,
977 TpConnection *connection,
979 TpChannelDispatchOperation *dispatch_operation,
981 TpObserveChannelsContext *context,
984 EmpathyLogWindow *self = user_data;
988 for (l = channels; l != NULL; l = g_list_next (l))
990 TpChannel *channel = l->data;
991 const gchar *type = tp_channel_get_channel_type (channel);
993 if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_TEXT))
995 TpTextChannel *text_channel = TP_TEXT_CHANNEL (channel);
997 g_hash_table_insert (self->priv->channels,
998 g_object_ref (channel), g_object_ref (account));
1000 tp_g_signal_connect_object (text_channel, "message-sent",
1001 G_CALLBACK (on_msg_sent), self, 0);
1002 tp_g_signal_connect_object (text_channel, "message-received",
1003 G_CALLBACK (on_msg_received), self, 0);
1004 tp_g_signal_connect_object (channel, "invalidated",
1005 G_CALLBACK (on_channel_ended), self, 0);
1007 else if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_CALL) ||
1008 !tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA))
1010 g_hash_table_insert (self->priv->channels,
1011 g_object_ref (channel), g_object_ref (account));
1013 tp_g_signal_connect_object (channel, "invalidated",
1014 G_CALLBACK (on_call_ended), self, 0);
1018 g_warning ("Unknown channel type: %s", type);
1022 tp_observe_channels_context_accept (context);
1026 log_window_create_observer (EmpathyLogWindow *self)
1028 TpAccountManager *am;
1030 am = tp_account_manager_dup ();
1032 self->priv->observer = tp_simple_observer_new_with_am (am, TRUE, "LogWindow",
1033 TRUE, observe_channels,
1034 g_object_ref (self), g_object_unref);
1036 self->priv->channels = g_hash_table_new_full (g_direct_hash, g_direct_equal,
1037 g_object_unref, g_object_unref);
1039 tp_base_client_take_observer_filter (self->priv->observer,
1041 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1042 TP_IFACE_CHANNEL_TYPE_TEXT,
1044 tp_base_client_take_observer_filter (self->priv->observer,
1046 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1047 TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA,
1049 tp_base_client_take_observer_filter (self->priv->observer,
1051 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1052 TP_IFACE_CHANNEL_TYPE_CALL,
1055 tp_base_client_register (self->priv->observer, NULL);
1057 g_object_unref (am);
1061 event_get_target (TplEvent *event)
1063 TplEntity *sender = tpl_event_get_sender (event);
1064 TplEntity *receiver = tpl_event_get_receiver (event);
1066 if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
1073 model_is_parent (GtkTreeModel *model,
1077 TplEvent *stored_event;
1080 gboolean found = FALSE;
1083 if (gtk_tree_model_iter_parent (model, &parent, iter))
1086 gtk_tree_model_get (model, iter,
1087 COL_EVENTS_ACCOUNT, &account,
1088 COL_EVENTS_TARGET, &target,
1089 COL_EVENTS_EVENT, &stored_event,
1092 if (G_OBJECT_TYPE (event) == G_OBJECT_TYPE (stored_event) &&
1093 account_equal (account, tpl_event_get_account (event)) &&
1094 (entity_equal (target, event_get_target (event)) ||
1095 is_same_confroom (event, stored_event)))
1100 gtk_tree_model_iter_nth_child (model, &child, iter,
1101 gtk_tree_model_iter_n_children (model, iter) - 1);
1103 gtk_tree_model_get (model, &child,
1104 COL_EVENTS_TS, ×tamp,
1107 if (ABS (tpl_event_get_timestamp (event) - timestamp) < MAX_GAP)
1109 /* The gap is smaller than 30 min */
1114 g_object_unref (stored_event);
1115 g_object_unref (account);
1116 g_object_unref (target);
1122 get_display_string_for_chat_message (EmpathyMessage *message,
1125 EmpathyContact *sender, *receiver, *target;
1126 TplEntity *ent_sender, *ent_receiver;
1127 const gchar *format;
1129 sender = empathy_message_get_sender (message);
1130 receiver = empathy_message_get_receiver (message);
1132 ent_sender = tpl_event_get_sender (event);
1133 ent_receiver = tpl_event_get_receiver (event);
1135 /* If this is a MUC, we want to show "Chat in <room>". */
1136 if (tpl_entity_get_entity_type (ent_sender) == TPL_ENTITY_ROOM ||
1137 (ent_receiver != NULL &&
1138 tpl_entity_get_entity_type (ent_receiver) == TPL_ENTITY_ROOM))
1139 format = _("Chat in %s");
1141 format = _("Chat with %s");
1143 if (tpl_entity_get_entity_type (ent_sender) == TPL_ENTITY_ROOM)
1145 else if (ent_receiver != NULL &&
1146 tpl_entity_get_entity_type (ent_receiver) == TPL_ENTITY_ROOM)
1148 else if (empathy_contact_is_user (sender))
1153 return g_markup_printf_escaped (format, empathy_contact_get_alias (target));
1157 get_parent_iter_for_message (TplEvent *event,
1158 EmpathyMessage *message,
1159 GtkTreeIter *parent)
1161 GtkTreeStore *store;
1162 GtkTreeModel *model;
1164 gboolean parent_found = FALSE;
1167 store = log_window->priv->store_events;
1168 model = GTK_TREE_MODEL (store);
1170 for (next = gtk_tree_model_get_iter_first (model, &iter);
1172 next = gtk_tree_model_iter_next (model, &iter))
1174 if ((parent_found = model_is_parent (model, &iter, event)))
1185 gchar *body, *pretty_date;
1187 date = g_date_time_new_from_unix_local (
1188 tpl_event_get_timestamp (event));
1190 pretty_date = g_date_time_format (date,
1191 C_("A date with the time", "%A, %e %B %Y %X"));
1193 body = get_display_string_for_chat_message (message, event);
1195 gtk_tree_store_append (store, &iter, NULL);
1196 gtk_tree_store_set (store, &iter,
1197 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1198 COL_EVENTS_PRETTY_DATE, pretty_date,
1199 COL_EVENTS_TEXT, body,
1200 COL_EVENTS_ICON, "format-justify-fill",
1201 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1202 COL_EVENTS_TARGET, event_get_target (event),
1203 COL_EVENTS_EVENT, event,
1209 g_free (pretty_date);
1210 g_date_time_unref (date);
1214 static const gchar *
1215 get_icon_for_event (TplEvent *event)
1217 const gchar *icon = NULL;
1219 if (TPL_IS_TEXT_EVENT (event))
1221 TplTextEvent *text = TPL_TEXT_EVENT (event);
1223 if (!tp_str_empty (tpl_text_event_get_supersedes_token (text)))
1224 icon = EMPATHY_IMAGE_EDIT_MESSAGE;
1226 else if (TPL_IS_CALL_EVENT (event))
1228 TplCallEvent *call = TPL_CALL_EVENT (event);
1229 TpCallStateChangeReason reason = tpl_call_event_get_end_reason (call);
1230 TplEntity *sender = tpl_event_get_sender (event);
1231 TplEntity *receiver = tpl_event_get_receiver (event);
1233 if (reason == TP_CALL_STATE_CHANGE_REASON_NO_ANSWER)
1234 icon = EMPATHY_IMAGE_CALL_MISSED;
1235 else if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
1236 icon = EMPATHY_IMAGE_CALL_OUTGOING;
1237 else if (tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF)
1238 icon = EMPATHY_IMAGE_CALL_INCOMING;
1245 log_window_append_chat_message (TplEvent *event,
1246 EmpathyMessage *message)
1248 GtkTreeStore *store = log_window->priv->store_events;
1249 GtkTreeIter iter, parent;
1250 gchar *pretty_date, *alias, *body;
1253 EmpathyStringParser *parsers;
1256 date = g_date_time_new_from_unix_local (
1257 tpl_event_get_timestamp (event));
1259 pretty_date = g_date_time_format (date, "%X");
1261 get_parent_iter_for_message (event, message, &parent);
1263 alias = g_markup_escape_text (
1264 tpl_entity_get_alias (tpl_event_get_sender (event)), -1);
1266 /* escape the text */
1267 parsers = empathy_webkit_get_string_parser (
1268 g_settings_get_boolean (log_window->priv->gsettings_chat,
1269 EMPATHY_PREFS_CHAT_SHOW_SMILEYS));
1270 msg = g_string_new ("");
1272 empathy_string_parser_substr (empathy_message_get_body (message), -1,
1275 msg_escaped = g_strescape (msg->str, NULL);
1277 if (tpl_text_event_get_message_type (TPL_TEXT_EVENT (event))
1278 == TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION)
1280 /* Translators: this is an emote: '* Danielle waves' */
1281 body = g_strdup_printf (_("<i>* %s %s</i>"), alias, msg_escaped);
1285 /* Translators: this is a message: 'Danielle: hello'
1286 * The string in bold is the sender's name */
1287 body = g_strdup_printf (_("<b>%s:</b> %s"), alias, msg_escaped);
1290 g_free (msg_escaped);
1292 gtk_tree_store_append (store, &iter, &parent);
1293 gtk_tree_store_set (store, &iter,
1294 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1295 COL_EVENTS_PRETTY_DATE, pretty_date,
1296 COL_EVENTS_TEXT, body,
1297 COL_EVENTS_ICON, get_icon_for_event (event),
1298 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1299 COL_EVENTS_TARGET, event_get_target (event),
1300 COL_EVENTS_EVENT, event,
1303 g_string_free (msg, TRUE);
1306 g_free (pretty_date);
1307 g_date_time_unref (date);
1311 log_window_append_call (TplEvent *event,
1312 EmpathyMessage *message)
1314 TplCallEvent *call = TPL_CALL_EVENT (event);
1315 GtkTreeStore *store = log_window->priv->store_events;
1316 GtkTreeIter iter, child;
1317 gchar *pretty_date, *duration, *finished;
1318 GDateTime *started_date, *finished_date;
1321 /* If searching, only add the call if the search string appears anywhere */
1322 if (!EMP_STR_EMPTY (log_window->priv->last_find))
1324 if (strstr (tpl_entity_get_identifier (tpl_event_get_sender (event)),
1325 log_window->priv->last_find) == NULL &&
1326 strstr (tpl_entity_get_identifier (tpl_event_get_receiver (event)),
1327 log_window->priv->last_find) == NULL &&
1328 strstr (tpl_call_event_get_detailed_end_reason (call),
1329 log_window->priv->last_find) == NULL)
1331 DEBUG ("TplCallEvent doesn't match search string, ignoring");
1336 started_date = g_date_time_new_from_unix_local (
1337 tpl_event_get_timestamp (event));
1339 pretty_date = g_date_time_format (started_date,
1340 C_("A date with the time", "%A, %e %B %Y %X"));
1342 gtk_tree_store_append (store, &iter, NULL);
1343 gtk_tree_store_set (store, &iter,
1344 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1345 COL_EVENTS_PRETTY_DATE, pretty_date,
1346 COL_EVENTS_TEXT, empathy_message_get_body (message),
1347 COL_EVENTS_ICON, get_icon_for_event (event),
1348 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1349 COL_EVENTS_TARGET, event_get_target (event),
1350 COL_EVENTS_EVENT, event,
1353 if (tpl_call_event_get_end_reason (call) != TP_CALL_STATE_CHANGE_REASON_NO_ANSWER)
1358 span = tpl_call_event_get_duration (TPL_CALL_EVENT (event));
1362 tmp = g_strdup_printf ("%" G_GINT64_FORMAT, span);
1363 duration = g_strdup_printf (
1364 ngettext ("%s second", "%s seconds", span), tmp);
1369 tmp = g_strdup_printf ("%" G_GINT64_FORMAT, span / 60);
1370 duration = g_strdup_printf (
1371 ngettext ("%s minute", "%s minutes", span / 60), tmp);
1375 finished_date = g_date_time_add (started_date, -span);
1376 finished = g_date_time_format (finished_date, "%X");
1377 g_date_time_unref (finished_date);
1379 body = g_strdup_printf (_("Call took %s, ended at %s"),
1380 duration, finished);
1385 gtk_tree_store_append (store, &child, &iter);
1386 gtk_tree_store_set (store, &child,
1387 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1388 COL_EVENTS_TEXT, body,
1389 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1390 COL_EVENTS_TARGET, event_get_target (event),
1391 COL_EVENTS_EVENT, event,
1397 g_free (pretty_date);
1398 g_date_time_unref (started_date);
1402 log_window_append_message (TplEvent *event,
1403 EmpathyMessage *message)
1405 if (TPL_IS_TEXT_EVENT (event))
1406 log_window_append_chat_message (event, message);
1407 else if (TPL_IS_CALL_EVENT (event))
1408 log_window_append_call (event, message);
1410 DEBUG ("Message type not handled");
1414 add_all_accounts_and_entities (GList **accounts,
1418 GtkTreeModel *model;
1421 view = GTK_TREE_VIEW (log_window->priv->treeview_who);
1422 model = gtk_tree_view_get_model (view);
1424 if (!gtk_tree_model_get_iter_first (model, &iter))
1433 gtk_tree_model_get (model, &iter,
1434 COL_WHO_ACCOUNT, &account,
1435 COL_WHO_TARGET, &entity,
1436 COL_WHO_TYPE, &type,
1439 if (type != COL_TYPE_NORMAL)
1442 if (accounts != NULL)
1443 *accounts = g_list_append (*accounts, account);
1445 if (entities != NULL)
1446 *entities = g_list_append (*entities, entity);
1448 while (gtk_tree_model_iter_next (model, &iter));
1452 log_window_get_selected (EmpathyLogWindow *self,
1457 TplEventTypeMask *event_mask,
1458 EventSubtype *subtype)
1461 GtkTreeModel *model;
1462 GtkTreeSelection *selection;
1464 TplEventTypeMask ev = 0;
1465 EventSubtype st = 0;
1469 view = GTK_TREE_VIEW (self->priv->treeview_who);
1470 model = gtk_tree_view_get_model (view);
1471 selection = gtk_tree_view_get_selection (view);
1473 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1477 if (accounts != NULL)
1479 if (entities != NULL)
1484 for (l = paths; l != NULL; l = l->next)
1486 GtkTreePath *path = l->data;
1490 gtk_tree_model_get_iter (model, &iter, path);
1491 gtk_tree_model_get (model, &iter,
1492 COL_WHO_ACCOUNT, &account,
1493 COL_WHO_TARGET, &entity,
1494 COL_WHO_TYPE, &type,
1497 if (type == COL_TYPE_ANY)
1499 if (accounts != NULL || entities != NULL)
1500 add_all_accounts_and_entities (accounts, entities);
1506 if (accounts != NULL)
1507 *accounts = g_list_append (*accounts, g_object_ref (account));
1509 if (entities != NULL)
1510 *entities = g_list_append (*entities, g_object_ref (entity));
1512 g_object_unref (account);
1513 g_object_unref (entity);
1515 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1517 view = GTK_TREE_VIEW (self->priv->treeview_what);
1518 model = gtk_tree_view_get_model (view);
1519 selection = gtk_tree_view_get_selection (view);
1521 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1522 for (l = paths; l != NULL; l = l->next)
1524 GtkTreePath *path = l->data;
1525 TplEventTypeMask mask;
1526 EventSubtype submask;
1528 gtk_tree_model_get_iter (model, &iter, path);
1529 gtk_tree_model_get (model, &iter,
1530 COL_WHAT_TYPE, &mask,
1531 COL_WHAT_SUBTYPE, &submask,
1537 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1539 view = GTK_TREE_VIEW (self->priv->treeview_when);
1540 model = gtk_tree_view_get_model (view);
1541 selection = gtk_tree_view_get_selection (view);
1547 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1548 for (l = paths; l != NULL; l = l->next)
1550 GtkTreePath *path = l->data;
1553 gtk_tree_model_get_iter (model, &iter, path);
1554 gtk_tree_model_get (model, &iter,
1555 COL_WHEN_DATE, &date,
1558 *dates = g_list_append (*dates, date);
1560 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1563 if (event_mask != NULL)
1566 if (subtype != NULL)
1573 model_has_entity (GtkTreeModel *model,
1578 TplLogSearchHit *hit = data;
1581 gboolean ret = FALSE;
1583 gtk_tree_model_get (model, iter,
1585 COL_WHO_ACCOUNT, &a,
1588 if (e != NULL && entity_equal (hit->target, e) &&
1589 a != NULL && account_equal (hit->account, a))
1591 ret = has_element = TRUE;
1594 tp_clear_object (&e);
1595 tp_clear_object (&a);
1601 model_has_date (GtkTreeModel *model,
1609 gtk_tree_model_get (model, iter,
1613 if (!g_date_compare (date, d))
1625 get_events_for_date (TplActionChain *chain, gpointer user_data);
1628 populate_events_from_search_hits (GList *accounts,
1632 TplEventTypeMask event_mask;
1633 EventSubtype subtype;
1636 gboolean is_anytime = FALSE;
1638 if (!log_window_get_selected (log_window,
1639 NULL, NULL, NULL, NULL, &event_mask, &subtype))
1642 anytime = g_date_new_dmy (2, 1, -1);
1643 if (g_list_find_custom (dates, anytime, (GCompareFunc) g_date_compare))
1646 for (l = log_window->priv->hits; l != NULL; l = l->next)
1648 TplLogSearchHit *hit = l->data;
1650 gboolean found = FALSE;
1652 /* Protect against invalid data (corrupt or old log files). */
1653 if (hit->account == NULL || hit->target == NULL)
1656 for (acc = accounts, targ = targets;
1657 acc != NULL && targ != NULL && !found;
1658 acc = acc->next, targ = targ->next)
1660 TpAccount *account = acc->data;
1661 TplEntity *target = targ->data;
1663 if (account_equal (hit->account, account) &&
1664 entity_equal (hit->target, target))
1672 g_list_find_custom (dates, hit->date, (GCompareFunc) g_date_compare)
1677 ctx = ctx_new (log_window, hit->account, hit->target, hit->date,
1678 event_mask, subtype, log_window->priv->count);
1679 _tpl_action_chain_append (log_window->priv->chain,
1680 get_events_for_date, ctx);
1685 _tpl_action_chain_start (log_window->priv->chain);
1687 g_date_free (anytime);
1691 format_date_for_display (GDate *date)
1697 /* g_date_strftime sucks */
1699 now = g_date_new ();
1700 g_date_set_time_t (now, time (NULL));
1702 days_elapsed = g_date_days_between (date, now);
1704 if (days_elapsed < 0)
1708 else if (days_elapsed == 0)
1710 text = g_strdup (_("Today"));
1712 else if (days_elapsed == 1)
1714 text = g_strdup (_("Yesterday"));
1720 dt = g_date_time_new_utc (g_date_get_year (date),
1721 g_date_get_month (date), g_date_get_day (date),
1724 if (days_elapsed <= 7)
1725 text = g_date_time_format (dt, "%A");
1727 text = g_date_time_format (dt,
1728 /* Translators: A date such as '23 May 2010' (strftime format) */
1731 g_date_time_unref (dt);
1740 add_date_if_needed (EmpathyLogWindow *self,
1743 GtkTreeModel *model;
1744 GtkListStore *store;
1747 model = gtk_tree_view_get_model (GTK_TREE_VIEW (
1748 log_window->priv->treeview_when));
1749 store = GTK_LIST_STORE (model);
1751 /* Add the date if it's not already there */
1752 has_element = FALSE;
1753 gtk_tree_model_foreach (model, model_has_date, date);
1757 text = format_date_for_display (date);
1759 gtk_list_store_insert_with_values (store, NULL, -1,
1760 COL_WHEN_DATE, date,
1761 COL_WHEN_TEXT, text,
1762 COL_WHEN_ICON, CALENDAR_ICON,
1769 populate_dates_from_search_hits (GList *accounts,
1774 GtkTreeModel *model;
1775 GtkListStore *store;
1776 GtkTreeSelection *selection;
1779 if (log_window == NULL)
1782 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
1783 model = gtk_tree_view_get_model (view);
1784 store = GTK_LIST_STORE (model);
1785 selection = gtk_tree_view_get_selection (view);
1787 for (l = log_window->priv->hits; l != NULL; l = l->next)
1789 TplLogSearchHit *hit = l->data;
1791 gboolean found = FALSE;
1793 /* Protect against invalid data (corrupt or old log files). */
1794 if (hit->account == NULL || hit->target == NULL)
1797 for (acc = accounts, targ = targets;
1798 acc != NULL && targ != NULL && !found;
1799 acc = acc->next, targ = targ->next)
1801 TpAccount *account = acc->data;
1802 TplEntity *target = targ->data;
1804 if (account_equal (hit->account, account) &&
1805 entity_equal (hit->target, target))
1812 add_date_if_needed (log_window, hit->date);
1815 if (gtk_tree_model_get_iter_first (model, &iter))
1819 date = g_date_new_dmy (1, 1, -1),
1821 gtk_list_store_prepend (store, &iter);
1822 gtk_list_store_set (store, &iter,
1823 COL_WHEN_DATE, date,
1824 COL_WHEN_TEXT, "separator",
1829 date = g_date_new_dmy (2, 1, -1),
1830 gtk_list_store_prepend (store, &iter);
1831 gtk_list_store_set (store, &iter,
1832 COL_WHEN_DATE, date,
1833 COL_WHEN_TEXT, _("Anytime"),
1838 if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 2))
1839 gtk_tree_selection_select_iter (selection, &iter);
1844 add_event_to_store (EmpathyLogWindow *self,
1848 GtkListStore *store;
1849 TplEntityType type = tpl_entity_get_entity_type (entity);
1850 EmpathyContact *contact;
1853 gboolean room = type == TPL_ENTITY_ROOM;
1855 store = GTK_LIST_STORE (gtk_tree_view_get_model (
1856 GTK_TREE_VIEW (log_window->priv->treeview_who)));
1858 contact = empathy_contact_from_tpl_contact (account, entity);
1860 name = empathy_contact_get_alias (contact);
1861 sort_key = g_utf8_collate_key (name, -1);
1863 gtk_list_store_insert_with_values (store, NULL, -1,
1864 COL_WHO_TYPE, COL_TYPE_NORMAL,
1865 COL_WHO_ICON, room ? EMPATHY_IMAGE_GROUP_MESSAGE
1866 : EMPATHY_IMAGE_AVATAR_DEFAULT,
1868 COL_WHO_NAME_SORT_KEY, sort_key,
1869 COL_WHO_ID, tpl_entity_get_identifier (entity),
1870 COL_WHO_ACCOUNT, account,
1871 COL_WHO_TARGET, entity,
1875 g_object_unref (contact);
1879 populate_entities_from_search_hits (void)
1881 EmpathyAccountChooser *account_chooser;
1884 GtkTreeModel *model;
1885 GtkTreeSelection *selection;
1887 GtkListStore *store;
1890 view = GTK_TREE_VIEW (log_window->priv->treeview_who);
1891 model = gtk_tree_view_get_model (view);
1892 store = GTK_LIST_STORE (model);
1893 selection = gtk_tree_view_get_selection (view);
1895 gtk_list_store_clear (store);
1897 account_chooser = EMPATHY_ACCOUNT_CHOOSER (log_window->priv->account_chooser);
1898 account = empathy_account_chooser_get_account (account_chooser);
1900 for (l = log_window->priv->hits; l; l = l->next)
1902 TplLogSearchHit *hit = l->data;
1904 /* Protect against invalid data (corrupt or old log files). */
1905 if (hit->account == NULL || hit->target == NULL)
1908 /* Filter based on the selected account */
1909 if (account != NULL && !account_equal (account, hit->account))
1912 /* Add the entity if it's not already there */
1913 has_element = FALSE;
1914 gtk_tree_model_foreach (model, model_has_entity, hit);
1917 add_event_to_store (log_window, hit->account, hit->target);
1921 if (gtk_tree_model_get_iter_first (model, &iter))
1923 gtk_list_store_prepend (store, &iter);
1924 gtk_list_store_set (store, &iter,
1925 COL_WHO_TYPE, COL_TYPE_SEPARATOR,
1926 COL_WHO_NAME, "separator",
1929 gtk_list_store_prepend (store, &iter);
1930 gtk_list_store_set (store, &iter,
1931 COL_WHO_TYPE, COL_TYPE_ANY,
1932 COL_WHO_NAME, _("Anyone"),
1936 /* Select 'Anyone' */
1937 if (gtk_tree_model_get_iter_first (model, &iter))
1938 gtk_tree_selection_select_iter (selection, &iter);
1942 log_manager_searched_new_cb (GObject *manager,
1943 GAsyncResult *result,
1948 GtkTreeSelection *selection;
1949 GError *error = NULL;
1951 if (log_window == NULL)
1954 if (!tpl_log_manager_search_finish (TPL_LOG_MANAGER (manager),
1955 result, &hits, &error))
1957 DEBUG ("%s. Aborting", error->message);
1958 g_error_free (error);
1962 tp_clear_pointer (&log_window->priv->hits, tpl_log_manager_search_free);
1963 log_window->priv->hits = hits;
1965 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
1966 selection = gtk_tree_view_get_selection (view);
1968 g_signal_handlers_unblock_by_func (selection,
1969 log_window_when_changed_cb,
1972 populate_entities_from_search_hits ();
1976 log_window_find_populate (EmpathyLogWindow *self,
1977 const gchar *search_criteria)
1980 GtkTreeModel *model;
1981 GtkTreeSelection *selection;
1982 GtkListStore *store;
1984 gtk_tree_store_clear (self->priv->store_events);
1986 view = GTK_TREE_VIEW (self->priv->treeview_who);
1987 model = gtk_tree_view_get_model (view);
1988 store = GTK_LIST_STORE (model);
1990 gtk_list_store_clear (store);
1992 view = GTK_TREE_VIEW (self->priv->treeview_when);
1993 model = gtk_tree_view_get_model (view);
1994 store = GTK_LIST_STORE (model);
1995 selection = gtk_tree_view_get_selection (view);
1997 gtk_list_store_clear (store);
1999 if (EMP_STR_EMPTY (search_criteria))
2001 tp_clear_pointer (&self->priv->hits, tpl_log_manager_search_free);
2002 webkit_web_view_set_highlight_text_matches (
2003 WEBKIT_WEB_VIEW (self->priv->webview), FALSE);
2004 log_window_who_populate (self);
2008 g_signal_handlers_block_by_func (selection,
2009 log_window_when_changed_cb,
2012 /* highlight the search text */
2013 webkit_web_view_mark_text_matches (WEBKIT_WEB_VIEW (self->priv->webview),
2014 search_criteria, FALSE, 0);
2016 tpl_log_manager_search_async (self->priv->log_manager,
2017 search_criteria, TPL_EVENT_MASK_ANY,
2018 log_manager_searched_new_cb, NULL);
2022 start_find_search (EmpathyLogWindow *self)
2026 str = gtk_entry_get_text (GTK_ENTRY (self->priv->search_entry));
2028 /* Don't find the same crap again */
2029 if (self->priv->last_find && !tp_strdiff (self->priv->last_find, str))
2032 g_free (self->priv->last_find);
2033 self->priv->last_find = g_strdup (str);
2035 log_window_find_populate (self, str);
2041 log_window_search_entry_changed_cb (GtkWidget *entry,
2042 EmpathyLogWindow *self)
2046 str = gtk_entry_get_text (GTK_ENTRY (self->priv->search_entry));
2048 if (!tp_str_empty (str))
2050 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
2051 GTK_ENTRY_ICON_SECONDARY, "edit-clear-symbolic");
2052 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
2053 GTK_ENTRY_ICON_SECONDARY, TRUE);
2057 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
2058 GTK_ENTRY_ICON_SECONDARY, "edit-find-symbolic");
2059 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
2060 GTK_ENTRY_ICON_SECONDARY, FALSE);
2063 if (self->priv->source != 0)
2064 g_source_remove (self->priv->source);
2065 self->priv->source = g_timeout_add (500, (GSourceFunc) start_find_search,
2070 log_window_search_entry_activate_cb (GtkWidget *entry,
2071 EmpathyLogWindow *self)
2073 start_find_search (self);
2077 log_window_search_entry_icon_pressed_cb (GtkEntry *entry,
2078 GtkEntryIconPosition icon_pos,
2082 if (icon_pos != GTK_ENTRY_ICON_SECONDARY)
2085 gtk_entry_buffer_set_text (gtk_entry_get_buffer (entry),
2090 do_update_buttons_sensitivity (EmpathyLogWindow *self)
2092 EmpathyCapabilities capabilities;
2093 gboolean profile, chat, call, video;
2095 tp_clear_object (&self->priv->button_video_binding);
2097 if (self->priv->selected_contact != NULL)
2099 capabilities = empathy_contact_get_capabilities (
2100 self->priv->selected_contact);
2102 profile = chat = TRUE;
2103 call = capabilities & EMPATHY_CAPABILITIES_AUDIO;
2104 video = capabilities & EMPATHY_CAPABILITIES_VIDEO;
2108 profile = chat = call = video = FALSE;
2111 gtk_widget_set_sensitive (self->priv->button_profile, profile);
2112 gtk_widget_set_sensitive (self->priv->button_chat, chat);
2113 gtk_widget_set_sensitive (self->priv->button_call, call);
2117 self->priv->button_video_binding = g_object_bind_property (
2118 self->priv->camera_monitor, "available",
2119 self->priv->button_video, "sensitive",
2120 G_BINDING_SYNC_CREATE);
2124 /* Don't override the binding */
2125 gtk_widget_set_sensitive (self->priv->button_video, video);
2130 contact_capabilities_changed_cb (EmpathyContact *contact,
2132 EmpathyLogWindow *self)
2134 do_update_buttons_sensitivity (self);
2138 log_window_update_buttons_sensitivity (EmpathyLogWindow *self)
2141 GtkTreeModel *model;
2142 GtkTreeSelection *selection;
2149 if (self->priv->selected_contact != NULL)
2151 g_signal_handlers_disconnect_by_func (self->priv->selected_contact,
2152 contact_capabilities_changed_cb, self);
2154 tp_clear_object (&self->priv->selected_contact);
2157 view = GTK_TREE_VIEW (self->priv->treeview_who);
2158 model = gtk_tree_view_get_model (view);
2159 selection = gtk_tree_view_get_selection (view);
2161 if (!gtk_tree_model_get_iter_first (model, &iter))
2164 if (gtk_tree_selection_count_selected_rows (selection) != 1)
2167 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2170 paths = gtk_tree_selection_get_selected_rows (selection, &model);
2171 g_return_if_fail (paths != NULL);
2174 gtk_tree_model_get_iter (model, &iter, path);
2175 gtk_tree_model_get (model, &iter,
2176 COL_WHO_ACCOUNT, &account,
2177 COL_WHO_TARGET, &target,
2180 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
2182 self->priv->selected_contact = empathy_contact_from_tpl_contact (account,
2185 g_object_unref (account);
2186 g_object_unref (target);
2191 /* If the Who pane doesn't contain a contact (e.g. it has many
2192 * selected, or has 'Anyone', let's try to get the contact from
2193 * the selected event. */
2195 if (self->priv->events_contact != NULL)
2196 self->priv->selected_contact = g_object_ref (self->priv->events_contact);
2199 if (self->priv->selected_contact != NULL)
2201 tp_g_signal_connect_object (self->priv->selected_contact,
2202 "notify::capabilities", G_CALLBACK (contact_capabilities_changed_cb),
2206 do_update_buttons_sensitivity (self);
2210 log_window_update_what_iter_sensitivity (GtkTreeModel *model,
2214 GtkTreeStore *store = GTK_TREE_STORE (model);
2218 gtk_tree_store_set (store, iter,
2219 COL_WHAT_SENSITIVE, sensitive,
2222 for (next = gtk_tree_model_iter_children (model, &child, iter);
2224 next = gtk_tree_model_iter_next (model, &child))
2226 gtk_tree_store_set (store, &child,
2227 COL_WHAT_SENSITIVE, sensitive,
2233 log_window_update_what_sensitivity (EmpathyLogWindow *self)
2236 GtkTreeModel *model;
2238 GList *accounts, *targets, *acc, *targ;
2241 if (!log_window_get_selected (self, &accounts, &targets, NULL, NULL,
2245 view = GTK_TREE_VIEW (self->priv->treeview_what);
2246 model = gtk_tree_view_get_model (view);
2248 /* For each event type... */
2249 for (next = gtk_tree_model_get_iter_first (model, &iter);
2251 next = gtk_tree_model_iter_next (model, &iter))
2253 TplEventTypeMask type;
2255 gtk_tree_model_get (model, &iter,
2256 COL_WHAT_TYPE, &type,
2259 /* ...we set the type and its subtypes (if any) unsensitive... */
2260 log_window_update_what_iter_sensitivity (model, &iter, FALSE);
2262 for (acc = accounts, targ = targets;
2263 acc != NULL && targ != NULL;
2264 acc = acc->next, targ = targ->next)
2266 TpAccount *account = acc->data;
2267 TplEntity *target = targ->data;
2269 if (tpl_log_manager_exists (self->priv->log_manager,
2270 account, target, type))
2272 /* And then we set it (and its subtypes, again, if any)
2273 * as sensitive if there are logs of that type. */
2274 log_window_update_what_iter_sensitivity (model, &iter, TRUE);
2280 g_list_free_full (accounts, g_object_unref);
2281 g_list_free_full (targets, g_object_unref);
2285 log_window_who_changed_cb (GtkTreeSelection *selection,
2286 EmpathyLogWindow *self)
2289 GtkTreeModel *model;
2292 DEBUG ("log_window_who_changed_cb");
2294 view = gtk_tree_selection_get_tree_view (selection);
2295 model = gtk_tree_view_get_model (view);
2297 if (gtk_tree_model_get_iter_first (model, &iter))
2299 /* If 'Anyone' is selected, everything else should be deselected */
2300 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2302 g_signal_handlers_block_by_func (selection,
2303 log_window_who_changed_cb,
2306 gtk_tree_selection_unselect_all (selection);
2307 gtk_tree_selection_select_iter (selection, &iter);
2309 g_signal_handlers_unblock_by_func (selection,
2310 log_window_who_changed_cb,
2315 log_window_update_what_sensitivity (self);
2316 log_window_update_buttons_sensitivity (self);
2318 /* The contact changed, so the dates need to be updated */
2319 log_window_chats_get_messages (self, TRUE);
2323 log_manager_got_entities_cb (GObject *manager,
2324 GAsyncResult *result,
2327 Ctx *ctx = user_data;
2331 GtkTreeModel *model;
2332 GtkTreeSelection *selection;
2333 GtkListStore *store;
2335 GError *error = NULL;
2336 gboolean select_account = FALSE;
2338 if (log_window == NULL)
2341 if (log_window->priv->count != ctx->count)
2344 if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager),
2345 result, &entities, &error))
2347 DEBUG ("%s. Aborting", error->message);
2348 g_error_free (error);
2352 view = GTK_TREE_VIEW (ctx->self->priv->treeview_who);
2353 model = gtk_tree_view_get_model (view);
2354 selection = gtk_tree_view_get_selection (view);
2355 store = GTK_LIST_STORE (model);
2357 /* Block signals to stop the logs being retrieved prematurely */
2358 g_signal_handlers_block_by_func (selection,
2359 log_window_who_changed_cb, ctx->self);
2361 for (l = entities; l; l = l->next)
2363 add_event_to_store (ctx->self, ctx->account, l->data);
2365 if (ctx->self->priv->selected_account != NULL &&
2366 !tp_strdiff (tp_proxy_get_object_path (ctx->account),
2367 tp_proxy_get_object_path (ctx->self->priv->selected_account)))
2368 select_account = TRUE;
2370 g_list_free_full (entities, g_object_unref);
2372 if (gtk_tree_model_get_iter_first (model, &iter))
2376 gtk_tree_model_get (model, &iter,
2377 COL_WHO_TYPE, &type,
2380 if (type != COL_TYPE_ANY)
2382 gtk_list_store_prepend (store, &iter);
2383 gtk_list_store_set (store, &iter,
2384 COL_WHO_TYPE, COL_TYPE_SEPARATOR,
2385 COL_WHO_NAME, "separator",
2388 gtk_list_store_prepend (store, &iter);
2389 gtk_list_store_set (store, &iter,
2390 COL_WHO_TYPE, COL_TYPE_ANY,
2391 COL_WHO_NAME, _("Anyone"),
2396 /* Unblock signals */
2397 g_signal_handlers_unblock_by_func (selection,
2398 log_window_who_changed_cb,
2401 /* We display the selected account if we populate the model with chats from
2404 log_window_chats_set_selected (ctx->self);
2407 _tpl_action_chain_continue (log_window->priv->chain);
2412 get_entities_for_account (TplActionChain *chain, gpointer user_data)
2414 Ctx *ctx = user_data;
2416 tpl_log_manager_get_entities_async (ctx->self->priv->log_manager, ctx->account,
2417 log_manager_got_entities_cb, ctx);
2421 select_first_entity (TplActionChain *chain, gpointer user_data)
2423 EmpathyLogWindow *self = user_data;
2425 GtkTreeModel *model;
2426 GtkTreeSelection *selection;
2429 view = GTK_TREE_VIEW (self->priv->treeview_who);
2430 model = gtk_tree_view_get_model (view);
2431 selection = gtk_tree_view_get_selection (view);
2433 if (gtk_tree_model_get_iter_first (model, &iter))
2434 gtk_tree_selection_select_iter (selection, &iter);
2436 _tpl_action_chain_continue (self->priv->chain);
2440 log_window_who_populate (EmpathyLogWindow *self)
2442 EmpathyAccountChooser *account_chooser;
2444 gboolean all_accounts;
2446 GtkTreeModel *model;
2447 GtkTreeSelection *selection;
2448 GtkListStore *store;
2451 if (self->priv->hits != NULL)
2453 populate_entities_from_search_hits ();
2457 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
2458 account = empathy_account_chooser_dup_account (account_chooser);
2459 all_accounts = empathy_account_chooser_has_all_selected (account_chooser);
2461 view = GTK_TREE_VIEW (self->priv->treeview_who);
2462 model = gtk_tree_view_get_model (view);
2463 selection = gtk_tree_view_get_selection (view);
2464 store = GTK_LIST_STORE (model);
2466 /* Block signals to stop the logs being retrieved prematurely */
2467 g_signal_handlers_block_by_func (selection,
2468 log_window_who_changed_cb,
2471 gtk_list_store_clear (store);
2473 /* Unblock signals */
2474 g_signal_handlers_unblock_by_func (selection,
2475 log_window_who_changed_cb,
2478 _tpl_action_chain_clear (self->priv->chain);
2479 self->priv->count++;
2481 if (!all_accounts && account == NULL)
2485 else if (!all_accounts)
2487 ctx = ctx_new (self, account, NULL, NULL, 0, 0, self->priv->count);
2488 _tpl_action_chain_append (self->priv->chain, get_entities_for_account, ctx);
2492 TpAccountManager *manager;
2493 GList *accounts, *l;
2495 manager = empathy_account_chooser_get_account_manager (account_chooser);
2496 accounts = tp_account_manager_dup_valid_accounts (manager);
2498 for (l = accounts; l != NULL; l = l->next)
2502 ctx = ctx_new (self, account, NULL, NULL, 0, 0, self->priv->count);
2503 _tpl_action_chain_append (self->priv->chain,
2504 get_entities_for_account, ctx);
2507 g_list_free_full (accounts, g_object_unref);
2509 _tpl_action_chain_append (self->priv->chain, select_first_entity, self);
2510 _tpl_action_chain_start (self->priv->chain);
2514 sort_by_name_key (GtkTreeModel *model,
2523 gtk_tree_model_get (model, a,
2524 COL_WHO_TYPE, &type1,
2525 COL_WHO_NAME_SORT_KEY, &key1,
2528 gtk_tree_model_get (model, b,
2529 COL_WHO_TYPE, &type2,
2530 COL_WHO_NAME_SORT_KEY, &key2,
2533 if (type1 == COL_TYPE_ANY)
2535 else if (type2 == COL_TYPE_ANY)
2537 else if (type1 == COL_TYPE_SEPARATOR)
2539 else if (type2 == COL_TYPE_SEPARATOR)
2542 ret = g_strcmp0 (key1, key2);
2551 who_row_is_separator (GtkTreeModel *model,
2557 gtk_tree_model_get (model, iter,
2558 COL_WHO_TYPE, &type,
2561 return (type == COL_TYPE_SEPARATOR);
2565 log_window_find_row (EmpathyLogWindow *self,
2566 GdkEventButton *event)
2568 WebKitHitTestResult *hit = webkit_web_view_get_hit_test_result (
2569 WEBKIT_WEB_VIEW (self->priv->webview), event);
2570 WebKitDOMNode *inner_node;
2572 tp_clear_object (&self->priv->events_contact);
2575 "inner-node", &inner_node,
2578 if (inner_node != NULL)
2580 GtkTreeModel *model = GTK_TREE_MODEL (self->priv->store_events);
2581 WebKitDOMNode *node;
2582 const char *path = NULL;
2585 /* walk back up the DOM tree looking for a node with empathy:path set */
2586 for (node = inner_node; node != NULL;
2587 node = webkit_dom_node_get_parent_node (node))
2589 if (!WEBKIT_DOM_IS_ELEMENT (node))
2592 path = webkit_dom_element_get_attribute_ns (
2593 WEBKIT_DOM_ELEMENT (node), EMPATHY_NS, "path");
2595 if (!tp_str_empty (path))
2599 /* look up the contact for this path */
2600 if (!tp_str_empty (path) &&
2601 gtk_tree_model_get_iter_from_string (model, &iter, path))
2606 gtk_tree_model_get (model, &iter,
2607 COL_EVENTS_ACCOUNT, &account,
2608 COL_EVENTS_TARGET, &target,
2611 self->priv->events_contact = empathy_contact_from_tpl_contact (
2614 g_object_unref (account);
2615 g_object_unref (target);
2618 g_object_unref (inner_node);
2621 g_object_unref (hit);
2623 log_window_update_buttons_sensitivity (self);
2627 log_window_events_button_press_event (GtkWidget *webview,
2628 GdkEventButton *event,
2629 EmpathyLogWindow *self)
2631 switch (event->button)
2634 log_window_find_row (self, event);
2638 empathy_webkit_context_menu_for_event (
2639 WEBKIT_WEB_VIEW (webview), event, 0);
2650 log_window_events_setup (EmpathyLogWindow *self)
2652 GtkTreeSortable *sortable;
2653 GtkTreeStore *store;
2656 self->priv->store_events = store = gtk_tree_store_new (COL_EVENTS_COUNT,
2657 G_TYPE_INT, /* type */
2658 G_TYPE_INT64, /* timestamp */
2659 G_TYPE_STRING, /* stringified date */
2660 G_TYPE_STRING, /* icon */
2661 G_TYPE_STRING, /* name */
2662 TP_TYPE_ACCOUNT, /* account */
2663 TPL_TYPE_ENTITY, /* target */
2664 TPL_TYPE_EVENT); /* event */
2666 sortable = GTK_TREE_SORTABLE (store);
2668 gtk_tree_sortable_set_sort_column_id (sortable,
2670 GTK_SORT_ASCENDING);
2674 log_window_who_setup (EmpathyLogWindow *self)
2677 GtkTreeModel *model;
2678 GtkTreeSelection *selection;
2679 GtkTreeSortable *sortable;
2680 GtkTreeViewColumn *column;
2681 GtkListStore *store;
2682 GtkCellRenderer *cell;
2684 view = GTK_TREE_VIEW (self->priv->treeview_who);
2685 selection = gtk_tree_view_get_selection (view);
2688 store = gtk_list_store_new (COL_WHO_COUNT,
2689 G_TYPE_INT, /* type */
2690 G_TYPE_STRING, /* icon */
2691 G_TYPE_STRING, /* name */
2692 G_TYPE_STRING, /* name sort key */
2693 G_TYPE_STRING, /* id */
2694 TP_TYPE_ACCOUNT, /* account */
2695 TPL_TYPE_ENTITY); /* target */
2697 model = GTK_TREE_MODEL (store);
2698 sortable = GTK_TREE_SORTABLE (store);
2700 gtk_tree_view_set_model (view, model);
2703 column = gtk_tree_view_column_new ();
2704 gtk_tree_view_column_set_title (column, _("Who"));
2706 cell = gtk_cell_renderer_pixbuf_new ();
2707 gtk_tree_view_column_pack_start (column, cell, FALSE);
2708 gtk_tree_view_column_add_attribute (column, cell,
2712 cell = gtk_cell_renderer_text_new ();
2713 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2714 gtk_tree_view_column_pack_start (column, cell, TRUE);
2715 gtk_tree_view_column_add_attribute (column, cell,
2719 gtk_tree_view_append_column (view, column);
2721 /* set up treeview properties */
2722 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
2723 gtk_tree_view_set_row_separator_func (view, who_row_is_separator,
2726 gtk_tree_sortable_set_sort_column_id (sortable,
2727 COL_WHO_NAME_SORT_KEY,
2728 GTK_SORT_ASCENDING);
2729 gtk_tree_sortable_set_sort_func (sortable,
2730 COL_WHO_NAME_SORT_KEY, sort_by_name_key,
2733 gtk_tree_view_set_search_column (view, COL_WHO_NAME);
2734 gtk_tree_view_set_tooltip_column (view, COL_WHO_ID);
2736 /* set up signals */
2737 g_signal_connect (selection, "changed",
2738 G_CALLBACK (log_window_who_changed_cb), self);
2740 g_object_unref (store);
2744 log_window_chats_accounts_changed_cb (GtkWidget *combobox,
2745 EmpathyLogWindow *self)
2747 /* Clear all current messages shown in the textview */
2748 gtk_tree_store_clear (self->priv->store_events);
2750 log_window_who_populate (self);
2754 log_window_chats_set_selected (EmpathyLogWindow *self)
2757 GtkTreeModel *model;
2758 GtkTreeSelection *selection;
2763 view = GTK_TREE_VIEW (self->priv->treeview_who);
2764 model = gtk_tree_view_get_model (view);
2765 selection = gtk_tree_view_get_selection (view);
2767 for (next = gtk_tree_model_get_iter_first (model, &iter);
2769 next = gtk_tree_model_iter_next (model, &iter))
2771 TpAccount *this_account;
2772 TplEntity *this_target;
2773 const gchar *this_chat_id;
2774 gboolean this_is_chatroom;
2777 gtk_tree_model_get (model, &iter,
2778 COL_WHO_TYPE, &this_type,
2779 COL_WHO_ACCOUNT, &this_account,
2780 COL_WHO_TARGET, &this_target,
2783 if (this_type != COL_TYPE_NORMAL)
2786 this_chat_id = tpl_entity_get_identifier (this_target);
2787 this_is_chatroom = tpl_entity_get_entity_type (this_target)
2790 if (this_account == self->priv->selected_account &&
2791 !tp_strdiff (this_chat_id, self->priv->selected_chat_id) &&
2792 this_is_chatroom == self->priv->selected_is_chatroom)
2794 gtk_tree_selection_select_iter (selection, &iter);
2795 path = gtk_tree_model_get_path (model, &iter);
2796 gtk_tree_view_scroll_to_cell (view, path, NULL, TRUE, 0.5, 0.0);
2797 gtk_tree_path_free (path);
2798 g_object_unref (this_account);
2799 g_object_unref (this_target);
2803 g_object_unref (this_account);
2804 g_object_unref (this_target);
2807 tp_clear_object (&self->priv->selected_account);
2808 tp_clear_pointer (&self->priv->selected_chat_id, g_free);
2812 sort_by_date (GtkTreeModel *model,
2817 GDate *date1, *date2;
2820 gtk_tree_model_get (model, a,
2821 COL_WHEN_DATE, &date1,
2824 gtk_tree_model_get (model, b,
2825 COL_WHEN_DATE, &date2,
2828 result = g_date_compare (date1, date2);
2830 g_date_free (date1);
2831 g_date_free (date2);
2836 when_row_is_separator (GtkTreeModel *model,
2843 gtk_tree_model_get (model, iter,
2844 COL_WHEN_TEXT, &when,
2847 ret = !tp_strdiff (when, "separator");
2853 log_window_when_changed_cb (GtkTreeSelection *selection,
2854 EmpathyLogWindow *self)
2857 GtkTreeModel *model;
2860 DEBUG ("log_window_when_changed_cb");
2862 view = gtk_tree_selection_get_tree_view (selection);
2863 model = gtk_tree_view_get_model (view);
2865 /* If 'Anytime' is selected, everything else should be deselected */
2866 if (gtk_tree_model_get_iter_first (model, &iter))
2868 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2870 g_signal_handlers_block_by_func (selection,
2871 log_window_when_changed_cb,
2874 gtk_tree_selection_unselect_all (selection);
2875 gtk_tree_selection_select_iter (selection, &iter);
2877 g_signal_handlers_unblock_by_func (selection,
2878 log_window_when_changed_cb,
2883 log_window_chats_get_messages (self, FALSE);
2887 log_window_when_setup (EmpathyLogWindow *self)
2890 GtkTreeModel *model;
2891 GtkTreeSelection *selection;
2892 GtkTreeSortable *sortable;
2893 GtkTreeViewColumn *column;
2894 GtkListStore *store;
2895 GtkCellRenderer *cell;
2897 view = GTK_TREE_VIEW (self->priv->treeview_when);
2898 selection = gtk_tree_view_get_selection (view);
2901 store = gtk_list_store_new (COL_WHEN_COUNT,
2902 G_TYPE_DATE, /* date */
2903 G_TYPE_STRING, /* stringified date */
2904 G_TYPE_STRING); /* icon */
2906 model = GTK_TREE_MODEL (store);
2907 sortable = GTK_TREE_SORTABLE (store);
2909 gtk_tree_view_set_model (view, model);
2912 column = gtk_tree_view_column_new ();
2913 gtk_tree_view_column_set_title (column, _("When"));
2915 cell = gtk_cell_renderer_pixbuf_new ();
2916 gtk_tree_view_column_pack_start (column, cell, FALSE);
2917 gtk_tree_view_column_add_attribute (column, cell,
2918 "icon-name", COL_WHEN_ICON);
2920 cell = gtk_cell_renderer_text_new ();
2921 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2922 gtk_tree_view_column_pack_start (column, cell, TRUE);
2923 gtk_tree_view_column_add_attribute (column, cell,
2927 gtk_tree_view_append_column (view, column);
2929 /* set up treeview properties */
2930 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
2931 gtk_tree_view_set_row_separator_func (view, when_row_is_separator,
2933 gtk_tree_sortable_set_sort_column_id (sortable,
2935 GTK_SORT_DESCENDING);
2936 gtk_tree_sortable_set_sort_func (sortable,
2937 COL_WHEN_DATE, sort_by_date,
2940 gtk_tree_view_set_search_column (view, COL_WHEN_TEXT);
2942 /* set up signals */
2943 g_signal_connect (selection, "changed",
2944 G_CALLBACK (log_window_when_changed_cb),
2947 g_object_unref (store);
2951 what_row_is_separator (GtkTreeModel *model,
2957 gtk_tree_model_get (model, iter,
2958 COL_WHAT_TYPE, &type,
2961 return (type == WHAT_TYPE_SEPARATOR);
2965 log_window_what_changed_cb (GtkTreeSelection *selection,
2966 EmpathyLogWindow *self)
2969 GtkTreeModel *model;
2972 DEBUG ("log_window_what_changed_cb");
2974 view = gtk_tree_selection_get_tree_view (selection);
2975 model = gtk_tree_view_get_model (view);
2977 /* If 'Anything' is selected, everything else should be deselected */
2978 if (gtk_tree_model_get_iter_first (model, &iter))
2980 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2982 g_signal_handlers_block_by_func (selection,
2983 log_window_what_changed_cb,
2986 gtk_tree_selection_unselect_all (selection);
2987 gtk_tree_selection_select_iter (selection, &iter);
2989 g_signal_handlers_unblock_by_func (selection,
2990 log_window_what_changed_cb,
2995 /* The dates need to be updated if we're not searching */
2996 log_window_chats_get_messages (self, self->priv->hits == NULL);
3000 log_window_what_collapse_row_cb (GtkTreeView *tree_view,
3005 /* Reject collapsing */
3012 EventSubtype subtype;
3018 log_window_what_setup (EmpathyLogWindow *self)
3021 GtkTreeModel *model;
3022 GtkTreeSelection *selection;
3023 GtkTreeViewColumn *column;
3025 GtkTreeStore *store;
3026 GtkCellRenderer *cell;
3030 struct event events [] = {
3031 { TPL_EVENT_MASK_ANY, 0, NULL, _("Anything") },
3032 { WHAT_TYPE_SEPARATOR, 0, NULL, "separator" },
3033 { TPL_EVENT_MASK_TEXT, 0, "format-justify-fill", _("Text chats") },
3034 { TPL_EVENT_MASK_CALL, EVENT_CALL_ALL, EMPATHY_IMAGE_CALL, _("Calls") },
3037 struct event call_events [] = {
3038 { TPL_EVENT_MASK_CALL, EVENT_CALL_INCOMING, EMPATHY_IMAGE_CALL_INCOMING, _("Incoming calls") },
3039 { TPL_EVENT_MASK_CALL, EVENT_CALL_OUTGOING, EMPATHY_IMAGE_CALL_OUTGOING, _("Outgoing calls") },
3040 { TPL_EVENT_MASK_CALL, EVENT_CALL_MISSED, EMPATHY_IMAGE_CALL_MISSED, _("Missed calls") }
3043 view = GTK_TREE_VIEW (self->priv->treeview_what);
3044 selection = gtk_tree_view_get_selection (view);
3047 store = gtk_tree_store_new (COL_WHAT_COUNT,
3048 G_TYPE_INT, /* history type */
3049 G_TYPE_INT, /* history subtype */
3050 G_TYPE_BOOLEAN, /* sensitive */
3051 G_TYPE_STRING, /* stringified history type */
3052 G_TYPE_STRING); /* icon */
3054 model = GTK_TREE_MODEL (store);
3056 gtk_tree_view_set_model (view, model);
3059 column = gtk_tree_view_column_new ();
3060 gtk_tree_view_column_set_title (column, _("What"));
3062 cell = gtk_cell_renderer_pixbuf_new ();
3063 gtk_tree_view_column_pack_start (column, cell, FALSE);
3064 gtk_tree_view_column_add_attribute (column, cell,
3065 "icon-name", COL_WHAT_ICON);
3067 cell = gtk_cell_renderer_text_new ();
3068 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
3069 gtk_tree_view_column_pack_start (column, cell, TRUE);
3070 gtk_tree_view_column_add_attribute (column, cell,
3071 "text", COL_WHAT_TEXT);
3072 gtk_tree_view_column_add_attribute (column, cell,
3073 "sensitive", COL_WHAT_SENSITIVE);
3075 gtk_tree_view_append_column (view, column);
3076 gtk_tree_view_set_search_column (view, COL_WHAT_TEXT);
3078 /* set up treeview properties */
3079 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
3080 gtk_tree_view_set_show_expanders (view, FALSE);
3081 gtk_tree_view_set_level_indentation (view, 12);
3082 gtk_tree_view_expand_all (view);
3083 gtk_tree_view_set_row_separator_func (view, what_row_is_separator,
3087 for (i = 0; i < G_N_ELEMENTS (events); i++)
3089 gtk_tree_store_append (store, &iter, NULL);
3090 gtk_tree_store_set (store, &iter,
3091 COL_WHAT_TYPE, events[i].type,
3092 COL_WHAT_SUBTYPE, events[i].subtype,
3093 COL_WHAT_SENSITIVE, TRUE,
3094 COL_WHAT_TEXT, events[i].text,
3095 COL_WHAT_ICON, events[i].icon,
3099 gtk_tree_model_iter_nth_child (model, &parent, NULL, 3);
3100 for (i = 0; i < G_N_ELEMENTS (call_events); i++)
3102 gtk_tree_store_append (store, &iter, &parent);
3103 gtk_tree_store_set (store, &iter,
3104 COL_WHAT_TYPE, call_events[i].type,
3105 COL_WHAT_SUBTYPE, call_events[i].subtype,
3106 COL_WHAT_SENSITIVE, TRUE,
3107 COL_WHAT_TEXT, call_events[i].text,
3108 COL_WHAT_ICON, call_events[i].icon,
3112 gtk_tree_view_expand_all (view);
3114 /* select 'Anything' */
3115 if (gtk_tree_model_get_iter_first (model, &iter))
3116 gtk_tree_selection_select_iter (selection, &iter);
3118 /* set up signals */
3119 g_signal_connect (view, "test-collapse-row",
3120 G_CALLBACK (log_window_what_collapse_row_cb),
3122 g_signal_connect (selection, "changed",
3123 G_CALLBACK (log_window_what_changed_cb),
3126 g_object_unref (store);
3130 log_window_maybe_expand_events (void)
3132 GtkTreeModel *model = GTK_TREE_MODEL (log_window->priv->store_events);
3134 /* If there's only one result, expand it */
3135 if (gtk_tree_model_iter_n_children (model, NULL) == 1)
3136 webkit_web_view_execute_script (
3137 WEBKIT_WEB_VIEW (log_window->priv->webview),
3138 "javascript:expandAll()");
3142 show_spinner (gpointer data)
3146 if (log_window == NULL)
3149 g_object_get (log_window->priv->spinner, "active", &active, NULL);
3152 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3159 show_events (TplActionChain *chain,
3162 log_window_maybe_expand_events ();
3163 gtk_spinner_stop (GTK_SPINNER (log_window->priv->spinner));
3164 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3167 _tpl_action_chain_continue (chain);
3171 start_spinner (void)
3173 gtk_spinner_start (GTK_SPINNER (log_window->priv->spinner));
3174 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3177 g_timeout_add (1000, show_spinner, NULL);
3178 _tpl_action_chain_append (log_window->priv->chain, show_events, NULL);
3182 log_window_got_messages_for_date_cb (GObject *manager,
3183 GAsyncResult *result,
3186 Ctx *ctx = user_data;
3187 GtkTreeModel *model;
3191 GError *error = NULL;
3194 if (log_window == NULL)
3200 if (log_window->priv->count != ctx->count)
3203 if (!tpl_log_manager_get_events_for_date_finish (TPL_LOG_MANAGER (manager),
3204 result, &events, &error))
3206 DEBUG ("Unable to retrieve messages for the selected date: %s. Aborting",
3208 g_error_free (error);
3212 for (l = events; l; l = l->next)
3214 TplEvent *event = l->data;
3215 gboolean append = TRUE;
3217 if (TPL_IS_CALL_EVENT (l->data)
3218 && ctx->event_mask & TPL_EVENT_MASK_CALL
3219 && ctx->event_mask != TPL_EVENT_MASK_ANY)
3221 TplCallEvent *call = l->data;
3225 if (ctx->subtype & EVENT_CALL_ALL)
3231 TpCallStateChangeReason reason =
3232 tpl_call_event_get_end_reason (call);
3233 TplEntity *sender = tpl_event_get_sender (event);
3234 TplEntity *receiver = tpl_event_get_receiver (event);
3236 if (reason == TP_CALL_STATE_CHANGE_REASON_NO_ANSWER)
3238 if (ctx->subtype & EVENT_CALL_MISSED)
3241 else if (ctx->subtype & EVENT_CALL_OUTGOING
3242 && tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
3246 else if (ctx->subtype & EVENT_CALL_INCOMING
3247 && tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF)
3256 EmpathyMessage *msg = empathy_message_from_tpl_log_event (event);
3257 log_window_append_message (event, msg);
3258 tp_clear_object (&msg);
3261 g_object_unref (event);
3263 g_list_free (events);
3265 model = GTK_TREE_MODEL (log_window->priv->store_events);
3266 n = gtk_tree_model_iter_n_children (model, NULL) - 1;
3268 if (n >= 0 && gtk_tree_model_iter_nth_child (model, &iter, NULL, n))
3273 path = gtk_tree_model_get_path (model, &iter);
3274 str = gtk_tree_path_to_string (path);
3276 script = g_strdup_printf ("javascript:scrollToRow([%s]);",
3277 g_strdelimit (str, ":", ','));
3279 webkit_web_view_execute_script (
3280 WEBKIT_WEB_VIEW (log_window->priv->webview),
3283 gtk_tree_path_free (path);
3291 _tpl_action_chain_continue (log_window->priv->chain);
3295 get_events_for_date (TplActionChain *chain, gpointer user_data)
3297 Ctx *ctx = user_data;
3299 tpl_log_manager_get_events_for_date_async (ctx->self->priv->log_manager,
3300 ctx->account, ctx->entity, ctx->event_mask,
3302 log_window_got_messages_for_date_cb,
3307 log_window_get_messages_for_dates (EmpathyLogWindow *self,
3310 GList *accounts, *targets, *acc, *targ, *l;
3311 TplEventTypeMask event_mask;
3312 EventSubtype subtype;
3313 GDate *date, *anytime, *separator;
3315 if (!log_window_get_selected (self,
3316 &accounts, &targets, NULL, NULL, &event_mask, &subtype))
3319 anytime = g_date_new_dmy (2, 1, -1);
3320 separator = g_date_new_dmy (1, 1, -1);
3322 _tpl_action_chain_clear (self->priv->chain);
3323 self->priv->count++;
3325 for (acc = accounts, targ = targets;
3326 acc != NULL && targ != NULL;
3327 acc = acc->next, targ = targ->next)
3329 TpAccount *account = acc->data;
3330 TplEntity *target = targ->data;
3332 for (l = dates; l != NULL; l = l->next)
3337 if (g_date_compare (date, anytime) != 0)
3341 ctx = ctx_new (self, account, target, date, event_mask, subtype,
3343 _tpl_action_chain_append (self->priv->chain, get_events_for_date, ctx);
3347 GtkTreeView *view = GTK_TREE_VIEW (self->priv->treeview_when);
3348 GtkTreeModel *model = gtk_tree_view_get_model (view);
3353 for (next = gtk_tree_model_get_iter_first (model, &iter);
3355 next = gtk_tree_model_iter_next (model, &iter))
3359 gtk_tree_model_get (model, &iter,
3363 if (g_date_compare (d, anytime) != 0 &&
3364 g_date_compare (d, separator) != 0)
3366 ctx = ctx_new (self, account, target, d,
3367 event_mask, subtype, self->priv->count);
3368 _tpl_action_chain_append (self->priv->chain, get_events_for_date, ctx);
3378 _tpl_action_chain_start (self->priv->chain);
3380 g_list_free_full (accounts, g_object_unref);
3381 g_list_free_full (targets, g_object_unref);
3382 g_date_free (separator);
3383 g_date_free (anytime);
3387 log_manager_got_dates_cb (GObject *manager,
3388 GAsyncResult *result,
3391 Ctx *ctx = user_data;
3393 GtkTreeModel *model;
3394 GtkListStore *store;
3398 GError *error = NULL;
3400 if (log_window == NULL)
3406 if (log_window->priv->count != ctx->count)
3409 if (!tpl_log_manager_get_dates_finish (TPL_LOG_MANAGER (manager),
3410 result, &dates, &error))
3412 DEBUG ("Unable to retrieve messages' dates: %s. Aborting",
3417 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
3418 model = gtk_tree_view_get_model (view);
3419 store = GTK_LIST_STORE (model);
3421 for (l = dates; l != NULL; l = l->next)
3423 add_date_if_needed (log_window, l->data);
3426 if (gtk_tree_model_get_iter_first (model, &iter))
3428 gchar *separator = NULL;
3430 if (gtk_tree_model_iter_next (model, &iter))
3432 gtk_tree_model_get (model, &iter,
3433 COL_WHEN_TEXT, &separator,
3437 if (g_strcmp0 (separator, "separator") != 0)
3441 date = g_date_new_dmy (1, 1, -1);
3443 gtk_list_store_prepend (store, &iter);
3444 gtk_list_store_set (store, &iter,
3445 COL_WHEN_DATE, date,
3446 COL_WHEN_TEXT, "separator",
3451 date = g_date_new_dmy (2, 1, -1);
3453 gtk_list_store_prepend (store, &iter);
3454 gtk_list_store_set (store, &iter,
3455 COL_WHEN_DATE, date,
3456 COL_WHEN_TEXT, _("Anytime"),
3465 g_list_free_full (dates, g_free);
3468 _tpl_action_chain_continue (log_window->priv->chain);
3472 select_date (TplActionChain *chain, gpointer user_data)
3475 GtkTreeModel *model;
3476 GtkTreeSelection *selection;
3479 gboolean selected = FALSE;
3481 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
3482 model = gtk_tree_view_get_model (view);
3483 selection = gtk_tree_view_get_selection (view);
3485 if (log_window->priv->current_dates != NULL)
3487 for (next = gtk_tree_model_get_iter_first (model, &iter);
3489 next = gtk_tree_model_iter_next (model, &iter))
3493 gtk_tree_model_get (model, &iter,
3494 COL_WHEN_DATE, &date,
3497 if (g_list_find_custom (log_window->priv->current_dates, date,
3498 (GCompareFunc) g_date_compare) != NULL)
3502 gtk_tree_selection_select_iter (selection, &iter);
3503 path = gtk_tree_model_get_path (model, &iter);
3504 gtk_tree_view_scroll_to_cell (view, path, NULL, FALSE, 0, 0);
3507 gtk_tree_path_free (path);
3516 /* Show messages of the most recent date */
3517 if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 2))
3518 gtk_tree_selection_select_iter (selection, &iter);
3521 _tpl_action_chain_continue (log_window->priv->chain);
3525 get_dates_for_entity (TplActionChain *chain, gpointer user_data)
3527 Ctx *ctx = user_data;
3529 tpl_log_manager_get_dates_async (ctx->self->priv->log_manager,
3530 ctx->account, ctx->entity, ctx->event_mask,
3531 log_manager_got_dates_cb, ctx);
3535 log_window_chats_get_messages (EmpathyLogWindow *self,
3536 gboolean force_get_dates)
3538 GList *accounts, *targets, *dates;
3539 TplEventTypeMask event_mask;
3541 GtkTreeModel *model;
3542 GtkListStore *store;
3543 GtkTreeSelection *selection;
3545 if (!log_window_get_selected (self, &accounts, &targets, NULL,
3546 &dates, &event_mask, NULL))
3549 view = GTK_TREE_VIEW (self->priv->treeview_when);
3550 selection = gtk_tree_view_get_selection (view);
3551 model = gtk_tree_view_get_model (view);
3552 store = GTK_LIST_STORE (model);
3554 /* Clear all current messages shown in the textview */
3555 gtk_tree_store_clear (self->priv->store_events);
3557 _tpl_action_chain_clear (self->priv->chain);
3558 self->priv->count++;
3560 /* If there's a search use the returned hits */
3561 if (self->priv->hits != NULL)
3563 if (force_get_dates)
3565 g_signal_handlers_block_by_func (selection,
3566 log_window_when_changed_cb,
3569 gtk_list_store_clear (store);
3571 g_signal_handlers_unblock_by_func (selection,
3572 log_window_when_changed_cb,
3575 populate_dates_from_search_hits (accounts, targets);
3579 populate_events_from_search_hits (accounts, targets, dates);
3582 /* Either use the supplied date or get the last */
3583 else if (force_get_dates || dates == NULL)
3587 if (self->priv->current_dates != NULL)
3589 g_list_free_full (self->priv->current_dates,
3590 (GDestroyNotify) g_date_free);
3591 self->priv->current_dates = NULL;
3594 if (gtk_tree_selection_count_selected_rows (selection) > 0)
3599 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
3601 for (l = paths; l != NULL; l = l->next)
3603 GtkTreePath *path = l->data;
3606 gtk_tree_model_get_iter (model, &iter, path);
3607 gtk_tree_model_get (model, &iter,
3608 COL_WHEN_DATE, &date,
3611 /* The list takes ownership of the date. */
3612 self->priv->current_dates =
3613 g_list_prepend (self->priv->current_dates, date);
3616 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
3619 g_signal_handlers_block_by_func (selection,
3620 log_window_when_changed_cb,
3623 gtk_list_store_clear (store);
3625 g_signal_handlers_unblock_by_func (selection,
3626 log_window_when_changed_cb,
3629 /* Get a list of dates and show them on the treeview */
3630 for (targ = targets, acc = accounts;
3631 targ != NULL && acc != NULL;
3632 targ = targ->next, acc = acc->next)
3634 TpAccount *account = acc->data;
3635 TplEntity *target = targ->data;
3636 Ctx *ctx = ctx_new (self, account, target, NULL, event_mask, 0,
3639 _tpl_action_chain_append (self->priv->chain, get_dates_for_entity, ctx);
3641 _tpl_action_chain_append (self->priv->chain, select_date, NULL);
3642 _tpl_action_chain_start (self->priv->chain);
3646 /* Show messages of the selected date */
3647 log_window_get_messages_for_dates (self, dates);
3650 g_list_free_full (accounts, g_object_unref);
3651 g_list_free_full (targets, g_object_unref);
3652 g_list_free_full (dates, (GFreeFunc) g_date_free);
3656 EmpathyAccountChooserFilterResultCallback callback;
3658 } FilterCallbackData;
3661 got_entities (GObject *manager,
3662 GAsyncResult *result,
3665 FilterCallbackData *data = user_data;
3667 GError *error = NULL;
3669 if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager),
3670 result, &entities, &error))
3672 DEBUG ("Could not get entities: %s", error->message);
3673 g_error_free (error);
3674 data->callback (FALSE, data->user_data);
3678 data->callback (entities != NULL, data->user_data);
3680 g_list_free_full (entities, g_object_unref);
3683 g_slice_free (FilterCallbackData, data);
3687 empathy_account_chooser_filter_has_logs (TpAccount *account,
3688 EmpathyAccountChooserFilterResultCallback callback,
3689 gpointer callback_data,
3692 TplLogManager *manager = tpl_log_manager_dup_singleton ();
3693 FilterCallbackData *cb_data = g_slice_new0 (FilterCallbackData);
3695 cb_data->callback = callback;
3696 cb_data->user_data = callback_data;
3698 tpl_log_manager_get_entities_async (manager, account, got_entities, cb_data);
3700 g_object_unref (manager);
3704 log_window_logger_clear_account_cb (TpProxy *proxy,
3705 const GError *error,
3707 GObject *weak_object)
3709 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (user_data);
3712 g_warning ("Error when clearing logs: %s", error->message);
3714 /* Refresh the log viewer so the logs are cleared if the account
3715 * has been deleted */
3716 gtk_tree_store_clear (self->priv->store_events);
3717 log_window_who_populate (self);
3719 /* Re-filter the account chooser so the accounts without logs get
3721 empathy_account_chooser_refilter (
3722 EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser));
3726 log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem,
3727 EmpathyLogWindow *self)
3729 GtkWidget *dialog, *content_area, *hbox, *label;
3730 EmpathyAccountChooser *account_chooser;
3734 GError *error = NULL;
3736 account_chooser = (EmpathyAccountChooser *) empathy_account_chooser_new ();
3737 empathy_account_chooser_set_has_all_option (account_chooser, TRUE);
3739 empathy_account_chooser_refilter (account_chooser);
3741 /* Select the same account as in the history window */
3742 empathy_account_chooser_set_account (account_chooser,
3743 empathy_account_chooser_get_account (
3744 EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser)));
3746 dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (self),
3747 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING,
3749 _("Are you sure you want to delete all logs of previous conversations?"));
3751 gtk_dialog_add_buttons (GTK_DIALOG (dialog),
3752 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
3753 _("Clear All"), GTK_RESPONSE_APPLY,
3756 content_area = gtk_message_dialog_get_message_area (
3757 GTK_MESSAGE_DIALOG (dialog));
3759 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
3760 label = gtk_label_new (_("Delete from:"));
3761 gtk_box_pack_start (GTK_BOX (hbox), label,
3763 gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (account_chooser),
3765 gtk_box_pack_start (GTK_BOX (content_area), hbox,
3768 gtk_widget_show_all (hbox);
3770 response_id = gtk_dialog_run (GTK_DIALOG (dialog));
3772 if (response_id != GTK_RESPONSE_APPLY)
3775 bus = tp_dbus_daemon_dup (&error);
3778 g_warning ("Could not delete logs: %s", error->message);
3779 g_error_free (error);
3783 logger = g_object_new (TP_TYPE_PROXY,
3784 "bus-name", "org.freedesktop.Telepathy.Logger",
3785 "object-path", "/org/freedesktop/Telepathy/Logger",
3788 g_object_unref (bus);
3790 tp_proxy_add_interface_by_id (logger, EMP_IFACE_QUARK_LOGGER);
3792 if (empathy_account_chooser_has_all_selected (account_chooser))
3794 DEBUG ("Deleting logs for all the accounts");
3796 emp_cli_logger_call_clear (logger, -1,
3797 log_window_logger_clear_account_cb,
3798 self, NULL, G_OBJECT (self));
3804 account = empathy_account_chooser_get_account (account_chooser);
3806 DEBUG ("Deleting logs for %s", tp_proxy_get_object_path (account));
3808 emp_cli_logger_call_clear_account (logger, -1,
3809 tp_proxy_get_object_path (account),
3810 log_window_logger_clear_account_cb,
3811 self, NULL, G_OBJECT (self));
3814 g_object_unref (logger);
3816 gtk_widget_destroy (dialog);