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>
30 #include <glib/gi18n-lib.h>
32 #include <webkit/webkit.h>
34 #include <telepathy-glib/telepathy-glib.h>
35 #include <telepathy-glib/proxy-subclass.h>
37 #include <telepathy-logger/telepathy-logger.h>
39 # include <telepathy-logger/call-event.h>
42 #include <extensions/extensions.h>
44 #include <libempathy/action-chain-internal.h>
45 #include <libempathy/empathy-camera-monitor.h>
46 #include <libempathy/empathy-chatroom-manager.h>
47 #include <libempathy/empathy-chatroom.h>
48 #include <libempathy/empathy-gsettings.h>
49 #include <libempathy/empathy-message.h>
50 #include <libempathy/empathy-request-util.h>
51 #include <libempathy/empathy-utils.h>
52 #include <libempathy/empathy-time.h>
54 #include "empathy-log-window.h"
55 #include "empathy-account-chooser.h"
56 #include "empathy-call-utils.h"
57 #include "empathy-chat-view.h"
58 #include "empathy-contact-dialogs.h"
59 #include "empathy-images.h"
60 #include "empathy-theme-manager.h"
61 #include "empathy-ui-utils.h"
62 #include "empathy-webkit-utils.h"
63 #include "empathy-geometry.h"
65 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
66 #include <libempathy/empathy-debug.h>
68 #define EMPATHY_NS "http://live.gnome.org/Empathy"
70 G_DEFINE_TYPE (EmpathyLogWindow, empathy_log_window, GTK_TYPE_WINDOW);
72 struct _EmpathyLogWindowPriv
76 GtkWidget *button_profile;
77 GtkWidget *button_chat;
78 GtkWidget *button_call;
79 GtkWidget *button_video;
81 GtkWidget *search_entry;
86 GtkWidget *treeview_who;
87 GtkWidget *treeview_what;
88 GtkWidget *treeview_when;
91 GtkTreeStore *store_events;
93 GtkWidget *account_chooser;
97 /* List of selected GDates, free with g_list_free_full (l, g_date_free) */
100 TplActionChain *chain;
101 TplLogManager *log_manager;
103 /* Hash of TpChannel<->TpAccount for use by the observer until we can
104 * get a TpAccount from a TpConnection or wherever */
105 GHashTable *channels;
106 TpBaseClient *observer;
108 EmpathyContact *selected_contact;
109 EmpathyContact *events_contact;
111 EmpathyCameraMonitor *camera_monitor;
112 GBinding *button_video_binding;
114 /* Used to cancel logger calls when no longer needed */
117 /* List of owned TplLogSearchHits, free with tpl_log_search_hit_free */
121 /* Only used while waiting for the account chooser to be ready */
122 TpAccount *selected_account;
123 gchar *selected_chat_id;
124 gboolean selected_is_chatroom;
126 GSettings *gsettings_chat;
127 GSettings *gsettings_desktop;
130 static void log_window_search_entry_changed_cb (GtkWidget *entry,
131 EmpathyLogWindow *self);
132 static void log_window_search_entry_activate_cb (GtkWidget *widget,
133 EmpathyLogWindow *self);
134 static void log_window_search_entry_icon_pressed_cb (GtkEntry *entry,
135 GtkEntryIconPosition icon_pos,
138 static void log_window_who_populate (EmpathyLogWindow *self);
139 static void log_window_who_setup (EmpathyLogWindow *self);
140 static void log_window_when_setup (EmpathyLogWindow *self);
141 static void log_window_what_setup (EmpathyLogWindow *self);
142 static void log_window_events_setup (EmpathyLogWindow *self);
143 static void log_window_chats_accounts_changed_cb (GtkWidget *combobox,
144 EmpathyLogWindow *self);
145 static void log_window_chats_set_selected (EmpathyLogWindow *self);
146 static void log_window_chats_get_messages (EmpathyLogWindow *self,
147 gboolean force_get_dates);
148 static void log_window_when_changed_cb (GtkTreeSelection *selection,
149 EmpathyLogWindow *self);
150 static void log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem,
151 EmpathyLogWindow *self);
152 static void start_spinner (void);
154 static void log_window_create_observer (EmpathyLogWindow *window);
155 static gboolean log_window_events_button_press_event (GtkWidget *webview,
156 GdkEventButton *event, EmpathyLogWindow *self);
157 static void log_window_update_buttons_sensitivity (EmpathyLogWindow *self);
160 empathy_account_chooser_filter_has_logs (TpAccount *account,
161 EmpathyAccountChooserFilterResultCallback callback,
162 gpointer callback_data,
184 COL_WHO_NAME_SORT_KEY,
213 COL_EVENTS_PRETTY_DATE,
222 #define CALENDAR_ICON "stock_calendar"
224 /* Seconds between two messages to be considered one conversation */
225 #define MAX_GAP 30*60
227 #define WHAT_TYPE_SEPARATOR -1
231 EVENT_CALL_INCOMING = 1 << 0,
232 EVENT_CALL_OUTGOING = 1 << 1,
233 EVENT_CALL_MISSED = 1 << 2,
234 EVENT_CALL_ALL = 1 << 3,
238 log_window_get_selected (EmpathyLogWindow *window,
243 TplEventTypeMask *event_mask,
244 EventSubtype *subtype);
246 static EmpathyLogWindow *log_window = NULL;
248 static gboolean has_element;
251 #define _date_copy(d) g_date_new_julian (g_date_get_julian (d))
256 EmpathyLogWindow *self;
260 TplEventTypeMask event_mask;
261 EventSubtype subtype;
266 ctx_new (EmpathyLogWindow *self,
270 TplEventTypeMask event_mask,
271 EventSubtype subtype,
274 Ctx *ctx = g_slice_new0 (Ctx);
278 ctx->account = g_object_ref (account);
280 ctx->entity = g_object_ref (entity);
282 ctx->date = _date_copy (date);
283 ctx->event_mask = event_mask;
284 ctx->subtype = subtype;
293 tp_clear_object (&ctx->account);
294 tp_clear_object (&ctx->entity);
295 tp_clear_pointer (&ctx->date, g_date_free);
297 g_slice_free (Ctx, ctx);
301 select_account_once_ready (EmpathyLogWindow *self,
303 const gchar *chat_id,
304 gboolean is_chatroom)
306 EmpathyAccountChooser *account_chooser;
308 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
310 tp_clear_object (&self->priv->selected_account);
311 self->priv->selected_account = g_object_ref (account);
313 g_free (self->priv->selected_chat_id);
314 self->priv->selected_chat_id = g_strdup (chat_id);
316 self->priv->selected_is_chatroom = is_chatroom;
318 empathy_account_chooser_set_account (account_chooser,
319 self->priv->selected_account);
323 toolbutton_profile_clicked (GtkToolButton *toolbutton,
324 EmpathyLogWindow *self)
326 g_return_if_fail (self != NULL);
327 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
329 empathy_contact_information_dialog_show (self->priv->selected_contact,
334 toolbutton_chat_clicked (GtkToolButton *toolbutton,
335 EmpathyLogWindow *self)
337 g_return_if_fail (self != NULL);
338 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
340 empathy_chat_with_contact (self->priv->selected_contact,
341 gtk_get_current_event_time ());
345 toolbutton_av_clicked (GtkToolButton *toolbutton,
346 EmpathyLogWindow *self)
350 g_return_if_fail (self != NULL);
351 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
353 video = (GTK_WIDGET (toolbutton) == self->priv->button_video);
355 empathy_call_new_with_streams (
356 empathy_contact_get_id (self->priv->selected_contact),
357 empathy_contact_get_account (self->priv->selected_contact),
358 TRUE, video, gtk_get_current_event_time ());
362 insert_or_change_row (EmpathyLogWindow *self,
368 char *str = gtk_tree_path_to_string (path);
369 char *script, *text, *date, *stock_icon;
372 gtk_tree_model_get (model, iter,
373 COL_EVENTS_TEXT, &text,
374 COL_EVENTS_PRETTY_DATE, &date,
375 COL_EVENTS_ICON, &stock_icon,
378 if (!tp_str_empty (stock_icon))
380 GtkIconInfo *icon_info = gtk_icon_theme_lookup_icon (
381 gtk_icon_theme_get_default (),
383 GTK_ICON_SIZE_MENU, 0);
385 if (icon_info != NULL)
386 icon = g_strdup (gtk_icon_info_get_filename (icon_info));
388 gtk_icon_info_free (icon_info);
391 script = g_strdup_printf ("javascript:%s([%s], '%s', '%s', '%s');",
393 g_strdelimit (str, ":", ','),
395 icon != NULL ? icon : "",
398 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
410 store_events_row_inserted (GtkTreeModel *model,
413 EmpathyLogWindow *self)
415 insert_or_change_row (self, "insertRow", model, path, iter);
419 store_events_row_changed (GtkTreeModel *model,
422 EmpathyLogWindow *self)
424 insert_or_change_row (self, "changeRow", model, path, iter);
428 store_events_row_deleted (GtkTreeModel *model,
430 EmpathyLogWindow *self)
432 char *str = gtk_tree_path_to_string (path);
435 script = g_strdup_printf ("javascript:deleteRow([%s]);",
436 g_strdelimit (str, ":", ','));
438 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
446 store_events_has_child_rows (GtkTreeModel *model,
449 EmpathyLogWindow *self)
451 char *str = gtk_tree_path_to_string (path);
454 script = g_strdup_printf ("javascript:hasChildRows([%s], %u);",
455 g_strdelimit (str, ":", ','),
456 gtk_tree_model_iter_has_child (model, iter));
458 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
466 store_events_rows_reordered (GtkTreeModel *model,
470 EmpathyLogWindow *self)
472 char *str = gtk_tree_path_to_string (path);
473 int i, children = gtk_tree_model_iter_n_children (model, iter);
474 char **new_order_strv, *new_order_s;
477 new_order_strv = g_new0 (char *, children + 1);
479 for (i = 0; i < children; i++)
480 new_order_strv[i] = g_strdup_printf ("%i", new_order[i]);
482 new_order_s = g_strjoinv (",", new_order_strv);
484 script = g_strdup_printf ("javascript:reorderRows([%s], [%s]);",
485 str == NULL ? "" : g_strdelimit (str, ":", ','),
488 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
493 g_free (new_order_s);
494 g_strfreev (new_order_strv);
498 events_webview_handle_navigation (WebKitWebView *webview,
499 WebKitWebFrame *frame,
500 WebKitNetworkRequest *request,
501 WebKitWebNavigationAction *navigation_action,
502 WebKitWebPolicyDecision *policy_decision,
503 EmpathyLogWindow *window)
505 empathy_url_show (GTK_WIDGET (webview),
506 webkit_network_request_get_uri (request));
508 webkit_web_policy_decision_ignore (policy_decision);
513 empathy_log_window_constructor (GType type,
515 GObjectConstructParam *props)
519 if (log_window != NULL)
521 retval = (GObject *) log_window;
525 retval = G_OBJECT_CLASS (empathy_log_window_parent_class)
526 ->constructor (type, n_props, props);
528 log_window = EMPATHY_LOG_WINDOW (retval);
529 g_object_add_weak_pointer (retval, (gpointer) &log_window);
536 empathy_log_window_dispose (GObject *object)
538 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (object);
540 if (self->priv->source != 0)
542 g_source_remove (self->priv->source);
543 self->priv->source = 0;
546 if (self->priv->current_dates != NULL)
548 g_list_free_full (self->priv->current_dates,
549 (GDestroyNotify) g_date_free);
550 self->priv->current_dates = NULL;
553 tp_clear_pointer (&self->priv->chain, _tpl_action_chain_free);
554 tp_clear_pointer (&self->priv->channels, g_hash_table_unref);
556 tp_clear_object (&self->priv->observer);
557 tp_clear_object (&self->priv->log_manager);
558 tp_clear_object (&self->priv->selected_account);
559 tp_clear_object (&self->priv->selected_contact);
560 tp_clear_object (&self->priv->events_contact);
561 tp_clear_object (&self->priv->camera_monitor);
563 tp_clear_object (&self->priv->gsettings_chat);
564 tp_clear_object (&self->priv->gsettings_desktop);
566 tp_clear_object (&self->priv->store_events);
568 G_OBJECT_CLASS (empathy_log_window_parent_class)->dispose (object);
572 empathy_log_window_finalize (GObject *object)
574 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (object);
576 g_free (self->priv->last_find);
577 g_free (self->priv->selected_chat_id);
579 G_OBJECT_CLASS (empathy_log_window_parent_class)->finalize (object);
583 empathy_log_window_class_init (
584 EmpathyLogWindowClass *empathy_log_window_class)
586 GObjectClass *object_class = G_OBJECT_CLASS (empathy_log_window_class);
588 g_type_class_add_private (empathy_log_window_class,
589 sizeof (EmpathyLogWindowPriv));
591 object_class->constructor = empathy_log_window_constructor;
592 object_class->dispose = empathy_log_window_dispose;
593 object_class->finalize = empathy_log_window_finalize;
597 empathy_log_window_init (EmpathyLogWindow *self)
599 EmpathyAccountChooser *account_chooser;
603 GtkWidget *vbox, *accounts, *search, *label, *closeitem;
604 GtkWidget *scrolledwindow_events;
607 self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
608 EMPATHY_TYPE_LOG_WINDOW, EmpathyLogWindowPriv);
610 self->priv->chain = _tpl_action_chain_new_async (NULL, NULL, NULL);
612 self->priv->camera_monitor = empathy_camera_monitor_dup_singleton ();
614 self->priv->log_manager = tpl_log_manager_dup_singleton ();
616 self->priv->gsettings_chat = g_settings_new (EMPATHY_PREFS_CHAT_SCHEMA);
617 self->priv->gsettings_desktop = g_settings_new (
618 EMPATHY_PREFS_DESKTOP_INTERFACE_SCHEMA);
620 gtk_window_set_title (GTK_WINDOW (self), _("History"));
621 gtk_widget_set_can_focus (GTK_WIDGET (self), FALSE);
622 gtk_window_set_default_size (GTK_WINDOW (self), 800, 600);
624 filename = empathy_file_lookup ("empathy-log-window.ui", "libempathy-gtk");
625 gui = empathy_builder_get_file (filename,
626 "vbox1", &self->priv->vbox,
627 "toolbutton_profile", &self->priv->button_profile,
628 "toolbutton_chat", &self->priv->button_chat,
629 "toolbutton_call", &self->priv->button_call,
630 "toolbutton_video", &self->priv->button_video,
631 "toolbutton_accounts", &accounts,
632 "toolbutton_search", &search,
633 "imagemenuitem_close", &closeitem,
634 "treeview_who", &self->priv->treeview_who,
635 "treeview_what", &self->priv->treeview_what,
636 "treeview_when", &self->priv->treeview_when,
637 "scrolledwindow_events", &scrolledwindow_events,
638 "notebook", &self->priv->notebook,
639 "spinner", &self->priv->spinner,
643 empathy_builder_connect (gui, self,
644 "toolbutton_profile", "clicked", toolbutton_profile_clicked,
645 "toolbutton_chat", "clicked", toolbutton_chat_clicked,
646 "toolbutton_call", "clicked", toolbutton_av_clicked,
647 "toolbutton_video", "clicked", toolbutton_av_clicked,
648 "imagemenuitem_delete", "activate", log_window_delete_menu_clicked_cb,
651 gtk_container_add (GTK_CONTAINER (self), self->priv->vbox);
653 g_object_unref (gui);
655 g_signal_connect_swapped (closeitem, "activate",
656 G_CALLBACK (gtk_widget_destroy), self);
658 /* Account chooser for chats */
659 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
661 self->priv->account_chooser = empathy_account_chooser_new ();
662 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
663 empathy_account_chooser_set_has_all_option (account_chooser, TRUE);
664 empathy_account_chooser_set_filter (account_chooser,
665 empathy_account_chooser_filter_has_logs, NULL);
666 empathy_account_chooser_set_all (account_chooser);
668 gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->account_chooser),
669 GTK_STYLE_CLASS_RAISED);
671 g_signal_connect (self->priv->account_chooser, "changed",
672 G_CALLBACK (log_window_chats_accounts_changed_cb),
675 label = gtk_label_new (_("Show"));
677 gtk_box_pack_start (GTK_BOX (vbox),
678 self->priv->account_chooser,
681 gtk_box_pack_start (GTK_BOX (vbox),
685 gtk_widget_show_all (vbox);
686 gtk_container_add (GTK_CONTAINER (accounts), vbox);
689 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
691 self->priv->search_entry = gtk_entry_new ();
692 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
693 GTK_ENTRY_ICON_SECONDARY, "edit-find-symbolic");
694 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
695 GTK_ENTRY_ICON_SECONDARY, FALSE);
697 label = gtk_label_new (_("Search"));
699 gtk_box_pack_start (GTK_BOX (vbox),
700 self->priv->search_entry,
703 gtk_box_pack_start (GTK_BOX (vbox),
707 gtk_widget_show_all (vbox);
708 gtk_container_add (GTK_CONTAINER (search), vbox);
710 g_signal_connect (self->priv->search_entry, "changed",
711 G_CALLBACK (log_window_search_entry_changed_cb),
714 g_signal_connect (self->priv->search_entry, "activate",
715 G_CALLBACK (log_window_search_entry_activate_cb),
718 g_signal_connect (self->priv->search_entry, "icon-press",
719 G_CALLBACK (log_window_search_entry_icon_pressed_cb),
723 log_window_events_setup (self);
724 log_window_who_setup (self);
725 log_window_what_setup (self);
726 log_window_when_setup (self);
728 log_window_create_observer (self);
730 log_window_who_populate (self);
733 self->priv->webview = webkit_web_view_new ();
734 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow_events),
735 GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
736 gtk_container_add (GTK_CONTAINER (scrolledwindow_events),
737 self->priv->webview);
738 gtk_widget_show (self->priv->webview);
740 empathy_webkit_bind_font_setting (WEBKIT_WEB_VIEW (self->priv->webview),
741 self->priv->gsettings_desktop,
742 EMPATHY_PREFS_DESKTOP_INTERFACE_FONT_NAME);
744 filename = empathy_file_lookup ("empathy-log-window.html", "data");
745 gfile = g_file_new_for_path (filename);
748 uri = g_file_get_uri (gfile);
749 webkit_web_view_load_uri (WEBKIT_WEB_VIEW (self->priv->webview), uri);
750 g_object_unref (gfile);
753 /* handle all navigation externally */
754 g_signal_connect (self->priv->webview, "navigation-policy-decision-requested",
755 G_CALLBACK (events_webview_handle_navigation), self);
757 /* listen to changes to the treemodel */
758 g_signal_connect (self->priv->store_events, "row-inserted",
759 G_CALLBACK (store_events_row_inserted), self);
760 g_signal_connect (self->priv->store_events, "row-changed",
761 G_CALLBACK (store_events_row_changed), self);
762 g_signal_connect (self->priv->store_events, "row-deleted",
763 G_CALLBACK (store_events_row_deleted), self);
764 g_signal_connect (self->priv->store_events, "rows-reordered",
765 G_CALLBACK (store_events_rows_reordered), self);
766 g_signal_connect (self->priv->store_events, "row-has-child-toggled",
767 G_CALLBACK (store_events_has_child_rows), self);
769 /* track clicked row */
770 g_signal_connect (self->priv->webview, "button-press-event",
771 G_CALLBACK (log_window_events_button_press_event), self);
773 log_window_update_buttons_sensitivity (self);
774 gtk_widget_show (GTK_WIDGET (self));
776 empathy_geometry_bind (GTK_WINDOW (self), "log-window");
780 empathy_log_window_show (TpAccount *account,
781 const gchar *chat_id,
782 gboolean is_chatroom,
785 log_window = g_object_new (EMPATHY_TYPE_LOG_WINDOW, NULL);
787 gtk_window_present (GTK_WINDOW (log_window));
789 if (account != NULL && chat_id != NULL)
790 select_account_once_ready (log_window, account, chat_id, is_chatroom);
793 gtk_window_set_transient_for (GTK_WINDOW (log_window),
794 GTK_WINDOW (parent));
796 return GTK_WIDGET (log_window);
800 account_equal (TpAccount *a,
803 return g_str_equal (tp_proxy_get_object_path (a),
804 tp_proxy_get_object_path (b));
808 entity_equal (TplEntity *a,
811 return g_str_equal (tpl_entity_get_identifier (a),
812 tpl_entity_get_identifier (b));
816 is_same_confroom (TplEvent *e1,
819 TplEntity *sender1 = tpl_event_get_sender (e1);
820 TplEntity *receiver1 = tpl_event_get_receiver (e1);
821 TplEntity *sender2 = tpl_event_get_sender (e2);
822 TplEntity *receiver2 = tpl_event_get_receiver (e2);
823 TplEntity *room1, *room2;
825 if (receiver1 == NULL || receiver2 == NULL)
828 if (tpl_entity_get_entity_type (sender1) == TPL_ENTITY_ROOM)
830 else if (tpl_entity_get_entity_type (receiver1) == TPL_ENTITY_ROOM)
835 if (tpl_entity_get_entity_type (sender2) == TPL_ENTITY_ROOM)
837 else if (tpl_entity_get_entity_type (receiver2) == TPL_ENTITY_ROOM)
842 return g_str_equal (tpl_entity_get_identifier (room1),
843 tpl_entity_get_identifier (room2));
847 maybe_refresh_logs (TpChannel *channel,
850 GList *accounts = NULL, *entities = NULL, *dates = NULL;
852 TplEventTypeMask event_mask;
853 GDate *anytime = NULL, *today = NULL;
854 GDateTime *now = NULL;
855 gboolean refresh = FALSE;
859 if (!log_window_get_selected (log_window,
860 &accounts, &entities, &anyone, &dates, &event_mask, NULL))
862 DEBUG ("Could not get selected rows");
866 type = tp_channel_get_channel_type (channel);
868 /* If the channel type is not in the What pane, whatever has happened
869 * won't be displayed in the events pane. */
870 if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_TEXT) &&
871 !(event_mask & TPL_EVENT_MASK_TEXT))
873 if ((!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA) ||
874 !tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_CALL)) &&
875 !(event_mask & TPL_EVENT_MASK_CALL))
878 anytime = g_date_new_dmy (2, 1, -1);
879 now = g_date_time_new_now_local ();
880 today = g_date_new_dmy (g_date_time_get_day_of_month (now),
881 g_date_time_get_month (now),
882 g_date_time_get_year (now));
884 /* If Today (or anytime) isn't selected, anything that has happened now
885 * won't be displayed. */
886 if (!g_list_find_custom (dates, anytime, (GCompareFunc) g_date_compare) &&
887 !g_list_find_custom (dates, today, (GCompareFunc) g_date_compare))
896 for (acc = accounts, ent = entities;
897 acc != NULL && ent != NULL;
898 acc = g_list_next (acc), ent = g_list_next (ent))
900 if (!account_equal (account, acc->data))
903 if (!tp_strdiff (tp_channel_get_identifier (channel),
904 tpl_entity_get_identifier (ent->data)))
912 tp_clear_pointer (&anytime, g_date_free);
913 tp_clear_pointer (&today, g_date_free);
914 tp_clear_pointer (&now, g_date_time_unref);
915 g_list_free_full (accounts, g_object_unref);
916 g_list_free_full (entities, g_object_unref);
917 g_list_free_full (dates, (GFreeFunc) g_date_free);
921 DEBUG ("Refreshing logs after received event");
923 /* FIXME: We need to populate the entities in case we
924 * didn't have any previous logs with this contact. */
925 log_window_chats_get_messages (log_window, FALSE);
930 on_msg_sent (TpTextChannel *channel,
931 TpSignalledMessage *message,
934 EmpathyLogWindow *self)
936 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
938 maybe_refresh_logs (TP_CHANNEL (channel), account);
942 on_msg_received (TpTextChannel *channel,
943 TpSignalledMessage *message,
944 EmpathyLogWindow *self)
946 TpMessage *msg = TP_MESSAGE (message);
947 TpChannelTextMessageType type = tp_message_get_message_type (msg);
948 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
950 if (type != TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL &&
951 type != TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION)
954 maybe_refresh_logs (TP_CHANNEL (channel), account);
958 on_channel_ended (TpChannel *channel,
962 EmpathyLogWindow *self)
964 if (self->priv->channels != NULL)
965 g_hash_table_remove (self->priv->channels, channel);
969 on_call_ended (TpChannel *channel,
973 EmpathyLogWindow *self)
975 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
977 maybe_refresh_logs (channel, account);
979 if (self->priv->channels != NULL)
980 g_hash_table_remove (self->priv->channels, channel);
984 observe_channels (TpSimpleObserver *observer,
986 TpConnection *connection,
988 TpChannelDispatchOperation *dispatch_operation,
990 TpObserveChannelsContext *context,
993 EmpathyLogWindow *self = user_data;
997 for (l = channels; l != NULL; l = g_list_next (l))
999 TpChannel *channel = l->data;
1000 const gchar *type = tp_channel_get_channel_type (channel);
1002 if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_TEXT))
1004 TpTextChannel *text_channel = TP_TEXT_CHANNEL (channel);
1006 g_hash_table_insert (self->priv->channels,
1007 g_object_ref (channel), g_object_ref (account));
1009 tp_g_signal_connect_object (text_channel, "message-sent",
1010 G_CALLBACK (on_msg_sent), self, 0);
1011 tp_g_signal_connect_object (text_channel, "message-received",
1012 G_CALLBACK (on_msg_received), self, 0);
1013 tp_g_signal_connect_object (channel, "invalidated",
1014 G_CALLBACK (on_channel_ended), self, 0);
1016 else if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_CALL) ||
1017 !tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA))
1019 g_hash_table_insert (self->priv->channels,
1020 g_object_ref (channel), g_object_ref (account));
1022 tp_g_signal_connect_object (channel, "invalidated",
1023 G_CALLBACK (on_call_ended), self, 0);
1027 g_warning ("Unknown channel type: %s", type);
1031 tp_observe_channels_context_accept (context);
1035 log_window_create_observer (EmpathyLogWindow *self)
1037 TpAccountManager *am;
1039 am = tp_account_manager_dup ();
1041 self->priv->observer = tp_simple_observer_new_with_am (am, TRUE, "LogWindow",
1042 TRUE, observe_channels,
1043 g_object_ref (self), g_object_unref);
1045 self->priv->channels = g_hash_table_new_full (g_direct_hash, g_direct_equal,
1046 g_object_unref, g_object_unref);
1048 tp_base_client_take_observer_filter (self->priv->observer,
1050 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1051 TP_IFACE_CHANNEL_TYPE_TEXT,
1053 tp_base_client_take_observer_filter (self->priv->observer,
1055 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1056 TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA,
1058 tp_base_client_take_observer_filter (self->priv->observer,
1060 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1061 TP_IFACE_CHANNEL_TYPE_CALL,
1064 tp_base_client_register (self->priv->observer, NULL);
1066 g_object_unref (am);
1070 event_get_target (TplEvent *event)
1072 TplEntity *sender = tpl_event_get_sender (event);
1073 TplEntity *receiver = tpl_event_get_receiver (event);
1075 if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
1082 model_is_parent (GtkTreeModel *model,
1086 TplEvent *stored_event;
1089 gboolean found = FALSE;
1092 if (gtk_tree_model_iter_parent (model, &parent, iter))
1095 gtk_tree_model_get (model, iter,
1096 COL_EVENTS_ACCOUNT, &account,
1097 COL_EVENTS_TARGET, &target,
1098 COL_EVENTS_EVENT, &stored_event,
1101 if (G_OBJECT_TYPE (event) == G_OBJECT_TYPE (stored_event) &&
1102 account_equal (account, tpl_event_get_account (event)) &&
1103 (entity_equal (target, event_get_target (event)) ||
1104 is_same_confroom (event, stored_event)))
1109 gtk_tree_model_iter_nth_child (model, &child, iter,
1110 gtk_tree_model_iter_n_children (model, iter) - 1);
1112 gtk_tree_model_get (model, &child,
1113 COL_EVENTS_TS, ×tamp,
1116 if (ABS (tpl_event_get_timestamp (event) - timestamp) < MAX_GAP)
1118 /* The gap is smaller than 30 min */
1123 g_object_unref (stored_event);
1124 g_object_unref (account);
1125 g_object_unref (target);
1131 get_display_string_for_chat_message (EmpathyMessage *message,
1134 EmpathyContact *sender, *receiver, *target;
1135 TplEntity *ent_sender, *ent_receiver;
1136 const gchar *format;
1138 sender = empathy_message_get_sender (message);
1139 receiver = empathy_message_get_receiver (message);
1141 ent_sender = tpl_event_get_sender (event);
1142 ent_receiver = tpl_event_get_receiver (event);
1144 /* If this is a MUC, we want to show "Chat in <room>". */
1145 if (tpl_entity_get_entity_type (ent_sender) == TPL_ENTITY_ROOM ||
1146 (ent_receiver != NULL &&
1147 tpl_entity_get_entity_type (ent_receiver) == TPL_ENTITY_ROOM))
1148 format = _("Chat in %s");
1150 format = _("Chat with %s");
1152 if (tpl_entity_get_entity_type (ent_sender) == TPL_ENTITY_ROOM)
1154 else if (ent_receiver != NULL &&
1155 tpl_entity_get_entity_type (ent_receiver) == TPL_ENTITY_ROOM)
1157 else if (empathy_contact_is_user (sender))
1162 return g_markup_printf_escaped (format, empathy_contact_get_alias (target));
1166 get_parent_iter_for_message (TplEvent *event,
1167 EmpathyMessage *message,
1168 GtkTreeIter *parent)
1170 GtkTreeStore *store;
1171 GtkTreeModel *model;
1173 gboolean parent_found = FALSE;
1176 store = log_window->priv->store_events;
1177 model = GTK_TREE_MODEL (store);
1179 for (next = gtk_tree_model_get_iter_first (model, &iter);
1181 next = gtk_tree_model_iter_next (model, &iter))
1183 if ((parent_found = model_is_parent (model, &iter, event)))
1194 gchar *body, *pretty_date;
1196 date = g_date_time_new_from_unix_local (
1197 tpl_event_get_timestamp (event));
1199 pretty_date = g_date_time_format (date,
1200 C_("A date with the time", "%A, %e %B %Y %X"));
1202 body = get_display_string_for_chat_message (message, event);
1204 gtk_tree_store_append (store, &iter, NULL);
1205 gtk_tree_store_set (store, &iter,
1206 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1207 COL_EVENTS_PRETTY_DATE, pretty_date,
1208 COL_EVENTS_TEXT, body,
1209 COL_EVENTS_ICON, "format-justify-fill",
1210 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1211 COL_EVENTS_TARGET, event_get_target (event),
1212 COL_EVENTS_EVENT, event,
1218 g_free (pretty_date);
1219 g_date_time_unref (date);
1223 static const gchar *
1224 get_icon_for_event (TplEvent *event)
1226 const gchar *icon = NULL;
1228 if (TPL_IS_TEXT_EVENT (event))
1230 TplTextEvent *text = TPL_TEXT_EVENT (event);
1232 if (!tp_str_empty (tpl_text_event_get_supersedes_token (text)))
1233 icon = EMPATHY_IMAGE_EDIT_MESSAGE;
1235 #ifdef HAVE_CALL_LOGS
1236 else if (TPL_IS_CALL_EVENT (event))
1238 TplCallEvent *call = TPL_CALL_EVENT (event);
1239 TplCallEndReason reason = tpl_call_event_get_end_reason (call);
1240 TplEntity *sender = tpl_event_get_sender (event);
1241 TplEntity *receiver = tpl_event_get_receiver (event);
1243 if (reason == TPL_CALL_END_REASON_NO_ANSWER)
1244 icon = EMPATHY_IMAGE_CALL_MISSED;
1245 else if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
1246 icon = EMPATHY_IMAGE_CALL_OUTGOING;
1247 else if (tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF)
1248 icon = EMPATHY_IMAGE_CALL_INCOMING;
1256 log_window_append_chat_message (TplEvent *event,
1257 EmpathyMessage *message)
1259 GtkTreeStore *store = log_window->priv->store_events;
1260 GtkTreeIter iter, parent;
1261 gchar *pretty_date, *alias, *body;
1263 EmpathyStringParser *parsers;
1266 date = g_date_time_new_from_unix_local (
1267 tpl_event_get_timestamp (event));
1269 pretty_date = g_date_time_format (date, "%X");
1271 get_parent_iter_for_message (event, message, &parent);
1273 alias = g_markup_escape_text (
1274 tpl_entity_get_alias (tpl_event_get_sender (event)), -1);
1276 /* escape the text */
1277 parsers = empathy_webkit_get_string_parser (
1278 g_settings_get_boolean (log_window->priv->gsettings_chat,
1279 EMPATHY_PREFS_CHAT_SHOW_SMILEYS));
1280 msg = g_string_new ("");
1282 empathy_string_parser_substr (empathy_message_get_body (message), -1,
1285 if (tpl_text_event_get_message_type (TPL_TEXT_EVENT (event))
1286 == TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION)
1288 /* Translators: this is an emote: '* Danielle waves' */
1289 body = g_strdup_printf (_("<i>* %s %s</i>"), alias, msg->str);
1293 /* Translators: this is a message: 'Danielle: hello'
1294 * The string in bold is the sender's name */
1295 body = g_strdup_printf (_("<b>%s:</b> %s"), alias, msg->str);
1298 gtk_tree_store_append (store, &iter, &parent);
1299 gtk_tree_store_set (store, &iter,
1300 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1301 COL_EVENTS_PRETTY_DATE, pretty_date,
1302 COL_EVENTS_TEXT, body,
1303 COL_EVENTS_ICON, get_icon_for_event (event),
1304 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1305 COL_EVENTS_TARGET, event_get_target (event),
1306 COL_EVENTS_EVENT, event,
1309 g_string_free (msg, TRUE);
1312 g_free (pretty_date);
1313 g_date_time_unref (date);
1316 #ifdef HAVE_CALL_LOGS
1318 log_window_append_call (TplEvent *event,
1319 EmpathyMessage *message)
1321 TplCallEvent *call = TPL_CALL_EVENT (event);
1322 GtkTreeStore *store = log_window->priv->store_events;
1323 GtkTreeIter iter, child;
1324 gchar *pretty_date, *duration, *finished;
1325 GDateTime *started_date, *finished_date;
1328 /* If searching, only add the call if the search string appears anywhere */
1329 if (!EMP_STR_EMPTY (log_window->priv->last_find))
1331 if (strstr (tpl_entity_get_identifier (tpl_event_get_sender (event)),
1332 log_window->priv->last_find) == NULL &&
1333 strstr (tpl_entity_get_identifier (tpl_event_get_receiver (event)),
1334 log_window->priv->last_find) == NULL &&
1335 strstr (tpl_call_event_get_detailed_end_reason (call),
1336 log_window->priv->last_find) == NULL)
1338 DEBUG ("TplCallEvent doesn't match search string, ignoring");
1343 started_date = g_date_time_new_from_unix_local (
1344 tpl_event_get_timestamp (event));
1346 pretty_date = g_date_time_format (started_date,
1347 C_("A date with the time", "%A, %e %B %Y %X"));
1349 gtk_tree_store_append (store, &iter, NULL);
1350 gtk_tree_store_set (store, &iter,
1351 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1352 COL_EVENTS_PRETTY_DATE, pretty_date,
1353 COL_EVENTS_TEXT, empathy_message_get_body (message),
1354 COL_EVENTS_ICON, get_icon_for_event (event),
1355 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1356 COL_EVENTS_TARGET, event_get_target (event),
1357 COL_EVENTS_EVENT, event,
1360 if (tpl_call_event_get_end_reason (call) != TPL_CALL_END_REASON_NO_ANSWER)
1365 span = tpl_call_event_get_duration (TPL_CALL_EVENT (event));
1369 tmp = g_strdup_printf ("%" G_GINT64_FORMAT, span);
1370 duration = g_strdup_printf (
1371 ngettext ("%s second", "%s seconds", span), tmp);
1376 tmp = g_strdup_printf ("%" G_GINT64_FORMAT, span / 60);
1377 duration = g_strdup_printf (
1378 ngettext ("%s minute", "%s minutes", span / 60), tmp);
1382 finished_date = g_date_time_add (started_date, -span);
1383 finished = g_date_time_format (finished_date, "%X");
1384 g_date_time_unref (finished_date);
1386 body = g_strdup_printf (_("Call took %s, ended at %s"),
1387 duration, finished);
1392 gtk_tree_store_append (store, &child, &iter);
1393 gtk_tree_store_set (store, &child,
1394 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1395 COL_EVENTS_TEXT, body,
1396 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1397 COL_EVENTS_TARGET, event_get_target (event),
1398 COL_EVENTS_EVENT, event,
1404 g_free (pretty_date);
1405 g_date_time_unref (started_date);
1410 log_window_append_message (TplEvent *event,
1411 EmpathyMessage *message)
1413 if (TPL_IS_TEXT_EVENT (event))
1414 log_window_append_chat_message (event, message);
1415 #ifdef HAVE_CALL_LOGS
1416 else if (TPL_IS_CALL_EVENT (event))
1417 log_window_append_call (event, message);
1420 DEBUG ("Message type not handled");
1424 add_all_accounts_and_entities (GList **accounts,
1428 GtkTreeModel *model;
1431 view = GTK_TREE_VIEW (log_window->priv->treeview_who);
1432 model = gtk_tree_view_get_model (view);
1434 if (!gtk_tree_model_get_iter_first (model, &iter))
1443 gtk_tree_model_get (model, &iter,
1444 COL_WHO_ACCOUNT, &account,
1445 COL_WHO_TARGET, &entity,
1446 COL_WHO_TYPE, &type,
1449 if (type != COL_TYPE_NORMAL)
1452 if (accounts != NULL)
1453 *accounts = g_list_append (*accounts, account);
1455 if (entities != NULL)
1456 *entities = g_list_append (*entities, entity);
1458 while (gtk_tree_model_iter_next (model, &iter));
1462 log_window_get_selected (EmpathyLogWindow *self,
1467 TplEventTypeMask *event_mask,
1468 EventSubtype *subtype)
1471 GtkTreeModel *model;
1472 GtkTreeSelection *selection;
1474 TplEventTypeMask ev = 0;
1475 EventSubtype st = 0;
1479 view = GTK_TREE_VIEW (self->priv->treeview_who);
1480 model = gtk_tree_view_get_model (view);
1481 selection = gtk_tree_view_get_selection (view);
1483 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1487 if (accounts != NULL)
1489 if (entities != NULL)
1494 for (l = paths; l != NULL; l = l->next)
1496 GtkTreePath *path = l->data;
1500 gtk_tree_model_get_iter (model, &iter, path);
1501 gtk_tree_model_get (model, &iter,
1502 COL_WHO_ACCOUNT, &account,
1503 COL_WHO_TARGET, &entity,
1504 COL_WHO_TYPE, &type,
1507 if (type == COL_TYPE_ANY)
1509 if (accounts != NULL || entities != NULL)
1510 add_all_accounts_and_entities (accounts, entities);
1516 if (accounts != NULL)
1517 *accounts = g_list_append (*accounts, g_object_ref (account));
1519 if (entities != NULL)
1520 *entities = g_list_append (*entities, g_object_ref (entity));
1522 g_object_unref (account);
1523 g_object_unref (entity);
1525 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1527 view = GTK_TREE_VIEW (self->priv->treeview_what);
1528 model = gtk_tree_view_get_model (view);
1529 selection = gtk_tree_view_get_selection (view);
1531 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1532 for (l = paths; l != NULL; l = l->next)
1534 GtkTreePath *path = l->data;
1535 TplEventTypeMask mask;
1536 EventSubtype submask;
1538 gtk_tree_model_get_iter (model, &iter, path);
1539 gtk_tree_model_get (model, &iter,
1540 COL_WHAT_TYPE, &mask,
1541 COL_WHAT_SUBTYPE, &submask,
1547 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1549 view = GTK_TREE_VIEW (self->priv->treeview_when);
1550 model = gtk_tree_view_get_model (view);
1551 selection = gtk_tree_view_get_selection (view);
1557 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1558 for (l = paths; l != NULL; l = l->next)
1560 GtkTreePath *path = l->data;
1563 gtk_tree_model_get_iter (model, &iter, path);
1564 gtk_tree_model_get (model, &iter,
1565 COL_WHEN_DATE, &date,
1568 *dates = g_list_append (*dates, date);
1570 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1573 if (event_mask != NULL)
1576 if (subtype != NULL)
1583 model_has_entity (GtkTreeModel *model,
1588 TplLogSearchHit *hit = data;
1591 gboolean ret = FALSE;
1593 gtk_tree_model_get (model, iter,
1595 COL_WHO_ACCOUNT, &a,
1598 if (e != NULL && entity_equal (hit->target, e) &&
1599 a != NULL && account_equal (hit->account, a))
1601 ret = has_element = TRUE;
1604 tp_clear_object (&e);
1605 tp_clear_object (&a);
1611 model_has_date (GtkTreeModel *model,
1619 gtk_tree_model_get (model, iter,
1623 if (!g_date_compare (date, d))
1635 get_events_for_date (TplActionChain *chain, gpointer user_data);
1638 populate_events_from_search_hits (GList *accounts,
1642 TplEventTypeMask event_mask;
1643 EventSubtype subtype;
1646 gboolean is_anytime = FALSE;
1648 if (!log_window_get_selected (log_window,
1649 NULL, NULL, NULL, NULL, &event_mask, &subtype))
1652 anytime = g_date_new_dmy (2, 1, -1);
1653 if (g_list_find_custom (dates, anytime, (GCompareFunc) g_date_compare))
1656 for (l = log_window->priv->hits; l != NULL; l = l->next)
1658 TplLogSearchHit *hit = l->data;
1660 gboolean found = FALSE;
1662 /* Protect against invalid data (corrupt or old log files). */
1663 if (hit->account == NULL || hit->target == NULL)
1666 for (acc = accounts, targ = targets;
1667 acc != NULL && targ != NULL && !found;
1668 acc = acc->next, targ = targ->next)
1670 TpAccount *account = acc->data;
1671 TplEntity *target = targ->data;
1673 if (account_equal (hit->account, account) &&
1674 entity_equal (hit->target, target))
1682 g_list_find_custom (dates, hit->date, (GCompareFunc) g_date_compare)
1687 ctx = ctx_new (log_window, hit->account, hit->target, hit->date,
1688 event_mask, subtype, log_window->priv->count);
1689 _tpl_action_chain_append (log_window->priv->chain,
1690 get_events_for_date, ctx);
1695 _tpl_action_chain_start (log_window->priv->chain);
1697 g_date_free (anytime);
1701 format_date_for_display (GDate *date)
1707 /* g_date_strftime sucks */
1709 now = g_date_new ();
1710 g_date_set_time_t (now, time (NULL));
1712 days_elapsed = g_date_days_between (date, now);
1714 if (days_elapsed < 0)
1718 else if (days_elapsed == 0)
1720 text = g_strdup (_("Today"));
1722 else if (days_elapsed == 1)
1724 text = g_strdup (_("Yesterday"));
1730 dt = g_date_time_new_utc (g_date_get_year (date),
1731 g_date_get_month (date), g_date_get_day (date),
1734 if (days_elapsed <= 7)
1735 text = g_date_time_format (dt, "%A");
1737 text = g_date_time_format (dt,
1738 /* Translators: A date such as '23 May 2010' (strftime format) */
1741 g_date_time_unref (dt);
1750 populate_dates_from_search_hits (GList *accounts,
1755 GtkTreeModel *model;
1756 GtkListStore *store;
1757 GtkTreeSelection *selection;
1760 if (log_window == NULL)
1763 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
1764 model = gtk_tree_view_get_model (view);
1765 store = GTK_LIST_STORE (model);
1766 selection = gtk_tree_view_get_selection (view);
1768 for (l = log_window->priv->hits; l != NULL; l = l->next)
1770 TplLogSearchHit *hit = l->data;
1772 gboolean found = FALSE;
1774 /* Protect against invalid data (corrupt or old log files). */
1775 if (hit->account == NULL || hit->target == NULL)
1778 for (acc = accounts, targ = targets;
1779 acc != NULL && targ != NULL && !found;
1780 acc = acc->next, targ = targ->next)
1782 TpAccount *account = acc->data;
1783 TplEntity *target = targ->data;
1785 if (account_equal (hit->account, account) &&
1786 entity_equal (hit->target, target))
1793 /* Add the date if it's not already there */
1794 has_element = FALSE;
1795 gtk_tree_model_foreach (model, model_has_date, hit->date);
1798 gchar *text = format_date_for_display (hit->date);
1800 gtk_list_store_append (store, &iter);
1801 gtk_list_store_set (store, &iter,
1802 COL_WHEN_DATE, hit->date,
1803 COL_WHEN_TEXT, text,
1804 COL_WHEN_ICON, CALENDAR_ICON,
1809 if (gtk_tree_model_get_iter_first (model, &iter))
1813 date = g_date_new_dmy (1, 1, -1),
1815 gtk_list_store_prepend (store, &iter);
1816 gtk_list_store_set (store, &iter,
1817 COL_WHEN_DATE, date,
1818 COL_WHEN_TEXT, "separator",
1823 date = g_date_new_dmy (2, 1, -1),
1824 gtk_list_store_prepend (store, &iter);
1825 gtk_list_store_set (store, &iter,
1826 COL_WHEN_DATE, date,
1827 COL_WHEN_TEXT, _("Anytime"),
1832 if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 2))
1833 gtk_tree_selection_select_iter (selection, &iter);
1838 populate_entities_from_search_hits (void)
1840 EmpathyAccountChooser *account_chooser;
1843 GtkTreeModel *model;
1844 GtkTreeSelection *selection;
1846 GtkListStore *store;
1849 view = GTK_TREE_VIEW (log_window->priv->treeview_who);
1850 model = gtk_tree_view_get_model (view);
1851 store = GTK_LIST_STORE (model);
1852 selection = gtk_tree_view_get_selection (view);
1854 gtk_list_store_clear (store);
1856 account_chooser = EMPATHY_ACCOUNT_CHOOSER (log_window->priv->account_chooser);
1857 account = empathy_account_chooser_get_account (account_chooser);
1859 for (l = log_window->priv->hits; l; l = l->next)
1861 TplLogSearchHit *hit = l->data;
1863 /* Protect against invalid data (corrupt or old log files). */
1864 if (hit->account == NULL || hit->target == NULL)
1867 /* Filter based on the selected account */
1868 if (account != NULL && !account_equal (account, hit->account))
1871 /* Add the entity if it's not already there */
1872 has_element = FALSE;
1873 gtk_tree_model_foreach (model, model_has_entity, hit);
1876 TplEntityType type = tpl_entity_get_entity_type (hit->target);
1877 EmpathyContact *contact;
1880 gboolean room = type == TPL_ENTITY_ROOM;
1882 contact = empathy_contact_from_tpl_contact (hit->account,
1885 name = empathy_contact_get_alias (contact);
1886 sort_key = g_utf8_collate_key (name, -1);
1888 gtk_list_store_append (store, &iter);
1889 gtk_list_store_set (store, &iter,
1890 COL_WHO_TYPE, COL_TYPE_NORMAL,
1891 COL_WHO_ICON, room ? EMPATHY_IMAGE_GROUP_MESSAGE
1892 : EMPATHY_IMAGE_AVATAR_DEFAULT,
1894 COL_WHO_NAME_SORT_KEY, sort_key,
1895 COL_WHO_ID, tpl_entity_get_identifier (hit->target),
1896 COL_WHO_ACCOUNT, hit->account,
1897 COL_WHO_TARGET, hit->target,
1901 g_object_unref (contact);
1905 if (gtk_tree_model_get_iter_first (model, &iter))
1907 gtk_list_store_prepend (store, &iter);
1908 gtk_list_store_set (store, &iter,
1909 COL_WHO_TYPE, COL_TYPE_SEPARATOR,
1910 COL_WHO_NAME, "separator",
1913 gtk_list_store_prepend (store, &iter);
1914 gtk_list_store_set (store, &iter,
1915 COL_WHO_TYPE, COL_TYPE_ANY,
1916 COL_WHO_NAME, _("Anyone"),
1920 /* Select 'Anyone' */
1921 if (gtk_tree_model_get_iter_first (model, &iter))
1922 gtk_tree_selection_select_iter (selection, &iter);
1926 log_manager_searched_new_cb (GObject *manager,
1927 GAsyncResult *result,
1932 GtkTreeSelection *selection;
1933 GError *error = NULL;
1935 if (log_window == NULL)
1938 if (!tpl_log_manager_search_finish (TPL_LOG_MANAGER (manager),
1939 result, &hits, &error))
1941 DEBUG ("%s. Aborting", error->message);
1942 g_error_free (error);
1946 tp_clear_pointer (&log_window->priv->hits, tpl_log_manager_search_free);
1947 log_window->priv->hits = hits;
1949 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
1950 selection = gtk_tree_view_get_selection (view);
1952 g_signal_handlers_unblock_by_func (selection,
1953 log_window_when_changed_cb,
1956 populate_entities_from_search_hits ();
1960 log_window_find_populate (EmpathyLogWindow *self,
1961 const gchar *search_criteria)
1964 GtkTreeModel *model;
1965 GtkTreeSelection *selection;
1966 GtkListStore *store;
1968 gtk_tree_store_clear (self->priv->store_events);
1970 view = GTK_TREE_VIEW (self->priv->treeview_who);
1971 model = gtk_tree_view_get_model (view);
1972 store = GTK_LIST_STORE (model);
1974 gtk_list_store_clear (store);
1976 view = GTK_TREE_VIEW (self->priv->treeview_when);
1977 model = gtk_tree_view_get_model (view);
1978 store = GTK_LIST_STORE (model);
1979 selection = gtk_tree_view_get_selection (view);
1981 gtk_list_store_clear (store);
1983 if (EMP_STR_EMPTY (search_criteria))
1985 tp_clear_pointer (&self->priv->hits, tpl_log_manager_search_free);
1986 webkit_web_view_set_highlight_text_matches (
1987 WEBKIT_WEB_VIEW (self->priv->webview), FALSE);
1988 log_window_who_populate (self);
1992 g_signal_handlers_block_by_func (selection,
1993 log_window_when_changed_cb,
1996 /* highlight the search text */
1997 webkit_web_view_mark_text_matches (WEBKIT_WEB_VIEW (self->priv->webview),
1998 search_criteria, FALSE, 0);
2000 tpl_log_manager_search_async (self->priv->log_manager,
2001 search_criteria, TPL_EVENT_MASK_ANY,
2002 log_manager_searched_new_cb, NULL);
2006 start_find_search (EmpathyLogWindow *self)
2010 str = gtk_entry_get_text (GTK_ENTRY (self->priv->search_entry));
2012 /* Don't find the same crap again */
2013 if (self->priv->last_find && !tp_strdiff (self->priv->last_find, str))
2016 g_free (self->priv->last_find);
2017 self->priv->last_find = g_strdup (str);
2019 log_window_find_populate (self, str);
2025 log_window_search_entry_changed_cb (GtkWidget *entry,
2026 EmpathyLogWindow *self)
2030 str = gtk_entry_get_text (GTK_ENTRY (self->priv->search_entry));
2032 if (!tp_str_empty (str))
2034 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
2035 GTK_ENTRY_ICON_SECONDARY, "edit-clear-symbolic");
2036 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
2037 GTK_ENTRY_ICON_SECONDARY, TRUE);
2041 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
2042 GTK_ENTRY_ICON_SECONDARY, "edit-find-symbolic");
2043 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
2044 GTK_ENTRY_ICON_SECONDARY, FALSE);
2047 if (self->priv->source != 0)
2048 g_source_remove (self->priv->source);
2049 self->priv->source = g_timeout_add (500, (GSourceFunc) start_find_search,
2054 log_window_search_entry_activate_cb (GtkWidget *entry,
2055 EmpathyLogWindow *self)
2057 start_find_search (self);
2061 log_window_search_entry_icon_pressed_cb (GtkEntry *entry,
2062 GtkEntryIconPosition icon_pos,
2066 if (icon_pos != GTK_ENTRY_ICON_SECONDARY)
2069 gtk_entry_buffer_set_text (gtk_entry_get_buffer (entry),
2074 do_update_buttons_sensitivity (EmpathyLogWindow *self)
2076 EmpathyCapabilities capabilities;
2077 gboolean profile, chat, call, video;
2079 tp_clear_object (&self->priv->button_video_binding);
2081 if (self->priv->selected_contact != NULL)
2083 capabilities = empathy_contact_get_capabilities (
2084 self->priv->selected_contact);
2086 profile = chat = TRUE;
2087 call = capabilities & EMPATHY_CAPABILITIES_AUDIO;
2088 video = capabilities & EMPATHY_CAPABILITIES_VIDEO;
2092 profile = chat = call = video = FALSE;
2095 gtk_widget_set_sensitive (self->priv->button_profile, profile);
2096 gtk_widget_set_sensitive (self->priv->button_chat, chat);
2097 gtk_widget_set_sensitive (self->priv->button_call, call);
2101 self->priv->button_video_binding = g_object_bind_property (
2102 self->priv->camera_monitor, "available",
2103 self->priv->button_video, "sensitive",
2104 G_BINDING_SYNC_CREATE);
2108 /* Don't override the binding */
2109 gtk_widget_set_sensitive (self->priv->button_video, video);
2114 contact_capabilities_changed_cb (EmpathyContact *contact,
2116 EmpathyLogWindow *self)
2118 do_update_buttons_sensitivity (self);
2122 log_window_update_buttons_sensitivity (EmpathyLogWindow *self)
2125 GtkTreeModel *model;
2126 GtkTreeSelection *selection;
2133 if (self->priv->selected_contact != NULL)
2135 g_signal_handlers_disconnect_by_func (self->priv->selected_contact,
2136 contact_capabilities_changed_cb, self);
2138 tp_clear_object (&self->priv->selected_contact);
2141 view = GTK_TREE_VIEW (self->priv->treeview_who);
2142 model = gtk_tree_view_get_model (view);
2143 selection = gtk_tree_view_get_selection (view);
2145 if (!gtk_tree_model_get_iter_first (model, &iter))
2148 if (gtk_tree_selection_count_selected_rows (selection) != 1)
2151 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2154 paths = gtk_tree_selection_get_selected_rows (selection, &model);
2155 g_return_if_fail (paths != NULL);
2158 gtk_tree_model_get_iter (model, &iter, path);
2159 gtk_tree_model_get (model, &iter,
2160 COL_WHO_ACCOUNT, &account,
2161 COL_WHO_TARGET, &target,
2164 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
2166 self->priv->selected_contact = empathy_contact_from_tpl_contact (account,
2169 g_object_unref (account);
2170 g_object_unref (target);
2175 /* If the Who pane doesn't contain a contact (e.g. it has many
2176 * selected, or has 'Anyone', let's try to get the contact from
2177 * the selected event. */
2179 if (self->priv->events_contact != NULL)
2180 self->priv->selected_contact = g_object_ref (self->priv->events_contact);
2183 if (self->priv->selected_contact != NULL)
2185 tp_g_signal_connect_object (self->priv->selected_contact,
2186 "notify::capabilities", G_CALLBACK (contact_capabilities_changed_cb),
2190 do_update_buttons_sensitivity (self);
2194 log_window_update_what_iter_sensitivity (GtkTreeModel *model,
2198 GtkTreeStore *store = GTK_TREE_STORE (model);
2202 gtk_tree_store_set (store, iter,
2203 COL_WHAT_SENSITIVE, sensitive,
2206 for (next = gtk_tree_model_iter_children (model, &child, iter);
2208 next = gtk_tree_model_iter_next (model, &child))
2210 gtk_tree_store_set (store, &child,
2211 COL_WHAT_SENSITIVE, sensitive,
2217 log_window_update_what_sensitivity (EmpathyLogWindow *self)
2220 GtkTreeModel *model;
2222 GList *accounts, *targets, *acc, *targ;
2225 if (!log_window_get_selected (self, &accounts, &targets, NULL, NULL,
2229 view = GTK_TREE_VIEW (self->priv->treeview_what);
2230 model = gtk_tree_view_get_model (view);
2232 /* For each event type... */
2233 for (next = gtk_tree_model_get_iter_first (model, &iter);
2235 next = gtk_tree_model_iter_next (model, &iter))
2237 TplEventTypeMask type;
2239 gtk_tree_model_get (model, &iter,
2240 COL_WHAT_TYPE, &type,
2243 /* ...we set the type and its subtypes (if any) unsensitive... */
2244 log_window_update_what_iter_sensitivity (model, &iter, FALSE);
2246 for (acc = accounts, targ = targets;
2247 acc != NULL && targ != NULL;
2248 acc = acc->next, targ = targ->next)
2250 TpAccount *account = acc->data;
2251 TplEntity *target = targ->data;
2253 if (tpl_log_manager_exists (self->priv->log_manager,
2254 account, target, type))
2256 /* And then we set it (and its subtypes, again, if any)
2257 * as sensitive if there are logs of that type. */
2258 log_window_update_what_iter_sensitivity (model, &iter, TRUE);
2264 g_list_free_full (accounts, g_object_unref);
2265 g_list_free_full (targets, g_object_unref);
2269 log_window_who_changed_cb (GtkTreeSelection *selection,
2270 EmpathyLogWindow *self)
2273 GtkTreeModel *model;
2276 DEBUG ("log_window_who_changed_cb");
2278 view = gtk_tree_selection_get_tree_view (selection);
2279 model = gtk_tree_view_get_model (view);
2281 if (gtk_tree_model_get_iter_first (model, &iter))
2283 /* If 'Anyone' is selected, everything else should be deselected */
2284 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2286 g_signal_handlers_block_by_func (selection,
2287 log_window_who_changed_cb,
2290 gtk_tree_selection_unselect_all (selection);
2291 gtk_tree_selection_select_iter (selection, &iter);
2293 g_signal_handlers_unblock_by_func (selection,
2294 log_window_who_changed_cb,
2299 log_window_update_what_sensitivity (self);
2300 log_window_update_buttons_sensitivity (self);
2302 /* The contact changed, so the dates need to be updated */
2303 log_window_chats_get_messages (self, TRUE);
2307 log_manager_got_entities_cb (GObject *manager,
2308 GAsyncResult *result,
2311 Ctx *ctx = user_data;
2315 GtkTreeModel *model;
2316 GtkTreeSelection *selection;
2317 GtkListStore *store;
2319 GError *error = NULL;
2320 gboolean select_account = FALSE;
2322 if (log_window == NULL)
2325 if (log_window->priv->count != ctx->count)
2328 if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager),
2329 result, &entities, &error))
2331 DEBUG ("%s. Aborting", error->message);
2332 g_error_free (error);
2336 view = GTK_TREE_VIEW (ctx->self->priv->treeview_who);
2337 model = gtk_tree_view_get_model (view);
2338 selection = gtk_tree_view_get_selection (view);
2339 store = GTK_LIST_STORE (model);
2341 /* Block signals to stop the logs being retrieved prematurely */
2342 g_signal_handlers_block_by_func (selection,
2343 log_window_who_changed_cb, ctx->self);
2345 for (l = entities; l; l = l->next)
2347 TplEntity *entity = TPL_ENTITY (l->data);
2348 TplEntityType type = tpl_entity_get_entity_type (entity);
2349 EmpathyContact *contact;
2352 gboolean room = type == TPL_ENTITY_ROOM;
2354 contact = empathy_contact_from_tpl_contact (ctx->account, entity);
2356 name = empathy_contact_get_alias (contact);
2357 sort_key = g_utf8_collate_key (name, -1);
2359 gtk_list_store_append (store, &iter);
2360 gtk_list_store_set (store, &iter,
2361 COL_WHO_TYPE, COL_TYPE_NORMAL,
2362 COL_WHO_ICON, room ? EMPATHY_IMAGE_GROUP_MESSAGE
2363 : EMPATHY_IMAGE_AVATAR_DEFAULT,
2365 COL_WHO_NAME_SORT_KEY, sort_key,
2366 COL_WHO_ID, tpl_entity_get_identifier (entity),
2367 COL_WHO_ACCOUNT, ctx->account,
2368 COL_WHO_TARGET, entity,
2372 g_object_unref (contact);
2374 if (ctx->self->priv->selected_account != NULL &&
2375 !tp_strdiff (tp_proxy_get_object_path (ctx->account),
2376 tp_proxy_get_object_path (ctx->self->priv->selected_account)))
2377 select_account = TRUE;
2379 g_list_free_full (entities, g_object_unref);
2381 if (gtk_tree_model_get_iter_first (model, &iter))
2385 gtk_tree_model_get (model, &iter,
2386 COL_WHO_TYPE, &type,
2389 if (type != COL_TYPE_ANY)
2391 gtk_list_store_prepend (store, &iter);
2392 gtk_list_store_set (store, &iter,
2393 COL_WHO_TYPE, COL_TYPE_SEPARATOR,
2394 COL_WHO_NAME, "separator",
2397 gtk_list_store_prepend (store, &iter);
2398 gtk_list_store_set (store, &iter,
2399 COL_WHO_TYPE, COL_TYPE_ANY,
2400 COL_WHO_NAME, _("Anyone"),
2405 /* Unblock signals */
2406 g_signal_handlers_unblock_by_func (selection,
2407 log_window_who_changed_cb,
2410 /* We display the selected account if we populate the model with chats from
2413 log_window_chats_set_selected (ctx->self);
2416 _tpl_action_chain_continue (log_window->priv->chain);
2421 get_entities_for_account (TplActionChain *chain, gpointer user_data)
2423 Ctx *ctx = user_data;
2425 tpl_log_manager_get_entities_async (ctx->self->priv->log_manager, ctx->account,
2426 log_manager_got_entities_cb, ctx);
2430 select_first_entity (TplActionChain *chain, gpointer user_data)
2432 EmpathyLogWindow *self = user_data;
2434 GtkTreeModel *model;
2435 GtkTreeSelection *selection;
2438 view = GTK_TREE_VIEW (self->priv->treeview_who);
2439 model = gtk_tree_view_get_model (view);
2440 selection = gtk_tree_view_get_selection (view);
2442 if (gtk_tree_model_get_iter_first (model, &iter))
2443 gtk_tree_selection_select_iter (selection, &iter);
2445 _tpl_action_chain_continue (self->priv->chain);
2449 log_window_who_populate (EmpathyLogWindow *self)
2451 EmpathyAccountChooser *account_chooser;
2453 gboolean all_accounts;
2455 GtkTreeModel *model;
2456 GtkTreeSelection *selection;
2457 GtkListStore *store;
2460 if (self->priv->hits != NULL)
2462 populate_entities_from_search_hits ();
2466 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
2467 account = empathy_account_chooser_dup_account (account_chooser);
2468 all_accounts = empathy_account_chooser_has_all_selected (account_chooser);
2470 view = GTK_TREE_VIEW (self->priv->treeview_who);
2471 model = gtk_tree_view_get_model (view);
2472 selection = gtk_tree_view_get_selection (view);
2473 store = GTK_LIST_STORE (model);
2475 /* Block signals to stop the logs being retrieved prematurely */
2476 g_signal_handlers_block_by_func (selection,
2477 log_window_who_changed_cb,
2480 gtk_list_store_clear (store);
2482 /* Unblock signals */
2483 g_signal_handlers_unblock_by_func (selection,
2484 log_window_who_changed_cb,
2487 _tpl_action_chain_clear (self->priv->chain);
2488 self->priv->count++;
2490 if (!all_accounts && account == NULL)
2494 else if (!all_accounts)
2496 ctx = ctx_new (self, account, NULL, NULL, 0, 0, self->priv->count);
2497 _tpl_action_chain_append (self->priv->chain, get_entities_for_account, ctx);
2501 TpAccountManager *manager;
2502 GList *accounts, *l;
2504 manager = empathy_account_chooser_get_account_manager (account_chooser);
2505 accounts = tp_account_manager_get_valid_accounts (manager);
2507 for (l = accounts; l != NULL; l = l->next)
2511 ctx = ctx_new (self, account, NULL, NULL, 0, 0, self->priv->count);
2512 _tpl_action_chain_append (self->priv->chain,
2513 get_entities_for_account, ctx);
2516 g_list_free (accounts);
2518 _tpl_action_chain_append (self->priv->chain, select_first_entity, self);
2519 _tpl_action_chain_start (self->priv->chain);
2523 sort_by_name_key (GtkTreeModel *model,
2532 gtk_tree_model_get (model, a,
2533 COL_WHO_TYPE, &type1,
2534 COL_WHO_NAME_SORT_KEY, &key1,
2537 gtk_tree_model_get (model, b,
2538 COL_WHO_TYPE, &type2,
2539 COL_WHO_NAME_SORT_KEY, &key2,
2542 if (type1 == COL_TYPE_ANY)
2544 else if (type2 == COL_TYPE_ANY)
2546 else if (type1 == COL_TYPE_SEPARATOR)
2548 else if (type2 == COL_TYPE_SEPARATOR)
2551 ret = g_strcmp0 (key1, key2);
2560 who_row_is_separator (GtkTreeModel *model,
2566 gtk_tree_model_get (model, iter,
2567 COL_WHO_TYPE, &type,
2570 return (type == COL_TYPE_SEPARATOR);
2574 log_window_find_row (EmpathyLogWindow *self,
2575 GdkEventButton *event)
2577 WebKitHitTestResult *hit = webkit_web_view_get_hit_test_result (
2578 WEBKIT_WEB_VIEW (self->priv->webview), event);
2579 WebKitDOMNode *inner_node;
2581 tp_clear_object (&self->priv->events_contact);
2584 "inner-node", &inner_node,
2587 if (inner_node != NULL)
2589 GtkTreeModel *model = GTK_TREE_MODEL (self->priv->store_events);
2590 WebKitDOMNode *node;
2591 const char *path = NULL;
2594 /* walk back up the DOM tree looking for a node with empathy:path set */
2595 for (node = inner_node; node != NULL;
2596 node = webkit_dom_node_get_parent_node (node))
2598 if (!WEBKIT_DOM_IS_ELEMENT (node))
2601 path = webkit_dom_element_get_attribute_ns (
2602 WEBKIT_DOM_ELEMENT (node), EMPATHY_NS, "path");
2604 if (!tp_str_empty (path))
2608 /* look up the contact for this path */
2609 if (!tp_str_empty (path) &&
2610 gtk_tree_model_get_iter_from_string (model, &iter, path))
2615 gtk_tree_model_get (model, &iter,
2616 COL_EVENTS_ACCOUNT, &account,
2617 COL_EVENTS_TARGET, &target,
2620 self->priv->events_contact = empathy_contact_from_tpl_contact (
2623 g_object_unref (account);
2624 g_object_unref (target);
2627 g_object_unref (inner_node);
2630 g_object_unref (hit);
2632 log_window_update_buttons_sensitivity (self);
2636 log_window_events_button_press_event (GtkWidget *webview,
2637 GdkEventButton *event,
2638 EmpathyLogWindow *self)
2640 switch (event->button)
2643 log_window_find_row (self, event);
2647 empathy_webkit_context_menu_for_event (
2648 WEBKIT_WEB_VIEW (webview), event, 0);
2659 log_window_events_setup (EmpathyLogWindow *self)
2661 GtkTreeSortable *sortable;
2662 GtkTreeStore *store;
2665 self->priv->store_events = store = gtk_tree_store_new (COL_EVENTS_COUNT,
2666 G_TYPE_INT, /* type */
2667 G_TYPE_INT64, /* timestamp */
2668 G_TYPE_STRING, /* stringified date */
2669 G_TYPE_STRING, /* icon */
2670 G_TYPE_STRING, /* name */
2671 TP_TYPE_ACCOUNT, /* account */
2672 TPL_TYPE_ENTITY, /* target */
2673 TPL_TYPE_EVENT); /* event */
2675 sortable = GTK_TREE_SORTABLE (store);
2677 gtk_tree_sortable_set_sort_column_id (sortable,
2679 GTK_SORT_ASCENDING);
2683 log_window_who_setup (EmpathyLogWindow *self)
2686 GtkTreeModel *model;
2687 GtkTreeSelection *selection;
2688 GtkTreeSortable *sortable;
2689 GtkTreeViewColumn *column;
2690 GtkListStore *store;
2691 GtkCellRenderer *cell;
2693 view = GTK_TREE_VIEW (self->priv->treeview_who);
2694 selection = gtk_tree_view_get_selection (view);
2697 store = gtk_list_store_new (COL_WHO_COUNT,
2698 G_TYPE_INT, /* type */
2699 G_TYPE_STRING, /* icon */
2700 G_TYPE_STRING, /* name */
2701 G_TYPE_STRING, /* name sort key */
2702 G_TYPE_STRING, /* id */
2703 TP_TYPE_ACCOUNT, /* account */
2704 TPL_TYPE_ENTITY); /* target */
2706 model = GTK_TREE_MODEL (store);
2707 sortable = GTK_TREE_SORTABLE (store);
2709 gtk_tree_view_set_model (view, model);
2712 column = gtk_tree_view_column_new ();
2713 gtk_tree_view_column_set_title (column, _("Who"));
2715 cell = gtk_cell_renderer_pixbuf_new ();
2716 gtk_tree_view_column_pack_start (column, cell, FALSE);
2717 gtk_tree_view_column_add_attribute (column, cell,
2721 cell = gtk_cell_renderer_text_new ();
2722 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2723 gtk_tree_view_column_pack_start (column, cell, TRUE);
2724 gtk_tree_view_column_add_attribute (column, cell,
2728 gtk_tree_view_append_column (view, column);
2730 /* set up treeview properties */
2731 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
2732 gtk_tree_view_set_row_separator_func (view, who_row_is_separator,
2735 gtk_tree_sortable_set_sort_column_id (sortable,
2736 COL_WHO_NAME_SORT_KEY,
2737 GTK_SORT_ASCENDING);
2738 gtk_tree_sortable_set_sort_func (sortable,
2739 COL_WHO_NAME_SORT_KEY, sort_by_name_key,
2742 gtk_tree_view_set_search_column (view, COL_WHO_NAME);
2743 gtk_tree_view_set_tooltip_column (view, COL_WHO_ID);
2745 /* set up signals */
2746 g_signal_connect (selection, "changed",
2747 G_CALLBACK (log_window_who_changed_cb), self);
2749 g_object_unref (store);
2753 log_window_chats_accounts_changed_cb (GtkWidget *combobox,
2754 EmpathyLogWindow *self)
2756 /* Clear all current messages shown in the textview */
2757 gtk_tree_store_clear (self->priv->store_events);
2759 log_window_who_populate (self);
2763 log_window_chats_set_selected (EmpathyLogWindow *self)
2766 GtkTreeModel *model;
2767 GtkTreeSelection *selection;
2772 view = GTK_TREE_VIEW (self->priv->treeview_who);
2773 model = gtk_tree_view_get_model (view);
2774 selection = gtk_tree_view_get_selection (view);
2776 for (next = gtk_tree_model_get_iter_first (model, &iter);
2778 next = gtk_tree_model_iter_next (model, &iter))
2780 TpAccount *this_account;
2781 TplEntity *this_target;
2782 const gchar *this_chat_id;
2783 gboolean this_is_chatroom;
2786 gtk_tree_model_get (model, &iter,
2787 COL_WHO_TYPE, &this_type,
2788 COL_WHO_ACCOUNT, &this_account,
2789 COL_WHO_TARGET, &this_target,
2792 if (this_type != COL_TYPE_NORMAL)
2795 this_chat_id = tpl_entity_get_identifier (this_target);
2796 this_is_chatroom = tpl_entity_get_entity_type (this_target)
2799 if (this_account == self->priv->selected_account &&
2800 !tp_strdiff (this_chat_id, self->priv->selected_chat_id) &&
2801 this_is_chatroom == self->priv->selected_is_chatroom)
2803 gtk_tree_selection_select_iter (selection, &iter);
2804 path = gtk_tree_model_get_path (model, &iter);
2805 gtk_tree_view_scroll_to_cell (view, path, NULL, TRUE, 0.5, 0.0);
2806 gtk_tree_path_free (path);
2807 g_object_unref (this_account);
2808 g_object_unref (this_target);
2812 g_object_unref (this_account);
2813 g_object_unref (this_target);
2816 tp_clear_object (&self->priv->selected_account);
2817 tp_clear_pointer (&self->priv->selected_chat_id, g_free);
2821 sort_by_date (GtkTreeModel *model,
2826 GDate *date1, *date2;
2829 gtk_tree_model_get (model, a,
2830 COL_WHEN_DATE, &date1,
2833 gtk_tree_model_get (model, b,
2834 COL_WHEN_DATE, &date2,
2837 result = g_date_compare (date1, date2);
2839 g_date_free (date1);
2840 g_date_free (date2);
2845 when_row_is_separator (GtkTreeModel *model,
2852 gtk_tree_model_get (model, iter,
2853 COL_WHEN_TEXT, &when,
2856 ret = !tp_strdiff (when, "separator");
2862 log_window_when_changed_cb (GtkTreeSelection *selection,
2863 EmpathyLogWindow *self)
2866 GtkTreeModel *model;
2869 DEBUG ("log_window_when_changed_cb");
2871 view = gtk_tree_selection_get_tree_view (selection);
2872 model = gtk_tree_view_get_model (view);
2874 /* If 'Anytime' is selected, everything else should be deselected */
2875 if (gtk_tree_model_get_iter_first (model, &iter))
2877 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2879 g_signal_handlers_block_by_func (selection,
2880 log_window_when_changed_cb,
2883 gtk_tree_selection_unselect_all (selection);
2884 gtk_tree_selection_select_iter (selection, &iter);
2886 g_signal_handlers_unblock_by_func (selection,
2887 log_window_when_changed_cb,
2892 log_window_chats_get_messages (self, FALSE);
2896 log_window_when_setup (EmpathyLogWindow *self)
2899 GtkTreeModel *model;
2900 GtkTreeSelection *selection;
2901 GtkTreeSortable *sortable;
2902 GtkTreeViewColumn *column;
2903 GtkListStore *store;
2904 GtkCellRenderer *cell;
2906 view = GTK_TREE_VIEW (self->priv->treeview_when);
2907 selection = gtk_tree_view_get_selection (view);
2910 store = gtk_list_store_new (COL_WHEN_COUNT,
2911 G_TYPE_DATE, /* date */
2912 G_TYPE_STRING, /* stringified date */
2913 G_TYPE_STRING); /* icon */
2915 model = GTK_TREE_MODEL (store);
2916 sortable = GTK_TREE_SORTABLE (store);
2918 gtk_tree_view_set_model (view, model);
2921 column = gtk_tree_view_column_new ();
2922 gtk_tree_view_column_set_title (column, _("When"));
2924 cell = gtk_cell_renderer_pixbuf_new ();
2925 gtk_tree_view_column_pack_start (column, cell, FALSE);
2926 gtk_tree_view_column_add_attribute (column, cell,
2927 "icon-name", COL_WHEN_ICON);
2929 cell = gtk_cell_renderer_text_new ();
2930 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2931 gtk_tree_view_column_pack_start (column, cell, TRUE);
2932 gtk_tree_view_column_add_attribute (column, cell,
2936 gtk_tree_view_append_column (view, column);
2938 /* set up treeview properties */
2939 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
2940 gtk_tree_view_set_row_separator_func (view, when_row_is_separator,
2942 gtk_tree_sortable_set_sort_column_id (sortable,
2944 GTK_SORT_DESCENDING);
2945 gtk_tree_sortable_set_sort_func (sortable,
2946 COL_WHEN_DATE, sort_by_date,
2949 gtk_tree_view_set_search_column (view, COL_WHEN_TEXT);
2951 /* set up signals */
2952 g_signal_connect (selection, "changed",
2953 G_CALLBACK (log_window_when_changed_cb),
2956 g_object_unref (store);
2960 what_row_is_separator (GtkTreeModel *model,
2966 gtk_tree_model_get (model, iter,
2967 COL_WHAT_TYPE, &type,
2970 return (type == WHAT_TYPE_SEPARATOR);
2974 log_window_what_changed_cb (GtkTreeSelection *selection,
2975 EmpathyLogWindow *self)
2978 GtkTreeModel *model;
2981 DEBUG ("log_window_what_changed_cb");
2983 view = gtk_tree_selection_get_tree_view (selection);
2984 model = gtk_tree_view_get_model (view);
2986 /* If 'Anything' is selected, everything else should be deselected */
2987 if (gtk_tree_model_get_iter_first (model, &iter))
2989 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2991 g_signal_handlers_block_by_func (selection,
2992 log_window_what_changed_cb,
2995 gtk_tree_selection_unselect_all (selection);
2996 gtk_tree_selection_select_iter (selection, &iter);
2998 g_signal_handlers_unblock_by_func (selection,
2999 log_window_what_changed_cb,
3004 /* The dates need to be updated if we're not searching */
3005 log_window_chats_get_messages (self, self->priv->hits == NULL);
3009 log_window_what_collapse_row_cb (GtkTreeView *tree_view,
3014 /* Reject collapsing */
3021 EventSubtype subtype;
3027 log_window_what_setup (EmpathyLogWindow *self)
3030 GtkTreeModel *model;
3031 GtkTreeSelection *selection;
3032 GtkTreeViewColumn *column;
3034 GtkTreeStore *store;
3035 GtkCellRenderer *cell;
3037 struct event events [] = {
3038 { TPL_EVENT_MASK_ANY, 0, NULL, _("Anything") },
3039 { WHAT_TYPE_SEPARATOR, 0, NULL, "separator" },
3040 { TPL_EVENT_MASK_TEXT, 0, "format-justify-fill", _("Text chats") },
3041 #ifdef HAVE_CALL_LOGS
3042 { TPL_EVENT_MASK_CALL, EVENT_CALL_ALL, EMPATHY_IMAGE_CALL, _("Calls") },
3045 #ifdef HAVE_CALL_LOGS
3046 struct event call_events [] = {
3047 { TPL_EVENT_MASK_CALL, EVENT_CALL_INCOMING, EMPATHY_IMAGE_CALL_INCOMING, _("Incoming calls") },
3048 { TPL_EVENT_MASK_CALL, EVENT_CALL_OUTGOING, EMPATHY_IMAGE_CALL_OUTGOING, _("Outgoing calls") },
3049 { TPL_EVENT_MASK_CALL, EVENT_CALL_MISSED, EMPATHY_IMAGE_CALL_MISSED, _("Missed calls") }
3054 view = GTK_TREE_VIEW (self->priv->treeview_what);
3055 selection = gtk_tree_view_get_selection (view);
3058 store = gtk_tree_store_new (COL_WHAT_COUNT,
3059 G_TYPE_INT, /* history type */
3060 G_TYPE_INT, /* history subtype */
3061 G_TYPE_BOOLEAN, /* sensitive */
3062 G_TYPE_STRING, /* stringified history type */
3063 G_TYPE_STRING); /* icon */
3065 model = GTK_TREE_MODEL (store);
3067 gtk_tree_view_set_model (view, model);
3070 column = gtk_tree_view_column_new ();
3071 gtk_tree_view_column_set_title (column, _("What"));
3073 cell = gtk_cell_renderer_pixbuf_new ();
3074 gtk_tree_view_column_pack_start (column, cell, FALSE);
3075 gtk_tree_view_column_add_attribute (column, cell,
3076 "icon-name", COL_WHAT_ICON);
3078 cell = gtk_cell_renderer_text_new ();
3079 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
3080 gtk_tree_view_column_pack_start (column, cell, TRUE);
3081 gtk_tree_view_column_add_attribute (column, cell,
3082 "text", COL_WHAT_TEXT);
3083 gtk_tree_view_column_add_attribute (column, cell,
3084 "sensitive", COL_WHAT_SENSITIVE);
3086 gtk_tree_view_append_column (view, column);
3087 gtk_tree_view_set_search_column (view, COL_WHAT_TEXT);
3089 /* set up treeview properties */
3090 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
3091 gtk_tree_view_set_show_expanders (view, FALSE);
3092 gtk_tree_view_set_level_indentation (view, 12);
3093 gtk_tree_view_expand_all (view);
3094 gtk_tree_view_set_row_separator_func (view, what_row_is_separator,
3098 for (i = 0; i < G_N_ELEMENTS (events); i++)
3100 gtk_tree_store_append (store, &iter, NULL);
3101 gtk_tree_store_set (store, &iter,
3102 COL_WHAT_TYPE, events[i].type,
3103 COL_WHAT_SUBTYPE, events[i].subtype,
3104 COL_WHAT_SENSITIVE, TRUE,
3105 COL_WHAT_TEXT, events[i].text,
3106 COL_WHAT_ICON, events[i].icon,
3110 #ifdef HAVE_CALL_LOGS
3111 gtk_tree_model_iter_nth_child (model, &parent, NULL, 3);
3112 for (i = 0; i < G_N_ELEMENTS (call_events); i++)
3114 gtk_tree_store_append (store, &iter, &parent);
3115 gtk_tree_store_set (store, &iter,
3116 COL_WHAT_TYPE, call_events[i].type,
3117 COL_WHAT_SUBTYPE, call_events[i].subtype,
3118 COL_WHAT_SENSITIVE, TRUE,
3119 COL_WHAT_TEXT, call_events[i].text,
3120 COL_WHAT_ICON, call_events[i].icon,
3125 gtk_tree_view_expand_all (view);
3127 /* select 'Anything' */
3128 if (gtk_tree_model_get_iter_first (model, &iter))
3129 gtk_tree_selection_select_iter (selection, &iter);
3131 /* set up signals */
3132 g_signal_connect (view, "test-collapse-row",
3133 G_CALLBACK (log_window_what_collapse_row_cb),
3135 g_signal_connect (selection, "changed",
3136 G_CALLBACK (log_window_what_changed_cb),
3139 g_object_unref (store);
3143 log_window_maybe_expand_events (void)
3145 GtkTreeModel *model = GTK_TREE_MODEL (log_window->priv->store_events);
3147 /* If there's only one result, expand it */
3148 if (gtk_tree_model_iter_n_children (model, NULL) == 1)
3149 webkit_web_view_execute_script (
3150 WEBKIT_WEB_VIEW (log_window->priv->webview),
3151 "javascript:expandAll()");
3155 show_spinner (gpointer data)
3159 if (log_window == NULL)
3162 g_object_get (log_window->priv->spinner, "active", &active, NULL);
3165 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3172 show_events (TplActionChain *chain,
3175 log_window_maybe_expand_events ();
3176 gtk_spinner_stop (GTK_SPINNER (log_window->priv->spinner));
3177 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3180 _tpl_action_chain_continue (chain);
3184 start_spinner (void)
3186 gtk_spinner_start (GTK_SPINNER (log_window->priv->spinner));
3187 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3190 g_timeout_add (1000, show_spinner, NULL);
3191 _tpl_action_chain_append (log_window->priv->chain, show_events, NULL);
3195 log_window_got_messages_for_date_cb (GObject *manager,
3196 GAsyncResult *result,
3199 Ctx *ctx = user_data;
3200 GtkTreeModel *model;
3204 GError *error = NULL;
3207 if (log_window == NULL)
3213 if (log_window->priv->count != ctx->count)
3216 if (!tpl_log_manager_get_events_for_date_finish (TPL_LOG_MANAGER (manager),
3217 result, &events, &error))
3219 DEBUG ("Unable to retrieve messages for the selected date: %s. Aborting",
3221 g_error_free (error);
3225 for (l = events; l; l = l->next)
3227 TplEvent *event = l->data;
3228 gboolean append = TRUE;
3230 #ifdef HAVE_CALL_LOGS
3231 if (TPL_IS_CALL_EVENT (l->data)
3232 && ctx->event_mask & TPL_EVENT_MASK_CALL
3233 && ctx->event_mask != TPL_EVENT_MASK_ANY)
3235 TplCallEvent *call = l->data;
3239 if (ctx->subtype & EVENT_CALL_ALL)
3245 TplCallEndReason reason = tpl_call_event_get_end_reason (call);
3246 TplEntity *sender = tpl_event_get_sender (event);
3247 TplEntity *receiver = tpl_event_get_receiver (event);
3249 if (reason == TPL_CALL_END_REASON_NO_ANSWER)
3251 if (ctx->subtype & EVENT_CALL_MISSED)
3254 else if (ctx->subtype & EVENT_CALL_OUTGOING
3255 && tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
3259 else if (ctx->subtype & EVENT_CALL_INCOMING
3260 && tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF)
3270 EmpathyMessage *msg = empathy_message_from_tpl_log_event (event);
3271 log_window_append_message (event, msg);
3272 tp_clear_object (&msg);
3275 g_object_unref (event);
3277 g_list_free (events);
3279 model = GTK_TREE_MODEL (log_window->priv->store_events);
3280 n = gtk_tree_model_iter_n_children (model, NULL) - 1;
3282 if (n >= 0 && gtk_tree_model_iter_nth_child (model, &iter, NULL, n))
3287 path = gtk_tree_model_get_path (model, &iter);
3288 str = gtk_tree_path_to_string (path);
3290 script = g_strdup_printf ("javascript:scrollToRow([%s]);",
3291 g_strdelimit (str, ":", ','));
3293 webkit_web_view_execute_script (
3294 WEBKIT_WEB_VIEW (log_window->priv->webview),
3297 gtk_tree_path_free (path);
3305 _tpl_action_chain_continue (log_window->priv->chain);
3309 get_events_for_date (TplActionChain *chain, gpointer user_data)
3311 Ctx *ctx = user_data;
3313 tpl_log_manager_get_events_for_date_async (ctx->self->priv->log_manager,
3314 ctx->account, ctx->entity, ctx->event_mask,
3316 log_window_got_messages_for_date_cb,
3321 log_window_get_messages_for_dates (EmpathyLogWindow *self,
3324 GList *accounts, *targets, *acc, *targ, *l;
3325 TplEventTypeMask event_mask;
3326 EventSubtype subtype;
3327 GDate *date, *anytime, *separator;
3329 if (!log_window_get_selected (self,
3330 &accounts, &targets, NULL, NULL, &event_mask, &subtype))
3333 anytime = g_date_new_dmy (2, 1, -1);
3334 separator = g_date_new_dmy (1, 1, -1);
3336 _tpl_action_chain_clear (self->priv->chain);
3337 self->priv->count++;
3339 for (acc = accounts, targ = targets;
3340 acc != NULL && targ != NULL;
3341 acc = acc->next, targ = targ->next)
3343 TpAccount *account = acc->data;
3344 TplEntity *target = targ->data;
3346 for (l = dates; l != NULL; l = l->next)
3351 if (g_date_compare (date, anytime) != 0)
3355 ctx = ctx_new (self, account, target, date, event_mask, subtype,
3357 _tpl_action_chain_append (self->priv->chain, get_events_for_date, ctx);
3361 GtkTreeView *view = GTK_TREE_VIEW (self->priv->treeview_when);
3362 GtkTreeModel *model = gtk_tree_view_get_model (view);
3367 for (next = gtk_tree_model_get_iter_first (model, &iter);
3369 next = gtk_tree_model_iter_next (model, &iter))
3373 gtk_tree_model_get (model, &iter,
3377 if (g_date_compare (d, anytime) != 0 &&
3378 g_date_compare (d, separator) != 0)
3380 ctx = ctx_new (self, account, target, d,
3381 event_mask, subtype, self->priv->count);
3382 _tpl_action_chain_append (self->priv->chain, get_events_for_date, ctx);
3392 _tpl_action_chain_start (self->priv->chain);
3394 g_list_free_full (accounts, g_object_unref);
3395 g_list_free_full (targets, g_object_unref);
3396 g_date_free (separator);
3397 g_date_free (anytime);
3401 log_manager_got_dates_cb (GObject *manager,
3402 GAsyncResult *result,
3405 Ctx *ctx = user_data;
3407 GtkTreeModel *model;
3408 GtkListStore *store;
3412 GError *error = NULL;
3414 if (log_window == NULL)
3420 if (log_window->priv->count != ctx->count)
3423 if (!tpl_log_manager_get_dates_finish (TPL_LOG_MANAGER (manager),
3424 result, &dates, &error))
3426 DEBUG ("Unable to retrieve messages' dates: %s. Aborting",
3431 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
3432 model = gtk_tree_view_get_model (view);
3433 store = GTK_LIST_STORE (model);
3435 for (l = dates; l != NULL; l = l->next)
3437 GDate *date = l->data;
3439 /* Add the date if it's not already there */
3440 has_element = FALSE;
3441 gtk_tree_model_foreach (model, model_has_date, date);
3444 gchar *text = format_date_for_display (date);
3446 gtk_list_store_append (store, &iter);
3447 gtk_list_store_set (store, &iter,
3448 COL_WHEN_DATE, date,
3449 COL_WHEN_TEXT, text,
3450 COL_WHEN_ICON, CALENDAR_ICON,
3457 if (gtk_tree_model_get_iter_first (model, &iter))
3459 gchar *separator = NULL;
3461 if (gtk_tree_model_iter_next (model, &iter))
3463 gtk_tree_model_get (model, &iter,
3464 COL_WHEN_TEXT, &separator,
3468 if (g_strcmp0 (separator, "separator") != 0)
3472 date = g_date_new_dmy (1, 1, -1);
3474 gtk_list_store_prepend (store, &iter);
3475 gtk_list_store_set (store, &iter,
3476 COL_WHEN_DATE, date,
3477 COL_WHEN_TEXT, "separator",
3482 date = g_date_new_dmy (2, 1, -1);
3484 gtk_list_store_prepend (store, &iter);
3485 gtk_list_store_set (store, &iter,
3486 COL_WHEN_DATE, date,
3487 COL_WHEN_TEXT, _("Anytime"),
3496 g_list_free_full (dates, g_free);
3499 _tpl_action_chain_continue (log_window->priv->chain);
3503 select_date (TplActionChain *chain, gpointer user_data)
3506 GtkTreeModel *model;
3507 GtkTreeSelection *selection;
3510 gboolean selected = FALSE;
3512 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
3513 model = gtk_tree_view_get_model (view);
3514 selection = gtk_tree_view_get_selection (view);
3516 if (log_window->priv->current_dates != NULL)
3518 for (next = gtk_tree_model_get_iter_first (model, &iter);
3520 next = gtk_tree_model_iter_next (model, &iter))
3524 gtk_tree_model_get (model, &iter,
3525 COL_WHEN_DATE, &date,
3528 if (g_list_find_custom (log_window->priv->current_dates, date,
3529 (GCompareFunc) g_date_compare) != NULL)
3533 gtk_tree_selection_select_iter (selection, &iter);
3534 path = gtk_tree_model_get_path (model, &iter);
3535 gtk_tree_view_scroll_to_cell (view, path, NULL, FALSE, 0, 0);
3538 gtk_tree_path_free (path);
3547 /* Show messages of the most recent date */
3548 if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 2))
3549 gtk_tree_selection_select_iter (selection, &iter);
3552 _tpl_action_chain_continue (log_window->priv->chain);
3556 get_dates_for_entity (TplActionChain *chain, gpointer user_data)
3558 Ctx *ctx = user_data;
3560 tpl_log_manager_get_dates_async (ctx->self->priv->log_manager,
3561 ctx->account, ctx->entity, ctx->event_mask,
3562 log_manager_got_dates_cb, ctx);
3566 log_window_chats_get_messages (EmpathyLogWindow *self,
3567 gboolean force_get_dates)
3569 GList *accounts, *targets, *dates;
3570 TplEventTypeMask event_mask;
3572 GtkTreeModel *model;
3573 GtkListStore *store;
3574 GtkTreeSelection *selection;
3576 if (!log_window_get_selected (self, &accounts, &targets, NULL,
3577 &dates, &event_mask, NULL))
3580 view = GTK_TREE_VIEW (self->priv->treeview_when);
3581 selection = gtk_tree_view_get_selection (view);
3582 model = gtk_tree_view_get_model (view);
3583 store = GTK_LIST_STORE (model);
3585 /* Clear all current messages shown in the textview */
3586 gtk_tree_store_clear (self->priv->store_events);
3588 _tpl_action_chain_clear (self->priv->chain);
3589 self->priv->count++;
3591 /* If there's a search use the returned hits */
3592 if (self->priv->hits != NULL)
3594 if (force_get_dates)
3596 g_signal_handlers_block_by_func (selection,
3597 log_window_when_changed_cb,
3600 gtk_list_store_clear (store);
3602 g_signal_handlers_unblock_by_func (selection,
3603 log_window_when_changed_cb,
3606 populate_dates_from_search_hits (accounts, targets);
3610 populate_events_from_search_hits (accounts, targets, dates);
3613 /* Either use the supplied date or get the last */
3614 else if (force_get_dates || dates == NULL)
3618 if (self->priv->current_dates != NULL)
3620 g_list_free_full (self->priv->current_dates,
3621 (GDestroyNotify) g_date_free);
3622 self->priv->current_dates = NULL;
3625 if (gtk_tree_selection_count_selected_rows (selection) > 0)
3630 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
3632 for (l = paths; l != NULL; l = l->next)
3634 GtkTreePath *path = l->data;
3637 gtk_tree_model_get_iter (model, &iter, path);
3638 gtk_tree_model_get (model, &iter,
3639 COL_WHEN_DATE, &date,
3642 /* The list takes ownership of the date. */
3643 self->priv->current_dates =
3644 g_list_prepend (self->priv->current_dates, date);
3647 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
3650 g_signal_handlers_block_by_func (selection,
3651 log_window_when_changed_cb,
3654 gtk_list_store_clear (store);
3656 g_signal_handlers_unblock_by_func (selection,
3657 log_window_when_changed_cb,
3660 /* Get a list of dates and show them on the treeview */
3661 for (targ = targets, acc = accounts;
3662 targ != NULL && acc != NULL;
3663 targ = targ->next, acc = acc->next)
3665 TpAccount *account = acc->data;
3666 TplEntity *target = targ->data;
3667 Ctx *ctx = ctx_new (self, account, target, NULL, event_mask, 0,
3670 _tpl_action_chain_append (self->priv->chain, get_dates_for_entity, ctx);
3672 _tpl_action_chain_append (self->priv->chain, select_date, NULL);
3673 _tpl_action_chain_start (self->priv->chain);
3677 /* Show messages of the selected date */
3678 log_window_get_messages_for_dates (self, dates);
3681 g_list_free_full (accounts, g_object_unref);
3682 g_list_free_full (targets, g_object_unref);
3683 g_list_free_full (dates, (GFreeFunc) g_date_free);
3687 EmpathyAccountChooserFilterResultCallback callback;
3689 } FilterCallbackData;
3692 got_entities (GObject *manager,
3693 GAsyncResult *result,
3696 FilterCallbackData *data = user_data;
3698 GError *error = NULL;
3700 if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager),
3701 result, &entities, &error))
3703 DEBUG ("Could not get entities: %s", error->message);
3704 g_error_free (error);
3705 data->callback (FALSE, data->user_data);
3709 data->callback (entities != NULL, data->user_data);
3711 g_list_free_full (entities, g_object_unref);
3714 g_slice_free (FilterCallbackData, data);
3718 empathy_account_chooser_filter_has_logs (TpAccount *account,
3719 EmpathyAccountChooserFilterResultCallback callback,
3720 gpointer callback_data,
3723 TplLogManager *manager = tpl_log_manager_dup_singleton ();
3724 FilterCallbackData *cb_data = g_slice_new0 (FilterCallbackData);
3726 cb_data->callback = callback;
3727 cb_data->user_data = callback_data;
3729 tpl_log_manager_get_entities_async (manager, account, got_entities, cb_data);
3731 g_object_unref (manager);
3735 log_window_logger_clear_account_cb (TpProxy *proxy,
3736 const GError *error,
3738 GObject *weak_object)
3740 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (user_data);
3743 g_warning ("Error when clearing logs: %s", error->message);
3745 /* Refresh the log viewer so the logs are cleared if the account
3746 * has been deleted */
3747 gtk_tree_store_clear (self->priv->store_events);
3748 log_window_who_populate (self);
3750 /* Re-filter the account chooser so the accounts without logs get
3752 empathy_account_chooser_refilter (
3753 EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser));
3757 log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem,
3758 EmpathyLogWindow *self)
3760 GtkWidget *dialog, *content_area, *hbox, *label;
3761 EmpathyAccountChooser *account_chooser;
3765 GError *error = NULL;
3767 account_chooser = (EmpathyAccountChooser *) empathy_account_chooser_new ();
3768 empathy_account_chooser_set_has_all_option (account_chooser, TRUE);
3770 empathy_account_chooser_refilter (account_chooser);
3772 /* Select the same account as in the history window */
3773 empathy_account_chooser_set_account (account_chooser,
3774 empathy_account_chooser_get_account (
3775 EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser)));
3777 dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (self),
3778 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING,
3780 _("Are you sure you want to delete all logs of previous conversations?"));
3782 gtk_dialog_add_buttons (GTK_DIALOG (dialog),
3783 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
3784 _("Clear All"), GTK_RESPONSE_APPLY,
3787 content_area = gtk_message_dialog_get_message_area (
3788 GTK_MESSAGE_DIALOG (dialog));
3790 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
3791 label = gtk_label_new (_("Delete from:"));
3792 gtk_box_pack_start (GTK_BOX (hbox), label,
3794 gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (account_chooser),
3796 gtk_box_pack_start (GTK_BOX (content_area), hbox,
3799 gtk_widget_show_all (hbox);
3801 response_id = gtk_dialog_run (GTK_DIALOG (dialog));
3803 if (response_id != GTK_RESPONSE_APPLY)
3806 bus = tp_dbus_daemon_dup (&error);
3809 g_warning ("Could not delete logs: %s", error->message);
3810 g_error_free (error);
3814 logger = g_object_new (TP_TYPE_PROXY,
3815 "bus-name", "org.freedesktop.Telepathy.Logger",
3816 "object-path", "/org/freedesktop/Telepathy/Logger",
3819 g_object_unref (bus);
3821 tp_proxy_add_interface_by_id (logger, EMP_IFACE_QUARK_LOGGER);
3823 if (empathy_account_chooser_has_all_selected (account_chooser))
3825 DEBUG ("Deleting logs for all the accounts");
3827 emp_cli_logger_call_clear (logger, -1,
3828 log_window_logger_clear_account_cb,
3829 self, NULL, G_OBJECT (self));
3835 account = empathy_account_chooser_get_account (account_chooser);
3837 DEBUG ("Deleting logs for %s", tp_proxy_get_object_path (account));
3839 emp_cli_logger_call_clear_account (logger, -1,
3840 tp_proxy_get_object_path (account),
3841 log_window_logger_clear_account_cb,
3842 self, NULL, G_OBJECT (self));
3845 g_object_unref (logger);
3847 gtk_widget_destroy (dialog);