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-yell/telepathy-yell.h>
39 #include <telepathy-logger/telepathy-logger.h>
41 # include <telepathy-logger/call-event.h>
44 #include <extensions/extensions.h>
46 #include <libempathy/action-chain-internal.h>
47 #include <libempathy/empathy-camera-monitor.h>
48 #include <libempathy/empathy-chatroom-manager.h>
49 #include <libempathy/empathy-chatroom.h>
50 #include <libempathy/empathy-gsettings.h>
51 #include <libempathy/empathy-message.h>
52 #include <libempathy/empathy-request-util.h>
53 #include <libempathy/empathy-utils.h>
54 #include <libempathy/empathy-time.h>
56 #include "empathy-log-window.h"
57 #include "empathy-account-chooser.h"
58 #include "empathy-call-utils.h"
59 #include "empathy-chat-view.h"
60 #include "empathy-contact-dialogs.h"
61 #include "empathy-images.h"
62 #include "empathy-theme-manager.h"
63 #include "empathy-ui-utils.h"
64 #include "empathy-webkit-utils.h"
66 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
67 #include <libempathy/empathy-debug.h>
69 #define EMPATHY_NS "http://live.gnome.org/Empathy"
71 G_DEFINE_TYPE (EmpathyLogWindow, empathy_log_window, GTK_TYPE_WINDOW);
73 struct _EmpathyLogWindowPriv
77 GtkWidget *button_profile;
78 GtkWidget *button_chat;
79 GtkWidget *button_call;
80 GtkWidget *button_video;
82 GtkWidget *search_entry;
87 GtkWidget *treeview_who;
88 GtkWidget *treeview_what;
89 GtkWidget *treeview_when;
92 GtkTreeStore *store_events;
94 GtkWidget *account_chooser;
98 /* List of selected GDates, free with g_list_free_full (l, g_date_free) */
101 TplActionChain *chain;
102 TplLogManager *log_manager;
104 /* Hash of TpChannel<->TpAccount for use by the observer until we can
105 * get a TpAccount from a TpConnection or wherever */
106 GHashTable *channels;
107 TpBaseClient *observer;
109 EmpathyContact *selected_contact;
110 EmpathyContact *events_contact;
112 EmpathyCameraMonitor *camera_monitor;
113 GBinding *button_video_binding;
115 /* Used to cancel logger calls when no longer needed */
118 /* List of owned TplLogSearchHits, free with tpl_log_search_hit_free */
122 /* Only used while waiting for the account chooser to be ready */
123 TpAccount *selected_account;
124 gchar *selected_chat_id;
125 gboolean selected_is_chatroom;
127 GSettings *gsettings_chat;
128 GSettings *gsettings_desktop;
131 static void log_window_search_entry_changed_cb (GtkWidget *entry,
132 EmpathyLogWindow *self);
133 static void log_window_search_entry_activate_cb (GtkWidget *widget,
134 EmpathyLogWindow *self);
135 static void log_window_search_entry_icon_pressed_cb (GtkEntry *entry,
136 GtkEntryIconPosition icon_pos,
139 static void log_window_who_populate (EmpathyLogWindow *self);
140 static void log_window_who_setup (EmpathyLogWindow *self);
141 static void log_window_when_setup (EmpathyLogWindow *self);
142 static void log_window_what_setup (EmpathyLogWindow *self);
143 static void log_window_events_setup (EmpathyLogWindow *self);
144 static void log_window_chats_accounts_changed_cb (GtkWidget *combobox,
145 EmpathyLogWindow *self);
146 static void log_window_chats_set_selected (EmpathyLogWindow *self);
147 static void log_window_chats_get_messages (EmpathyLogWindow *self,
148 gboolean force_get_dates);
149 static void log_window_when_changed_cb (GtkTreeSelection *selection,
150 EmpathyLogWindow *self);
151 static void log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem,
152 EmpathyLogWindow *self);
153 static void start_spinner (void);
155 static void log_window_create_observer (EmpathyLogWindow *window);
156 static gboolean log_window_events_button_press_event (GtkWidget *webview,
157 GdkEventButton *event, EmpathyLogWindow *self);
158 static void log_window_update_buttons_sensitivity (EmpathyLogWindow *self);
161 empathy_account_chooser_filter_has_logs (TpAccount *account,
162 EmpathyAccountChooserFilterResultCallback callback,
163 gpointer callback_data,
185 COL_WHO_NAME_SORT_KEY,
214 COL_EVENTS_PRETTY_DATE,
223 #define CALENDAR_ICON "stock_calendar"
225 /* Seconds between two messages to be considered one conversation */
226 #define MAX_GAP 30*60
228 #define WHAT_TYPE_SEPARATOR -1
232 EVENT_CALL_INCOMING = 1 << 0,
233 EVENT_CALL_OUTGOING = 1 << 1,
234 EVENT_CALL_MISSED = 1 << 2,
235 EVENT_CALL_ALL = 1 << 3,
239 log_window_get_selected (EmpathyLogWindow *window,
244 TplEventTypeMask *event_mask,
245 EventSubtype *subtype);
247 static EmpathyLogWindow *log_window = NULL;
249 static gboolean has_element;
252 #define _date_copy(d) g_date_new_julian (g_date_get_julian (d))
257 EmpathyLogWindow *self;
261 TplEventTypeMask event_mask;
262 EventSubtype subtype;
267 ctx_new (EmpathyLogWindow *self,
271 TplEventTypeMask event_mask,
272 EventSubtype subtype,
275 Ctx *ctx = g_slice_new0 (Ctx);
279 ctx->account = g_object_ref (account);
281 ctx->entity = g_object_ref (entity);
283 ctx->date = _date_copy (date);
284 ctx->event_mask = event_mask;
285 ctx->subtype = subtype;
294 tp_clear_object (&ctx->account);
295 tp_clear_object (&ctx->entity);
296 tp_clear_pointer (&ctx->date, g_date_free);
298 g_slice_free (Ctx, ctx);
302 select_account_once_ready (EmpathyLogWindow *self,
304 const gchar *chat_id,
305 gboolean is_chatroom)
307 EmpathyAccountChooser *account_chooser;
309 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
311 tp_clear_object (&self->priv->selected_account);
312 self->priv->selected_account = g_object_ref (account);
314 g_free (self->priv->selected_chat_id);
315 self->priv->selected_chat_id = g_strdup (chat_id);
317 self->priv->selected_is_chatroom = is_chatroom;
319 empathy_account_chooser_set_account (account_chooser,
320 self->priv->selected_account);
324 toolbutton_profile_clicked (GtkToolButton *toolbutton,
325 EmpathyLogWindow *self)
327 g_return_if_fail (self != NULL);
328 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
330 empathy_contact_information_dialog_show (self->priv->selected_contact,
335 toolbutton_chat_clicked (GtkToolButton *toolbutton,
336 EmpathyLogWindow *self)
338 g_return_if_fail (self != NULL);
339 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
341 empathy_chat_with_contact (self->priv->selected_contact,
342 gtk_get_current_event_time ());
346 toolbutton_av_clicked (GtkToolButton *toolbutton,
347 EmpathyLogWindow *self)
351 g_return_if_fail (self != NULL);
352 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
354 video = (GTK_WIDGET (toolbutton) == self->priv->button_video);
356 empathy_call_new_with_streams (
357 empathy_contact_get_id (self->priv->selected_contact),
358 empathy_contact_get_account (self->priv->selected_contact),
359 TRUE, video, gtk_get_current_event_time ());
363 insert_or_change_row (EmpathyLogWindow *self,
369 char *str = gtk_tree_path_to_string (path);
370 char *script, *text, *date, *stock_icon;
373 gtk_tree_model_get (model, iter,
374 COL_EVENTS_TEXT, &text,
375 COL_EVENTS_PRETTY_DATE, &date,
376 COL_EVENTS_ICON, &stock_icon,
379 if (!tp_str_empty (stock_icon))
381 GtkIconInfo *icon_info = gtk_icon_theme_lookup_icon (
382 gtk_icon_theme_get_default (),
384 GTK_ICON_SIZE_MENU, 0);
386 if (icon_info != NULL)
387 icon = g_strdup (gtk_icon_info_get_filename (icon_info));
389 gtk_icon_info_free (icon_info);
392 script = g_strdup_printf ("javascript:%s([%s], '%s', '%s', '%s');",
394 g_strdelimit (str, ":", ','),
396 icon != NULL ? icon : "",
399 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
411 store_events_row_inserted (GtkTreeModel *model,
414 EmpathyLogWindow *self)
416 insert_or_change_row (self, "insertRow", model, path, iter);
420 store_events_row_changed (GtkTreeModel *model,
423 EmpathyLogWindow *self)
425 insert_or_change_row (self, "changeRow", model, path, iter);
429 store_events_row_deleted (GtkTreeModel *model,
431 EmpathyLogWindow *self)
433 char *str = gtk_tree_path_to_string (path);
436 script = g_strdup_printf ("javascript:deleteRow([%s]);",
437 g_strdelimit (str, ":", ','));
439 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
447 store_events_has_child_rows (GtkTreeModel *model,
450 EmpathyLogWindow *self)
452 char *str = gtk_tree_path_to_string (path);
455 script = g_strdup_printf ("javascript:hasChildRows([%s], %u);",
456 g_strdelimit (str, ":", ','),
457 gtk_tree_model_iter_has_child (model, iter));
459 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
467 store_events_rows_reordered (GtkTreeModel *model,
471 EmpathyLogWindow *self)
473 char *str = gtk_tree_path_to_string (path);
474 int i, children = gtk_tree_model_iter_n_children (model, iter);
475 char **new_order_strv, *new_order_s;
478 new_order_strv = g_new0 (char *, children + 1);
480 for (i = 0; i < children; i++)
481 new_order_strv[i] = g_strdup_printf ("%i", new_order[i]);
483 new_order_s = g_strjoinv (",", new_order_strv);
485 script = g_strdup_printf ("javascript:reorderRows([%s], [%s]);",
486 str == NULL ? "" : g_strdelimit (str, ":", ','),
489 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
494 g_free (new_order_s);
495 g_strfreev (new_order_strv);
499 events_webview_handle_navigation (WebKitWebView *webview,
500 WebKitWebFrame *frame,
501 WebKitNetworkRequest *request,
502 WebKitWebNavigationAction *navigation_action,
503 WebKitWebPolicyDecision *policy_decision,
504 EmpathyLogWindow *window)
506 empathy_url_show (GTK_WIDGET (webview),
507 webkit_network_request_get_uri (request));
509 webkit_web_policy_decision_ignore (policy_decision);
514 empathy_log_window_constructor (GType type,
516 GObjectConstructParam *props)
520 if (log_window != NULL)
522 retval = (GObject *) log_window;
526 retval = G_OBJECT_CLASS (empathy_log_window_parent_class)
527 ->constructor (type, n_props, props);
529 log_window = EMPATHY_LOG_WINDOW (retval);
530 g_object_add_weak_pointer (retval, (gpointer) &log_window);
537 empathy_log_window_dispose (GObject *object)
539 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (object);
541 if (self->priv->source != 0)
543 g_source_remove (self->priv->source);
544 self->priv->source = 0;
547 if (self->priv->current_dates != NULL)
549 g_list_free_full (self->priv->current_dates,
550 (GDestroyNotify) g_date_free);
551 self->priv->current_dates = NULL;
554 tp_clear_pointer (&self->priv->chain, _tpl_action_chain_free);
555 tp_clear_pointer (&self->priv->channels, g_hash_table_unref);
557 tp_clear_object (&self->priv->observer);
558 tp_clear_object (&self->priv->log_manager);
559 tp_clear_object (&self->priv->selected_account);
560 tp_clear_object (&self->priv->selected_contact);
561 tp_clear_object (&self->priv->events_contact);
562 tp_clear_object (&self->priv->camera_monitor);
564 tp_clear_object (&self->priv->gsettings_chat);
565 tp_clear_object (&self->priv->gsettings_desktop);
567 tp_clear_object (&self->priv->store_events);
569 G_OBJECT_CLASS (empathy_log_window_parent_class)->dispose (object);
573 empathy_log_window_finalize (GObject *object)
575 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (object);
577 g_free (self->priv->last_find);
578 g_free (self->priv->selected_chat_id);
580 G_OBJECT_CLASS (empathy_log_window_parent_class)->finalize (object);
584 empathy_log_window_class_init (
585 EmpathyLogWindowClass *empathy_log_window_class)
587 GObjectClass *object_class = G_OBJECT_CLASS (empathy_log_window_class);
589 g_type_class_add_private (empathy_log_window_class,
590 sizeof (EmpathyLogWindowPriv));
592 object_class->constructor = empathy_log_window_constructor;
593 object_class->dispose = empathy_log_window_dispose;
594 object_class->finalize = empathy_log_window_finalize;
598 empathy_log_window_init (EmpathyLogWindow *self)
600 EmpathyAccountChooser *account_chooser;
604 GtkWidget *vbox, *accounts, *search, *label, *closeitem;
605 GtkWidget *scrolledwindow_events;
608 self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
609 EMPATHY_TYPE_LOG_WINDOW, EmpathyLogWindowPriv);
611 self->priv->chain = _tpl_action_chain_new_async (NULL, NULL, NULL);
613 self->priv->camera_monitor = empathy_camera_monitor_dup_singleton ();
615 self->priv->log_manager = tpl_log_manager_dup_singleton ();
617 self->priv->gsettings_chat = g_settings_new (EMPATHY_PREFS_CHAT_SCHEMA);
618 self->priv->gsettings_desktop = g_settings_new (
619 EMPATHY_PREFS_DESKTOP_INTERFACE_SCHEMA);
621 gtk_window_set_title (GTK_WINDOW (self), _("History"));
622 gtk_widget_set_can_focus (GTK_WIDGET (self), FALSE);
623 gtk_window_set_default_size (GTK_WINDOW (self), 800, 600);
625 filename = empathy_file_lookup ("empathy-log-window.ui", "libempathy-gtk");
626 gui = empathy_builder_get_file (filename,
627 "vbox1", &self->priv->vbox,
628 "toolbutton_profile", &self->priv->button_profile,
629 "toolbutton_chat", &self->priv->button_chat,
630 "toolbutton_call", &self->priv->button_call,
631 "toolbutton_video", &self->priv->button_video,
632 "toolbutton_accounts", &accounts,
633 "toolbutton_search", &search,
634 "imagemenuitem_close", &closeitem,
635 "treeview_who", &self->priv->treeview_who,
636 "treeview_what", &self->priv->treeview_what,
637 "treeview_when", &self->priv->treeview_when,
638 "scrolledwindow_events", &scrolledwindow_events,
639 "notebook", &self->priv->notebook,
640 "spinner", &self->priv->spinner,
644 empathy_builder_connect (gui, self,
645 "toolbutton_profile", "clicked", toolbutton_profile_clicked,
646 "toolbutton_chat", "clicked", toolbutton_chat_clicked,
647 "toolbutton_call", "clicked", toolbutton_av_clicked,
648 "toolbutton_video", "clicked", toolbutton_av_clicked,
649 "imagemenuitem_delete", "activate", log_window_delete_menu_clicked_cb,
652 gtk_container_add (GTK_CONTAINER (self), self->priv->vbox);
654 g_object_unref (gui);
656 g_signal_connect_swapped (closeitem, "activate",
657 G_CALLBACK (gtk_widget_destroy), self);
659 /* Account chooser for chats */
660 vbox = gtk_vbox_new (FALSE, 3);
662 self->priv->account_chooser = empathy_account_chooser_new ();
663 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
664 empathy_account_chooser_set_has_all_option (account_chooser, TRUE);
665 empathy_account_chooser_set_filter (account_chooser,
666 empathy_account_chooser_filter_has_logs, NULL);
667 empathy_account_chooser_set_all (account_chooser);
669 gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->account_chooser),
670 GTK_STYLE_CLASS_RAISED);
672 g_signal_connect (self->priv->account_chooser, "changed",
673 G_CALLBACK (log_window_chats_accounts_changed_cb),
676 label = gtk_label_new (_("Show"));
678 gtk_box_pack_start (GTK_BOX (vbox),
679 self->priv->account_chooser,
682 gtk_box_pack_start (GTK_BOX (vbox),
686 gtk_widget_show_all (vbox);
687 gtk_container_add (GTK_CONTAINER (accounts), vbox);
690 vbox = gtk_vbox_new (FALSE, 3);
692 self->priv->search_entry = gtk_entry_new ();
693 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
694 GTK_ENTRY_ICON_SECONDARY, "edit-find-symbolic");
695 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
696 GTK_ENTRY_ICON_SECONDARY, FALSE);
698 label = gtk_label_new (_("Search"));
700 gtk_box_pack_start (GTK_BOX (vbox),
701 self->priv->search_entry,
704 gtk_box_pack_start (GTK_BOX (vbox),
708 gtk_widget_show_all (vbox);
709 gtk_container_add (GTK_CONTAINER (search), vbox);
711 g_signal_connect (self->priv->search_entry, "changed",
712 G_CALLBACK (log_window_search_entry_changed_cb),
715 g_signal_connect (self->priv->search_entry, "activate",
716 G_CALLBACK (log_window_search_entry_activate_cb),
719 g_signal_connect (self->priv->search_entry, "icon-press",
720 G_CALLBACK (log_window_search_entry_icon_pressed_cb),
724 log_window_events_setup (self);
725 log_window_who_setup (self);
726 log_window_what_setup (self);
727 log_window_when_setup (self);
729 log_window_create_observer (self);
731 log_window_who_populate (self);
734 self->priv->webview = webkit_web_view_new ();
735 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow_events),
736 GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
737 gtk_container_add (GTK_CONTAINER (scrolledwindow_events),
738 self->priv->webview);
739 gtk_widget_show (self->priv->webview);
741 empathy_webkit_bind_font_setting (WEBKIT_WEB_VIEW (self->priv->webview),
742 self->priv->gsettings_desktop,
743 EMPATHY_PREFS_DESKTOP_INTERFACE_FONT_NAME);
745 filename = empathy_file_lookup ("empathy-log-window.html", "data");
746 gfile = g_file_new_for_path (filename);
749 uri = g_file_get_uri (gfile);
750 webkit_web_view_load_uri (WEBKIT_WEB_VIEW (self->priv->webview), uri);
751 g_object_unref (gfile);
754 /* handle all navigation externally */
755 g_signal_connect (self->priv->webview, "navigation-policy-decision-requested",
756 G_CALLBACK (events_webview_handle_navigation), self);
758 /* listen to changes to the treemodel */
759 g_signal_connect (self->priv->store_events, "row-inserted",
760 G_CALLBACK (store_events_row_inserted), self);
761 g_signal_connect (self->priv->store_events, "row-changed",
762 G_CALLBACK (store_events_row_changed), self);
763 g_signal_connect (self->priv->store_events, "row-deleted",
764 G_CALLBACK (store_events_row_deleted), self);
765 g_signal_connect (self->priv->store_events, "rows-reordered",
766 G_CALLBACK (store_events_rows_reordered), self);
767 g_signal_connect (self->priv->store_events, "row-has-child-toggled",
768 G_CALLBACK (store_events_has_child_rows), self);
770 /* track clicked row */
771 g_signal_connect (self->priv->webview, "button-press-event",
772 G_CALLBACK (log_window_events_button_press_event), self);
774 log_window_update_buttons_sensitivity (self);
775 gtk_widget_show (GTK_WIDGET (self));
779 empathy_log_window_show (TpAccount *account,
780 const gchar *chat_id,
781 gboolean is_chatroom,
784 log_window = g_object_new (EMPATHY_TYPE_LOG_WINDOW, NULL);
786 gtk_window_present (GTK_WINDOW (log_window));
788 if (account != NULL && chat_id != NULL)
789 select_account_once_ready (log_window, account, chat_id, is_chatroom);
792 gtk_window_set_transient_for (GTK_WINDOW (log_window),
793 GTK_WINDOW (parent));
795 return GTK_WIDGET (log_window);
799 account_equal (TpAccount *a,
802 return g_str_equal (tp_proxy_get_object_path (a),
803 tp_proxy_get_object_path (b));
807 entity_equal (TplEntity *a,
810 return g_str_equal (tpl_entity_get_identifier (a),
811 tpl_entity_get_identifier (b));
815 is_same_confroom (TplEvent *e1,
818 TplEntity *sender1 = tpl_event_get_sender (e1);
819 TplEntity *receiver1 = tpl_event_get_receiver (e1);
820 TplEntity *sender2 = tpl_event_get_sender (e2);
821 TplEntity *receiver2 = tpl_event_get_receiver (e2);
822 TplEntity *room1, *room2;
824 if (receiver1 == NULL || receiver2 == NULL)
827 if (tpl_entity_get_entity_type (sender1) == TPL_ENTITY_ROOM)
829 else if (tpl_entity_get_entity_type (receiver1) == TPL_ENTITY_ROOM)
834 if (tpl_entity_get_entity_type (sender2) == TPL_ENTITY_ROOM)
836 else if (tpl_entity_get_entity_type (receiver2) == TPL_ENTITY_ROOM)
841 return g_str_equal (tpl_entity_get_identifier (room1),
842 tpl_entity_get_identifier (room2));
846 maybe_refresh_logs (TpChannel *channel,
849 GList *accounts = NULL, *entities = NULL, *dates = NULL;
851 TplEventTypeMask event_mask;
852 GDate *anytime = NULL, *today = NULL;
853 GDateTime *now = NULL;
854 gboolean refresh = FALSE;
858 if (!log_window_get_selected (log_window,
859 &accounts, &entities, &anyone, &dates, &event_mask, NULL))
861 DEBUG ("Could not get selected rows");
865 type = tp_channel_get_channel_type (channel);
867 /* If the channel type is not in the What pane, whatever has happened
868 * won't be displayed in the events pane. */
869 if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_TEXT) &&
870 !(event_mask & TPL_EVENT_MASK_TEXT))
872 if ((!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA) ||
873 !tp_strdiff (type, TPY_IFACE_CHANNEL_TYPE_CALL)) &&
874 !(event_mask & TPL_EVENT_MASK_CALL))
877 anytime = g_date_new_dmy (2, 1, -1);
878 now = g_date_time_new_now_local ();
879 today = g_date_new_dmy (g_date_time_get_day_of_month (now),
880 g_date_time_get_month (now),
881 g_date_time_get_year (now));
883 /* If Today (or anytime) isn't selected, anything that has happened now
884 * won't be displayed. */
885 if (!g_list_find_custom (dates, anytime, (GCompareFunc) g_date_compare) &&
886 !g_list_find_custom (dates, today, (GCompareFunc) g_date_compare))
895 for (acc = accounts, ent = entities;
896 acc != NULL && ent != NULL;
897 acc = g_list_next (acc), ent = g_list_next (ent))
899 if (!account_equal (account, acc->data))
902 if (!tp_strdiff (tp_channel_get_identifier (channel),
903 tpl_entity_get_identifier (ent->data)))
911 tp_clear_pointer (&anytime, g_date_free);
912 tp_clear_pointer (&today, g_date_free);
913 tp_clear_pointer (&now, g_date_time_unref);
914 g_list_free_full (accounts, g_object_unref);
915 g_list_free_full (entities, g_object_unref);
916 g_list_free_full (dates, (GFreeFunc) g_date_free);
920 DEBUG ("Refreshing logs after received event");
922 /* FIXME: We need to populate the entities in case we
923 * didn't have any previous logs with this contact. */
924 log_window_chats_get_messages (log_window, FALSE);
929 on_msg_sent (TpTextChannel *channel,
930 TpSignalledMessage *message,
933 EmpathyLogWindow *self)
935 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
937 maybe_refresh_logs (TP_CHANNEL (channel), account);
941 on_msg_received (TpTextChannel *channel,
942 TpSignalledMessage *message,
943 EmpathyLogWindow *self)
945 TpMessage *msg = TP_MESSAGE (message);
946 TpChannelTextMessageType type = tp_message_get_message_type (msg);
947 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
949 if (type != TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL &&
950 type != TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION)
953 maybe_refresh_logs (TP_CHANNEL (channel), account);
957 on_channel_ended (TpChannel *channel,
961 EmpathyLogWindow *self)
963 if (self->priv->channels != NULL)
964 g_hash_table_remove (self->priv->channels, channel);
968 on_call_ended (TpChannel *channel,
972 EmpathyLogWindow *self)
974 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
976 maybe_refresh_logs (channel, account);
978 if (self->priv->channels != NULL)
979 g_hash_table_remove (self->priv->channels, channel);
983 observe_channels (TpSimpleObserver *observer,
985 TpConnection *connection,
987 TpChannelDispatchOperation *dispatch_operation,
989 TpObserveChannelsContext *context,
992 EmpathyLogWindow *self = user_data;
996 for (l = channels; l != NULL; l = g_list_next (l))
998 TpChannel *channel = l->data;
999 const gchar *type = tp_channel_get_channel_type (channel);
1001 if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_TEXT))
1003 TpTextChannel *text_channel = TP_TEXT_CHANNEL (channel);
1005 g_hash_table_insert (self->priv->channels,
1006 g_object_ref (channel), g_object_ref (account));
1008 tp_g_signal_connect_object (text_channel, "message-sent",
1009 G_CALLBACK (on_msg_sent), self, 0);
1010 tp_g_signal_connect_object (text_channel, "message-received",
1011 G_CALLBACK (on_msg_received), self, 0);
1012 tp_g_signal_connect_object (channel, "invalidated",
1013 G_CALLBACK (on_channel_ended), self, 0);
1015 else if (!tp_strdiff (type, TPY_IFACE_CHANNEL_TYPE_CALL) ||
1016 !tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA))
1018 g_hash_table_insert (self->priv->channels,
1019 g_object_ref (channel), g_object_ref (account));
1021 tp_g_signal_connect_object (channel, "invalidated",
1022 G_CALLBACK (on_call_ended), self, 0);
1026 g_warning ("Unknown channel type: %s", type);
1030 tp_observe_channels_context_accept (context);
1034 log_window_create_observer (EmpathyLogWindow *self)
1036 TpAccountManager *am;
1038 am = tp_account_manager_dup ();
1040 self->priv->observer = tp_simple_observer_new_with_am (am, TRUE, "LogWindow",
1041 TRUE, observe_channels,
1042 g_object_ref (self), g_object_unref);
1044 self->priv->channels = g_hash_table_new_full (g_direct_hash, g_direct_equal,
1045 g_object_unref, g_object_unref);
1047 tp_base_client_take_observer_filter (self->priv->observer,
1049 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1050 TP_IFACE_CHANNEL_TYPE_TEXT,
1052 tp_base_client_take_observer_filter (self->priv->observer,
1054 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1055 TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA,
1057 tp_base_client_take_observer_filter (self->priv->observer,
1059 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1060 TPY_IFACE_CHANNEL_TYPE_CALL,
1063 tp_base_client_register (self->priv->observer, NULL);
1065 g_object_unref (am);
1069 event_get_target (TplEvent *event)
1071 TplEntity *sender = tpl_event_get_sender (event);
1072 TplEntity *receiver = tpl_event_get_receiver (event);
1074 if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
1081 model_is_parent (GtkTreeModel *model,
1085 TplEvent *stored_event;
1088 gboolean found = FALSE;
1091 if (gtk_tree_model_iter_parent (model, &parent, iter))
1094 gtk_tree_model_get (model, iter,
1095 COL_EVENTS_ACCOUNT, &account,
1096 COL_EVENTS_TARGET, &target,
1097 COL_EVENTS_EVENT, &stored_event,
1100 if (G_OBJECT_TYPE (event) == G_OBJECT_TYPE (stored_event) &&
1101 account_equal (account, tpl_event_get_account (event)) &&
1102 (entity_equal (target, event_get_target (event)) ||
1103 is_same_confroom (event, stored_event)))
1108 gtk_tree_model_iter_nth_child (model, &child, iter,
1109 gtk_tree_model_iter_n_children (model, iter) - 1);
1111 gtk_tree_model_get (model, &child,
1112 COL_EVENTS_TS, ×tamp,
1115 if (ABS (tpl_event_get_timestamp (event) - timestamp) < MAX_GAP)
1117 /* The gap is smaller than 30 min */
1122 g_object_unref (stored_event);
1123 g_object_unref (account);
1124 g_object_unref (target);
1130 get_display_string_for_chat_message (EmpathyMessage *message,
1133 EmpathyContact *sender, *receiver, *target;
1134 TplEntity *ent_sender, *ent_receiver;
1135 const gchar *format;
1137 sender = empathy_message_get_sender (message);
1138 receiver = empathy_message_get_receiver (message);
1140 ent_sender = tpl_event_get_sender (event);
1141 ent_receiver = tpl_event_get_receiver (event);
1143 /* If this is a MUC, we want to show "Chat in <room>". */
1144 if (tpl_entity_get_entity_type (ent_sender) == TPL_ENTITY_ROOM ||
1145 (ent_receiver != NULL &&
1146 tpl_entity_get_entity_type (ent_receiver) == TPL_ENTITY_ROOM))
1147 format = _("Chat in %s");
1149 format = _("Chat with %s");
1151 if (tpl_entity_get_entity_type (ent_sender) == TPL_ENTITY_ROOM)
1153 else if (ent_receiver != NULL &&
1154 tpl_entity_get_entity_type (ent_receiver) == TPL_ENTITY_ROOM)
1156 else if (empathy_contact_is_user (sender))
1161 return g_markup_printf_escaped (format, empathy_contact_get_alias (target));
1165 get_parent_iter_for_message (TplEvent *event,
1166 EmpathyMessage *message,
1167 GtkTreeIter *parent)
1169 GtkTreeStore *store;
1170 GtkTreeModel *model;
1172 gboolean parent_found = FALSE;
1175 store = log_window->priv->store_events;
1176 model = GTK_TREE_MODEL (store);
1178 for (next = gtk_tree_model_get_iter_first (model, &iter);
1180 next = gtk_tree_model_iter_next (model, &iter))
1182 if ((parent_found = model_is_parent (model, &iter, event)))
1193 gchar *body, *pretty_date;
1195 date = g_date_time_new_from_unix_local (
1196 tpl_event_get_timestamp (event));
1198 pretty_date = g_date_time_format (date,
1199 C_("A date with the time", "%A, %e %B %Y %X"));
1201 body = get_display_string_for_chat_message (message, event);
1203 gtk_tree_store_append (store, &iter, NULL);
1204 gtk_tree_store_set (store, &iter,
1205 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1206 COL_EVENTS_PRETTY_DATE, pretty_date,
1207 COL_EVENTS_TEXT, body,
1208 COL_EVENTS_ICON, "format-justify-fill",
1209 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1210 COL_EVENTS_TARGET, event_get_target (event),
1211 COL_EVENTS_EVENT, event,
1217 g_free (pretty_date);
1218 g_date_time_unref (date);
1222 static const gchar *
1223 get_icon_for_event (TplEvent *event)
1225 const gchar *icon = NULL;
1227 if (TPL_IS_TEXT_EVENT (event))
1229 TplTextEvent *text = TPL_TEXT_EVENT (event);
1231 if (!tp_str_empty (tpl_text_event_get_supersedes_token (text)))
1232 icon = EMPATHY_IMAGE_EDIT_MESSAGE;
1234 #ifdef HAVE_CALL_LOGS
1235 else if (TPL_IS_CALL_EVENT (event))
1237 TplCallEvent *call = TPL_CALL_EVENT (event);
1238 TplCallEndReason reason = tpl_call_event_get_end_reason (call);
1239 TplEntity *sender = tpl_event_get_sender (event);
1240 TplEntity *receiver = tpl_event_get_receiver (event);
1242 if (reason == TPL_CALL_END_REASON_NO_ANSWER)
1243 icon = EMPATHY_IMAGE_CALL_MISSED;
1244 else if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
1245 icon = EMPATHY_IMAGE_CALL_OUTGOING;
1246 else if (tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF)
1247 icon = EMPATHY_IMAGE_CALL_INCOMING;
1255 log_window_append_chat_message (TplEvent *event,
1256 EmpathyMessage *message)
1258 GtkTreeStore *store = log_window->priv->store_events;
1259 GtkTreeIter iter, parent;
1260 gchar *pretty_date, *alias, *body;
1262 EmpathyStringParser *parsers;
1265 date = g_date_time_new_from_unix_local (
1266 tpl_event_get_timestamp (event));
1268 pretty_date = g_date_time_format (date, "%X");
1270 get_parent_iter_for_message (event, message, &parent);
1272 alias = g_markup_escape_text (
1273 tpl_entity_get_alias (tpl_event_get_sender (event)), -1);
1275 /* escape the text */
1276 parsers = empathy_webkit_get_string_parser (
1277 g_settings_get_boolean (log_window->priv->gsettings_chat,
1278 EMPATHY_PREFS_CHAT_SHOW_SMILEYS));
1279 msg = g_string_new ("");
1281 empathy_string_parser_substr (empathy_message_get_body (message), -1,
1284 if (tpl_text_event_get_message_type (TPL_TEXT_EVENT (event))
1285 == TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION)
1287 /* Translators: this is an emote: '* Danielle waves' */
1288 body = g_strdup_printf (_("<i>* %s %s</i>"), alias, msg->str);
1292 /* Translators: this is a message: 'Danielle: hello'
1293 * The string in bold is the sender's name */
1294 body = g_strdup_printf (_("<b>%s:</b> %s"), alias, msg->str);
1297 gtk_tree_store_append (store, &iter, &parent);
1298 gtk_tree_store_set (store, &iter,
1299 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1300 COL_EVENTS_PRETTY_DATE, pretty_date,
1301 COL_EVENTS_TEXT, body,
1302 COL_EVENTS_ICON, get_icon_for_event (event),
1303 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1304 COL_EVENTS_TARGET, event_get_target (event),
1305 COL_EVENTS_EVENT, event,
1308 g_string_free (msg, TRUE);
1311 g_free (pretty_date);
1312 g_date_time_unref (date);
1315 #ifdef HAVE_CALL_LOGS
1317 log_window_append_call (TplEvent *event,
1318 EmpathyMessage *message)
1320 TplCallEvent *call = TPL_CALL_EVENT (event);
1321 GtkTreeStore *store = log_window->priv->store_events;
1322 GtkTreeIter iter, child;
1323 gchar *pretty_date, *duration, *finished;
1324 GDateTime *started_date, *finished_date;
1327 /* If searching, only add the call if the search string appears anywhere */
1328 if (!EMP_STR_EMPTY (log_window->priv->last_find))
1330 if (strstr (tpl_entity_get_identifier (tpl_event_get_sender (event)),
1331 log_window->priv->last_find) == NULL &&
1332 strstr (tpl_entity_get_identifier (tpl_event_get_receiver (event)),
1333 log_window->priv->last_find) == NULL &&
1334 strstr (tpl_call_event_get_detailed_end_reason (call),
1335 log_window->priv->last_find) == NULL)
1337 DEBUG ("TplCallEvent doesn't match search string, ignoring");
1342 started_date = g_date_time_new_from_unix_local (
1343 tpl_event_get_timestamp (event));
1345 pretty_date = g_date_time_format (started_date,
1346 C_("A date with the time", "%A, %e %B %Y %X"));
1348 gtk_tree_store_append (store, &iter, NULL);
1349 gtk_tree_store_set (store, &iter,
1350 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1351 COL_EVENTS_PRETTY_DATE, pretty_date,
1352 COL_EVENTS_TEXT, empathy_message_get_body (message),
1353 COL_EVENTS_ICON, get_icon_for_event (event),
1354 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1355 COL_EVENTS_TARGET, event_get_target (event),
1356 COL_EVENTS_EVENT, event,
1359 if (tpl_call_event_get_end_reason (call) != TPL_CALL_END_REASON_NO_ANSWER)
1364 span = tpl_call_event_get_duration (TPL_CALL_EVENT (event));
1368 tmp = g_strdup_printf ("%" G_GINT64_FORMAT, span);
1369 duration = g_strdup_printf (
1370 ngettext ("%s second", "%s seconds", span), tmp);
1375 tmp = g_strdup_printf ("%" G_GINT64_FORMAT, span / 60);
1376 duration = g_strdup_printf (
1377 ngettext ("%s minute", "%s minutes", span / 60), tmp);
1381 finished_date = g_date_time_add (started_date, -span);
1382 finished = g_date_time_format (finished_date, "%X");
1383 g_date_time_unref (finished_date);
1385 body = g_strdup_printf (_("Call took %s, ended at %s"),
1386 duration, finished);
1391 gtk_tree_store_append (store, &child, &iter);
1392 gtk_tree_store_set (store, &child,
1393 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1394 COL_EVENTS_TEXT, body,
1395 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1396 COL_EVENTS_TARGET, event_get_target (event),
1397 COL_EVENTS_EVENT, event,
1403 g_free (pretty_date);
1404 g_date_time_unref (started_date);
1409 log_window_append_message (TplEvent *event,
1410 EmpathyMessage *message)
1412 if (TPL_IS_TEXT_EVENT (event))
1413 log_window_append_chat_message (event, message);
1414 #ifdef HAVE_CALL_LOGS
1415 else if (TPL_IS_CALL_EVENT (event))
1416 log_window_append_call (event, message);
1419 DEBUG ("Message type not handled");
1423 add_all_accounts_and_entities (GList **accounts,
1427 GtkTreeModel *model;
1430 view = GTK_TREE_VIEW (log_window->priv->treeview_who);
1431 model = gtk_tree_view_get_model (view);
1433 if (!gtk_tree_model_get_iter_first (model, &iter))
1442 gtk_tree_model_get (model, &iter,
1443 COL_WHO_ACCOUNT, &account,
1444 COL_WHO_TARGET, &entity,
1445 COL_WHO_TYPE, &type,
1448 if (type != COL_TYPE_NORMAL)
1451 if (accounts != NULL)
1452 *accounts = g_list_append (*accounts, account);
1454 if (entities != NULL)
1455 *entities = g_list_append (*entities, entity);
1457 while (gtk_tree_model_iter_next (model, &iter));
1461 log_window_get_selected (EmpathyLogWindow *self,
1466 TplEventTypeMask *event_mask,
1467 EventSubtype *subtype)
1470 GtkTreeModel *model;
1471 GtkTreeSelection *selection;
1473 TplEventTypeMask ev = 0;
1474 EventSubtype st = 0;
1478 view = GTK_TREE_VIEW (self->priv->treeview_who);
1479 model = gtk_tree_view_get_model (view);
1480 selection = gtk_tree_view_get_selection (view);
1482 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1486 if (accounts != NULL)
1488 if (entities != NULL)
1493 for (l = paths; l != NULL; l = l->next)
1495 GtkTreePath *path = l->data;
1499 gtk_tree_model_get_iter (model, &iter, path);
1500 gtk_tree_model_get (model, &iter,
1501 COL_WHO_ACCOUNT, &account,
1502 COL_WHO_TARGET, &entity,
1503 COL_WHO_TYPE, &type,
1506 if (type == COL_TYPE_ANY)
1508 if (accounts != NULL || entities != NULL)
1509 add_all_accounts_and_entities (accounts, entities);
1515 if (accounts != NULL)
1516 *accounts = g_list_append (*accounts, g_object_ref (account));
1518 if (entities != NULL)
1519 *entities = g_list_append (*entities, g_object_ref (entity));
1521 g_object_unref (account);
1522 g_object_unref (entity);
1524 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1526 view = GTK_TREE_VIEW (self->priv->treeview_what);
1527 model = gtk_tree_view_get_model (view);
1528 selection = gtk_tree_view_get_selection (view);
1530 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1531 for (l = paths; l != NULL; l = l->next)
1533 GtkTreePath *path = l->data;
1534 TplEventTypeMask mask;
1535 EventSubtype submask;
1537 gtk_tree_model_get_iter (model, &iter, path);
1538 gtk_tree_model_get (model, &iter,
1539 COL_WHAT_TYPE, &mask,
1540 COL_WHAT_SUBTYPE, &submask,
1546 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1548 view = GTK_TREE_VIEW (self->priv->treeview_when);
1549 model = gtk_tree_view_get_model (view);
1550 selection = gtk_tree_view_get_selection (view);
1556 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1557 for (l = paths; l != NULL; l = l->next)
1559 GtkTreePath *path = l->data;
1562 gtk_tree_model_get_iter (model, &iter, path);
1563 gtk_tree_model_get (model, &iter,
1564 COL_WHEN_DATE, &date,
1567 *dates = g_list_append (*dates, date);
1569 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1572 if (event_mask != NULL)
1575 if (subtype != NULL)
1582 model_has_entity (GtkTreeModel *model,
1587 TplLogSearchHit *hit = data;
1590 gboolean ret = FALSE;
1592 gtk_tree_model_get (model, iter,
1594 COL_WHO_ACCOUNT, &a,
1597 if (e != NULL && entity_equal (hit->target, e) &&
1598 a != NULL && account_equal (hit->account, a))
1600 ret = has_element = TRUE;
1603 tp_clear_object (&e);
1604 tp_clear_object (&a);
1610 model_has_date (GtkTreeModel *model,
1618 gtk_tree_model_get (model, iter,
1622 if (!g_date_compare (date, d))
1634 get_events_for_date (TplActionChain *chain, gpointer user_data);
1637 populate_events_from_search_hits (GList *accounts,
1641 TplEventTypeMask event_mask;
1642 EventSubtype subtype;
1645 gboolean is_anytime = FALSE;
1647 if (!log_window_get_selected (log_window,
1648 NULL, NULL, NULL, NULL, &event_mask, &subtype))
1651 anytime = g_date_new_dmy (2, 1, -1);
1652 if (g_list_find_custom (dates, anytime, (GCompareFunc) g_date_compare))
1655 for (l = log_window->priv->hits; l != NULL; l = l->next)
1657 TplLogSearchHit *hit = l->data;
1659 gboolean found = FALSE;
1661 /* Protect against invalid data (corrupt or old log files). */
1662 if (hit->account == NULL || hit->target == NULL)
1665 for (acc = accounts, targ = targets;
1666 acc != NULL && targ != NULL && !found;
1667 acc = acc->next, targ = targ->next)
1669 TpAccount *account = acc->data;
1670 TplEntity *target = targ->data;
1672 if (account_equal (hit->account, account) &&
1673 entity_equal (hit->target, target))
1681 g_list_find_custom (dates, hit->date, (GCompareFunc) g_date_compare)
1686 ctx = ctx_new (log_window, hit->account, hit->target, hit->date,
1687 event_mask, subtype, log_window->priv->count);
1688 _tpl_action_chain_append (log_window->priv->chain,
1689 get_events_for_date, ctx);
1694 _tpl_action_chain_start (log_window->priv->chain);
1696 g_date_free (anytime);
1700 format_date_for_display (GDate *date)
1706 /* g_date_strftime sucks */
1708 now = g_date_new ();
1709 g_date_set_time_t (now, time (NULL));
1711 days_elapsed = g_date_days_between (date, now);
1713 if (days_elapsed < 0)
1717 else if (days_elapsed == 0)
1719 text = g_strdup (_("Today"));
1721 else if (days_elapsed == 1)
1723 text = g_strdup (_("Yesterday"));
1729 dt = g_date_time_new_utc (g_date_get_year (date),
1730 g_date_get_month (date), g_date_get_day (date),
1733 if (days_elapsed <= 7)
1734 text = g_date_time_format (dt, "%A");
1736 text = g_date_time_format (dt,
1737 /* Translators: A date such as '23 May 2010' (strftime format) */
1740 g_date_time_unref (dt);
1749 populate_dates_from_search_hits (GList *accounts,
1754 GtkTreeModel *model;
1755 GtkListStore *store;
1756 GtkTreeSelection *selection;
1759 if (log_window == NULL)
1762 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
1763 model = gtk_tree_view_get_model (view);
1764 store = GTK_LIST_STORE (model);
1765 selection = gtk_tree_view_get_selection (view);
1767 for (l = log_window->priv->hits; l != NULL; l = l->next)
1769 TplLogSearchHit *hit = l->data;
1771 gboolean found = FALSE;
1773 /* Protect against invalid data (corrupt or old log files). */
1774 if (hit->account == NULL || hit->target == NULL)
1777 for (acc = accounts, targ = targets;
1778 acc != NULL && targ != NULL && !found;
1779 acc = acc->next, targ = targ->next)
1781 TpAccount *account = acc->data;
1782 TplEntity *target = targ->data;
1784 if (account_equal (hit->account, account) &&
1785 entity_equal (hit->target, target))
1792 /* Add the date if it's not already there */
1793 has_element = FALSE;
1794 gtk_tree_model_foreach (model, model_has_date, hit->date);
1797 gchar *text = format_date_for_display (hit->date);
1799 gtk_list_store_append (store, &iter);
1800 gtk_list_store_set (store, &iter,
1801 COL_WHEN_DATE, hit->date,
1802 COL_WHEN_TEXT, text,
1803 COL_WHEN_ICON, CALENDAR_ICON,
1808 if (gtk_tree_model_get_iter_first (model, &iter))
1812 date = g_date_new_dmy (1, 1, -1),
1814 gtk_list_store_prepend (store, &iter);
1815 gtk_list_store_set (store, &iter,
1816 COL_WHEN_DATE, date,
1817 COL_WHEN_TEXT, "separator",
1822 date = g_date_new_dmy (2, 1, -1),
1823 gtk_list_store_prepend (store, &iter);
1824 gtk_list_store_set (store, &iter,
1825 COL_WHEN_DATE, date,
1826 COL_WHEN_TEXT, _("Anytime"),
1831 if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 2))
1832 gtk_tree_selection_select_iter (selection, &iter);
1837 populate_entities_from_search_hits (void)
1839 EmpathyAccountChooser *account_chooser;
1842 GtkTreeModel *model;
1843 GtkTreeSelection *selection;
1845 GtkListStore *store;
1848 view = GTK_TREE_VIEW (log_window->priv->treeview_who);
1849 model = gtk_tree_view_get_model (view);
1850 store = GTK_LIST_STORE (model);
1851 selection = gtk_tree_view_get_selection (view);
1853 gtk_list_store_clear (store);
1855 account_chooser = EMPATHY_ACCOUNT_CHOOSER (log_window->priv->account_chooser);
1856 account = empathy_account_chooser_get_account (account_chooser);
1858 for (l = log_window->priv->hits; l; l = l->next)
1860 TplLogSearchHit *hit = l->data;
1862 /* Protect against invalid data (corrupt or old log files). */
1863 if (hit->account == NULL || hit->target == NULL)
1866 /* Filter based on the selected account */
1867 if (account != NULL && !account_equal (account, hit->account))
1870 /* Add the entity if it's not already there */
1871 has_element = FALSE;
1872 gtk_tree_model_foreach (model, model_has_entity, hit);
1875 TplEntityType type = tpl_entity_get_entity_type (hit->target);
1876 EmpathyContact *contact;
1879 gboolean room = type == TPL_ENTITY_ROOM;
1881 contact = empathy_contact_from_tpl_contact (hit->account,
1884 name = empathy_contact_get_alias (contact);
1885 sort_key = g_utf8_collate_key (name, -1);
1887 gtk_list_store_append (store, &iter);
1888 gtk_list_store_set (store, &iter,
1889 COL_WHO_TYPE, COL_TYPE_NORMAL,
1890 COL_WHO_ICON, room ? EMPATHY_IMAGE_GROUP_MESSAGE
1891 : EMPATHY_IMAGE_AVATAR_DEFAULT,
1893 COL_WHO_NAME_SORT_KEY, sort_key,
1894 COL_WHO_ID, tpl_entity_get_identifier (hit->target),
1895 COL_WHO_ACCOUNT, hit->account,
1896 COL_WHO_TARGET, hit->target,
1900 g_object_unref (contact);
1904 if (gtk_tree_model_get_iter_first (model, &iter))
1906 gtk_list_store_prepend (store, &iter);
1907 gtk_list_store_set (store, &iter,
1908 COL_WHO_TYPE, COL_TYPE_SEPARATOR,
1909 COL_WHO_NAME, "separator",
1912 gtk_list_store_prepend (store, &iter);
1913 gtk_list_store_set (store, &iter,
1914 COL_WHO_TYPE, COL_TYPE_ANY,
1915 COL_WHO_NAME, _("Anyone"),
1919 /* Select 'Anyone' */
1920 if (gtk_tree_model_get_iter_first (model, &iter))
1921 gtk_tree_selection_select_iter (selection, &iter);
1925 log_manager_searched_new_cb (GObject *manager,
1926 GAsyncResult *result,
1931 GtkTreeSelection *selection;
1932 GError *error = NULL;
1934 if (log_window == NULL)
1937 if (!tpl_log_manager_search_finish (TPL_LOG_MANAGER (manager),
1938 result, &hits, &error))
1940 DEBUG ("%s. Aborting", error->message);
1941 g_error_free (error);
1945 tp_clear_pointer (&log_window->priv->hits, tpl_log_manager_search_free);
1946 log_window->priv->hits = hits;
1948 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
1949 selection = gtk_tree_view_get_selection (view);
1951 g_signal_handlers_unblock_by_func (selection,
1952 log_window_when_changed_cb,
1955 populate_entities_from_search_hits ();
1959 log_window_find_populate (EmpathyLogWindow *self,
1960 const gchar *search_criteria)
1963 GtkTreeModel *model;
1964 GtkTreeSelection *selection;
1965 GtkListStore *store;
1967 gtk_tree_store_clear (self->priv->store_events);
1969 view = GTK_TREE_VIEW (self->priv->treeview_who);
1970 model = gtk_tree_view_get_model (view);
1971 store = GTK_LIST_STORE (model);
1973 gtk_list_store_clear (store);
1975 view = GTK_TREE_VIEW (self->priv->treeview_when);
1976 model = gtk_tree_view_get_model (view);
1977 store = GTK_LIST_STORE (model);
1978 selection = gtk_tree_view_get_selection (view);
1980 gtk_list_store_clear (store);
1982 if (EMP_STR_EMPTY (search_criteria))
1984 tp_clear_pointer (&self->priv->hits, tpl_log_manager_search_free);
1985 webkit_web_view_set_highlight_text_matches (
1986 WEBKIT_WEB_VIEW (self->priv->webview), FALSE);
1987 log_window_who_populate (self);
1991 g_signal_handlers_block_by_func (selection,
1992 log_window_when_changed_cb,
1995 /* highlight the search text */
1996 webkit_web_view_mark_text_matches (WEBKIT_WEB_VIEW (self->priv->webview),
1997 search_criteria, FALSE, 0);
1999 tpl_log_manager_search_async (self->priv->log_manager,
2000 search_criteria, TPL_EVENT_MASK_ANY,
2001 log_manager_searched_new_cb, NULL);
2005 start_find_search (EmpathyLogWindow *self)
2009 str = gtk_entry_get_text (GTK_ENTRY (self->priv->search_entry));
2011 /* Don't find the same crap again */
2012 if (self->priv->last_find && !tp_strdiff (self->priv->last_find, str))
2015 g_free (self->priv->last_find);
2016 self->priv->last_find = g_strdup (str);
2018 log_window_find_populate (self, str);
2024 log_window_search_entry_changed_cb (GtkWidget *entry,
2025 EmpathyLogWindow *self)
2029 str = gtk_entry_get_text (GTK_ENTRY (self->priv->search_entry));
2031 if (!tp_str_empty (str))
2033 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
2034 GTK_ENTRY_ICON_SECONDARY, "edit-clear-symbolic");
2035 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
2036 GTK_ENTRY_ICON_SECONDARY, TRUE);
2040 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
2041 GTK_ENTRY_ICON_SECONDARY, "edit-find-symbolic");
2042 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
2043 GTK_ENTRY_ICON_SECONDARY, FALSE);
2046 if (self->priv->source != 0)
2047 g_source_remove (self->priv->source);
2048 self->priv->source = g_timeout_add (500, (GSourceFunc) start_find_search,
2053 log_window_search_entry_activate_cb (GtkWidget *entry,
2054 EmpathyLogWindow *self)
2056 start_find_search (self);
2060 log_window_search_entry_icon_pressed_cb (GtkEntry *entry,
2061 GtkEntryIconPosition icon_pos,
2065 if (icon_pos != GTK_ENTRY_ICON_SECONDARY)
2068 gtk_entry_buffer_set_text (gtk_entry_get_buffer (entry),
2073 log_window_update_buttons_sensitivity (EmpathyLogWindow *self)
2076 GtkTreeModel *model;
2077 GtkTreeSelection *selection;
2078 EmpathyCapabilities capabilities;
2084 gboolean profile, chat, call, video;
2086 profile = chat = call = video = FALSE;
2088 tp_clear_object (&self->priv->button_video_binding);
2089 tp_clear_object (&self->priv->selected_contact);
2091 view = GTK_TREE_VIEW (self->priv->treeview_who);
2092 model = gtk_tree_view_get_model (view);
2093 selection = gtk_tree_view_get_selection (view);
2095 profile = chat = call = video = FALSE;
2097 if (!gtk_tree_model_get_iter_first (model, &iter))
2100 if (gtk_tree_selection_count_selected_rows (selection) != 1)
2103 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2106 paths = gtk_tree_selection_get_selected_rows (selection, &model);
2107 g_return_if_fail (paths != NULL);
2110 gtk_tree_model_get_iter (model, &iter, path);
2111 gtk_tree_model_get (model, &iter,
2112 COL_WHO_ACCOUNT, &account,
2113 COL_WHO_TARGET, &target,
2116 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
2118 self->priv->selected_contact = empathy_contact_from_tpl_contact (account,
2121 g_object_unref (account);
2122 g_object_unref (target);
2124 capabilities = empathy_contact_get_capabilities (self->priv->selected_contact);
2126 profile = chat = TRUE;
2127 call = capabilities & EMPATHY_CAPABILITIES_AUDIO;
2128 video = capabilities & EMPATHY_CAPABILITIES_VIDEO;
2133 /* If the Who pane doesn't contain a contact (e.g. it has many
2134 * selected, or has 'Anyone', let's try to get the contact from
2135 * the selected event. */
2137 if (self->priv->events_contact != NULL)
2138 self->priv->selected_contact = g_object_ref (self->priv->events_contact);
2142 capabilities = empathy_contact_get_capabilities (self->priv->selected_contact);
2144 profile = chat = TRUE;
2145 call = capabilities & EMPATHY_CAPABILITIES_AUDIO;
2146 video = capabilities & EMPATHY_CAPABILITIES_VIDEO;
2149 self->priv->button_video_binding = g_object_bind_property (
2150 self->priv->camera_monitor, "available",
2151 self->priv->button_video, "sensitive",
2152 G_BINDING_SYNC_CREATE);
2155 gtk_widget_set_sensitive (self->priv->button_profile, profile);
2156 gtk_widget_set_sensitive (self->priv->button_chat, chat);
2157 gtk_widget_set_sensitive (self->priv->button_call, call);
2159 /* Don't override the binding */
2161 gtk_widget_set_sensitive (self->priv->button_video, video);
2165 log_window_update_what_iter_sensitivity (GtkTreeModel *model,
2169 GtkTreeStore *store = GTK_TREE_STORE (model);
2173 gtk_tree_store_set (store, iter,
2174 COL_WHAT_SENSITIVE, sensitive,
2177 for (next = gtk_tree_model_iter_children (model, &child, iter);
2179 next = gtk_tree_model_iter_next (model, &child))
2181 gtk_tree_store_set (store, &child,
2182 COL_WHAT_SENSITIVE, sensitive,
2188 log_window_update_what_sensitivity (EmpathyLogWindow *self)
2191 GtkTreeModel *model;
2193 GList *accounts, *targets, *acc, *targ;
2196 if (!log_window_get_selected (self, &accounts, &targets, NULL, NULL,
2200 view = GTK_TREE_VIEW (self->priv->treeview_what);
2201 model = gtk_tree_view_get_model (view);
2203 /* For each event type... */
2204 for (next = gtk_tree_model_get_iter_first (model, &iter);
2206 next = gtk_tree_model_iter_next (model, &iter))
2208 TplEventTypeMask type;
2210 gtk_tree_model_get (model, &iter,
2211 COL_WHAT_TYPE, &type,
2214 /* ...we set the type and its subtypes (if any) unsensitive... */
2215 log_window_update_what_iter_sensitivity (model, &iter, FALSE);
2217 for (acc = accounts, targ = targets;
2218 acc != NULL && targ != NULL;
2219 acc = acc->next, targ = targ->next)
2221 TpAccount *account = acc->data;
2222 TplEntity *target = targ->data;
2224 if (tpl_log_manager_exists (self->priv->log_manager,
2225 account, target, type))
2227 /* And then we set it (and its subtypes, again, if any)
2228 * as sensitive if there are logs of that type. */
2229 log_window_update_what_iter_sensitivity (model, &iter, TRUE);
2235 g_list_free_full (accounts, g_object_unref);
2236 g_list_free_full (targets, g_object_unref);
2240 log_window_who_changed_cb (GtkTreeSelection *selection,
2241 EmpathyLogWindow *self)
2244 GtkTreeModel *model;
2247 DEBUG ("log_window_who_changed_cb");
2249 view = gtk_tree_selection_get_tree_view (selection);
2250 model = gtk_tree_view_get_model (view);
2252 if (gtk_tree_model_get_iter_first (model, &iter))
2254 /* If 'Anyone' is selected, everything else should be deselected */
2255 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2257 g_signal_handlers_block_by_func (selection,
2258 log_window_who_changed_cb,
2261 gtk_tree_selection_unselect_all (selection);
2262 gtk_tree_selection_select_iter (selection, &iter);
2264 g_signal_handlers_unblock_by_func (selection,
2265 log_window_who_changed_cb,
2270 log_window_update_what_sensitivity (self);
2271 log_window_update_buttons_sensitivity (self);
2273 /* The contact changed, so the dates need to be updated */
2274 log_window_chats_get_messages (self, TRUE);
2278 log_manager_got_entities_cb (GObject *manager,
2279 GAsyncResult *result,
2282 Ctx *ctx = user_data;
2286 GtkTreeModel *model;
2287 GtkTreeSelection *selection;
2288 GtkListStore *store;
2290 GError *error = NULL;
2291 gboolean select_account = FALSE;
2293 if (log_window == NULL)
2296 if (log_window->priv->count != ctx->count)
2299 if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager),
2300 result, &entities, &error))
2302 DEBUG ("%s. Aborting", error->message);
2303 g_error_free (error);
2307 view = GTK_TREE_VIEW (ctx->self->priv->treeview_who);
2308 model = gtk_tree_view_get_model (view);
2309 selection = gtk_tree_view_get_selection (view);
2310 store = GTK_LIST_STORE (model);
2312 /* Block signals to stop the logs being retrieved prematurely */
2313 g_signal_handlers_block_by_func (selection,
2314 log_window_who_changed_cb, ctx->self);
2316 for (l = entities; l; l = l->next)
2318 TplEntity *entity = TPL_ENTITY (l->data);
2319 TplEntityType type = tpl_entity_get_entity_type (entity);
2320 EmpathyContact *contact;
2323 gboolean room = type == TPL_ENTITY_ROOM;
2325 contact = empathy_contact_from_tpl_contact (ctx->account, entity);
2327 name = empathy_contact_get_alias (contact);
2328 sort_key = g_utf8_collate_key (name, -1);
2330 gtk_list_store_append (store, &iter);
2331 gtk_list_store_set (store, &iter,
2332 COL_WHO_TYPE, COL_TYPE_NORMAL,
2333 COL_WHO_ICON, room ? EMPATHY_IMAGE_GROUP_MESSAGE
2334 : EMPATHY_IMAGE_AVATAR_DEFAULT,
2336 COL_WHO_NAME_SORT_KEY, sort_key,
2337 COL_WHO_ID, tpl_entity_get_identifier (entity),
2338 COL_WHO_ACCOUNT, ctx->account,
2339 COL_WHO_TARGET, entity,
2343 g_object_unref (contact);
2345 if (ctx->self->priv->selected_account != NULL &&
2346 !tp_strdiff (tp_proxy_get_object_path (ctx->account),
2347 tp_proxy_get_object_path (ctx->self->priv->selected_account)))
2348 select_account = TRUE;
2350 g_list_free_full (entities, g_object_unref);
2352 if (gtk_tree_model_get_iter_first (model, &iter))
2356 gtk_tree_model_get (model, &iter,
2357 COL_WHO_TYPE, &type,
2360 if (type != COL_TYPE_ANY)
2362 gtk_list_store_prepend (store, &iter);
2363 gtk_list_store_set (store, &iter,
2364 COL_WHO_TYPE, COL_TYPE_SEPARATOR,
2365 COL_WHO_NAME, "separator",
2368 gtk_list_store_prepend (store, &iter);
2369 gtk_list_store_set (store, &iter,
2370 COL_WHO_TYPE, COL_TYPE_ANY,
2371 COL_WHO_NAME, _("Anyone"),
2376 /* Unblock signals */
2377 g_signal_handlers_unblock_by_func (selection,
2378 log_window_who_changed_cb,
2381 /* We display the selected account if we populate the model with chats from
2384 log_window_chats_set_selected (ctx->self);
2387 _tpl_action_chain_continue (log_window->priv->chain);
2392 get_entities_for_account (TplActionChain *chain, gpointer user_data)
2394 Ctx *ctx = user_data;
2396 tpl_log_manager_get_entities_async (ctx->self->priv->log_manager, ctx->account,
2397 log_manager_got_entities_cb, ctx);
2401 select_first_entity (TplActionChain *chain, gpointer user_data)
2403 EmpathyLogWindow *self = user_data;
2405 GtkTreeModel *model;
2406 GtkTreeSelection *selection;
2409 view = GTK_TREE_VIEW (self->priv->treeview_who);
2410 model = gtk_tree_view_get_model (view);
2411 selection = gtk_tree_view_get_selection (view);
2413 if (gtk_tree_model_get_iter_first (model, &iter))
2414 gtk_tree_selection_select_iter (selection, &iter);
2416 _tpl_action_chain_continue (self->priv->chain);
2420 log_window_who_populate (EmpathyLogWindow *self)
2422 EmpathyAccountChooser *account_chooser;
2424 gboolean all_accounts;
2426 GtkTreeModel *model;
2427 GtkTreeSelection *selection;
2428 GtkListStore *store;
2431 if (self->priv->hits != NULL)
2433 populate_entities_from_search_hits ();
2437 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
2438 account = empathy_account_chooser_dup_account (account_chooser);
2439 all_accounts = empathy_account_chooser_has_all_selected (account_chooser);
2441 view = GTK_TREE_VIEW (self->priv->treeview_who);
2442 model = gtk_tree_view_get_model (view);
2443 selection = gtk_tree_view_get_selection (view);
2444 store = GTK_LIST_STORE (model);
2446 /* Block signals to stop the logs being retrieved prematurely */
2447 g_signal_handlers_block_by_func (selection,
2448 log_window_who_changed_cb,
2451 gtk_list_store_clear (store);
2453 /* Unblock signals */
2454 g_signal_handlers_unblock_by_func (selection,
2455 log_window_who_changed_cb,
2458 _tpl_action_chain_clear (self->priv->chain);
2459 self->priv->count++;
2461 if (!all_accounts && account == NULL)
2465 else if (!all_accounts)
2467 ctx = ctx_new (self, account, NULL, NULL, 0, 0, self->priv->count);
2468 _tpl_action_chain_append (self->priv->chain, get_entities_for_account, ctx);
2472 TpAccountManager *manager;
2473 GList *accounts, *l;
2475 manager = empathy_account_chooser_get_account_manager (account_chooser);
2476 accounts = tp_account_manager_get_valid_accounts (manager);
2478 for (l = accounts; l != NULL; l = l->next)
2482 ctx = ctx_new (self, account, NULL, NULL, 0, 0, self->priv->count);
2483 _tpl_action_chain_append (self->priv->chain,
2484 get_entities_for_account, ctx);
2487 g_list_free (accounts);
2489 _tpl_action_chain_append (self->priv->chain, select_first_entity, self);
2490 _tpl_action_chain_start (self->priv->chain);
2494 sort_by_name_key (GtkTreeModel *model,
2503 gtk_tree_model_get (model, a,
2504 COL_WHO_TYPE, &type1,
2505 COL_WHO_NAME_SORT_KEY, &key1,
2508 gtk_tree_model_get (model, b,
2509 COL_WHO_TYPE, &type2,
2510 COL_WHO_NAME_SORT_KEY, &key2,
2513 if (type1 == COL_TYPE_ANY)
2515 else if (type2 == COL_TYPE_ANY)
2517 else if (type1 == COL_TYPE_SEPARATOR)
2519 else if (type2 == COL_TYPE_SEPARATOR)
2522 ret = g_strcmp0 (key1, key2);
2531 who_row_is_separator (GtkTreeModel *model,
2537 gtk_tree_model_get (model, iter,
2538 COL_WHO_TYPE, &type,
2541 return (type == COL_TYPE_SEPARATOR);
2545 log_window_find_row (EmpathyLogWindow *self,
2546 GdkEventButton *event)
2548 WebKitHitTestResult *hit = webkit_web_view_get_hit_test_result (
2549 WEBKIT_WEB_VIEW (self->priv->webview), event);
2550 WebKitDOMNode *inner_node;
2552 tp_clear_object (&self->priv->events_contact);
2555 "inner-node", &inner_node,
2558 if (inner_node != NULL)
2560 GtkTreeModel *model = GTK_TREE_MODEL (self->priv->store_events);
2561 WebKitDOMNode *node;
2562 const char *path = NULL;
2565 /* walk back up the DOM tree looking for a node with empathy:path set */
2566 for (node = inner_node; node != NULL;
2567 node = webkit_dom_node_get_parent_node (node))
2569 if (!WEBKIT_DOM_IS_ELEMENT (node))
2572 path = webkit_dom_element_get_attribute_ns (
2573 WEBKIT_DOM_ELEMENT (node), EMPATHY_NS, "path");
2575 if (!tp_str_empty (path))
2579 /* look up the contact for this path */
2580 if (!tp_str_empty (path) &&
2581 gtk_tree_model_get_iter_from_string (model, &iter, path))
2586 gtk_tree_model_get (model, &iter,
2587 COL_EVENTS_ACCOUNT, &account,
2588 COL_EVENTS_TARGET, &target,
2591 self->priv->events_contact = empathy_contact_from_tpl_contact (
2594 g_object_unref (account);
2595 g_object_unref (target);
2598 g_object_unref (inner_node);
2601 g_object_unref (hit);
2603 log_window_update_buttons_sensitivity (self);
2607 log_window_events_button_press_event (GtkWidget *webview,
2608 GdkEventButton *event,
2609 EmpathyLogWindow *self)
2611 switch (event->button)
2614 log_window_find_row (self, event);
2618 empathy_webkit_context_menu_for_event (
2619 WEBKIT_WEB_VIEW (webview), event, 0);
2630 log_window_events_setup (EmpathyLogWindow *self)
2632 GtkTreeSortable *sortable;
2633 GtkTreeStore *store;
2636 self->priv->store_events = store = gtk_tree_store_new (COL_EVENTS_COUNT,
2637 G_TYPE_INT, /* type */
2638 G_TYPE_INT64, /* timestamp */
2639 G_TYPE_STRING, /* stringified date */
2640 G_TYPE_STRING, /* icon */
2641 G_TYPE_STRING, /* name */
2642 TP_TYPE_ACCOUNT, /* account */
2643 TPL_TYPE_ENTITY, /* target */
2644 TPL_TYPE_EVENT); /* event */
2646 sortable = GTK_TREE_SORTABLE (store);
2648 gtk_tree_sortable_set_sort_column_id (sortable,
2650 GTK_SORT_ASCENDING);
2654 log_window_who_setup (EmpathyLogWindow *self)
2657 GtkTreeModel *model;
2658 GtkTreeSelection *selection;
2659 GtkTreeSortable *sortable;
2660 GtkTreeViewColumn *column;
2661 GtkListStore *store;
2662 GtkCellRenderer *cell;
2664 view = GTK_TREE_VIEW (self->priv->treeview_who);
2665 selection = gtk_tree_view_get_selection (view);
2668 store = gtk_list_store_new (COL_WHO_COUNT,
2669 G_TYPE_INT, /* type */
2670 G_TYPE_STRING, /* icon */
2671 G_TYPE_STRING, /* name */
2672 G_TYPE_STRING, /* name sort key */
2673 G_TYPE_STRING, /* id */
2674 TP_TYPE_ACCOUNT, /* account */
2675 TPL_TYPE_ENTITY); /* target */
2677 model = GTK_TREE_MODEL (store);
2678 sortable = GTK_TREE_SORTABLE (store);
2680 gtk_tree_view_set_model (view, model);
2683 column = gtk_tree_view_column_new ();
2684 gtk_tree_view_column_set_title (column, _("Who"));
2686 cell = gtk_cell_renderer_pixbuf_new ();
2687 gtk_tree_view_column_pack_start (column, cell, FALSE);
2688 gtk_tree_view_column_add_attribute (column, cell,
2692 cell = gtk_cell_renderer_text_new ();
2693 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2694 gtk_tree_view_column_pack_start (column, cell, TRUE);
2695 gtk_tree_view_column_add_attribute (column, cell,
2699 gtk_tree_view_append_column (view, column);
2701 /* set up treeview properties */
2702 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
2703 gtk_tree_view_set_row_separator_func (view, who_row_is_separator,
2706 gtk_tree_sortable_set_sort_column_id (sortable,
2707 COL_WHO_NAME_SORT_KEY,
2708 GTK_SORT_ASCENDING);
2709 gtk_tree_sortable_set_sort_func (sortable,
2710 COL_WHO_NAME_SORT_KEY, sort_by_name_key,
2713 gtk_tree_view_set_search_column (view, COL_WHO_NAME);
2714 gtk_tree_view_set_tooltip_column (view, COL_WHO_ID);
2716 /* set up signals */
2717 g_signal_connect (selection, "changed",
2718 G_CALLBACK (log_window_who_changed_cb), self);
2720 g_object_unref (store);
2724 log_window_chats_accounts_changed_cb (GtkWidget *combobox,
2725 EmpathyLogWindow *self)
2727 /* Clear all current messages shown in the textview */
2728 gtk_tree_store_clear (self->priv->store_events);
2730 log_window_who_populate (self);
2734 log_window_chats_set_selected (EmpathyLogWindow *self)
2737 GtkTreeModel *model;
2738 GtkTreeSelection *selection;
2743 view = GTK_TREE_VIEW (self->priv->treeview_who);
2744 model = gtk_tree_view_get_model (view);
2745 selection = gtk_tree_view_get_selection (view);
2747 for (next = gtk_tree_model_get_iter_first (model, &iter);
2749 next = gtk_tree_model_iter_next (model, &iter))
2751 TpAccount *this_account;
2752 TplEntity *this_target;
2753 const gchar *this_chat_id;
2754 gboolean this_is_chatroom;
2757 gtk_tree_model_get (model, &iter,
2758 COL_WHO_TYPE, &this_type,
2759 COL_WHO_ACCOUNT, &this_account,
2760 COL_WHO_TARGET, &this_target,
2763 if (this_type != COL_TYPE_NORMAL)
2766 this_chat_id = tpl_entity_get_identifier (this_target);
2767 this_is_chatroom = tpl_entity_get_entity_type (this_target)
2770 if (this_account == self->priv->selected_account &&
2771 !tp_strdiff (this_chat_id, self->priv->selected_chat_id) &&
2772 this_is_chatroom == self->priv->selected_is_chatroom)
2774 gtk_tree_selection_select_iter (selection, &iter);
2775 path = gtk_tree_model_get_path (model, &iter);
2776 gtk_tree_view_scroll_to_cell (view, path, NULL, TRUE, 0.5, 0.0);
2777 gtk_tree_path_free (path);
2778 g_object_unref (this_account);
2779 g_object_unref (this_target);
2783 g_object_unref (this_account);
2784 g_object_unref (this_target);
2787 tp_clear_object (&self->priv->selected_account);
2788 tp_clear_pointer (&self->priv->selected_chat_id, g_free);
2792 sort_by_date (GtkTreeModel *model,
2797 GDate *date1, *date2;
2800 gtk_tree_model_get (model, a,
2801 COL_WHEN_DATE, &date1,
2804 gtk_tree_model_get (model, b,
2805 COL_WHEN_DATE, &date2,
2808 result = g_date_compare (date1, date2);
2810 g_date_free (date1);
2811 g_date_free (date2);
2816 when_row_is_separator (GtkTreeModel *model,
2823 gtk_tree_model_get (model, iter,
2824 COL_WHEN_TEXT, &when,
2827 ret = !tp_strdiff (when, "separator");
2833 log_window_when_changed_cb (GtkTreeSelection *selection,
2834 EmpathyLogWindow *self)
2837 GtkTreeModel *model;
2840 DEBUG ("log_window_when_changed_cb");
2842 view = gtk_tree_selection_get_tree_view (selection);
2843 model = gtk_tree_view_get_model (view);
2845 /* If 'Anytime' is selected, everything else should be deselected */
2846 if (gtk_tree_model_get_iter_first (model, &iter))
2848 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2850 g_signal_handlers_block_by_func (selection,
2851 log_window_when_changed_cb,
2854 gtk_tree_selection_unselect_all (selection);
2855 gtk_tree_selection_select_iter (selection, &iter);
2857 g_signal_handlers_unblock_by_func (selection,
2858 log_window_when_changed_cb,
2863 log_window_chats_get_messages (self, FALSE);
2867 log_window_when_setup (EmpathyLogWindow *self)
2870 GtkTreeModel *model;
2871 GtkTreeSelection *selection;
2872 GtkTreeSortable *sortable;
2873 GtkTreeViewColumn *column;
2874 GtkListStore *store;
2875 GtkCellRenderer *cell;
2877 view = GTK_TREE_VIEW (self->priv->treeview_when);
2878 selection = gtk_tree_view_get_selection (view);
2881 store = gtk_list_store_new (COL_WHEN_COUNT,
2882 G_TYPE_DATE, /* date */
2883 G_TYPE_STRING, /* stringified date */
2884 G_TYPE_STRING); /* icon */
2886 model = GTK_TREE_MODEL (store);
2887 sortable = GTK_TREE_SORTABLE (store);
2889 gtk_tree_view_set_model (view, model);
2892 column = gtk_tree_view_column_new ();
2893 gtk_tree_view_column_set_title (column, _("When"));
2895 cell = gtk_cell_renderer_pixbuf_new ();
2896 gtk_tree_view_column_pack_start (column, cell, FALSE);
2897 gtk_tree_view_column_add_attribute (column, cell,
2898 "icon-name", COL_WHEN_ICON);
2900 cell = gtk_cell_renderer_text_new ();
2901 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2902 gtk_tree_view_column_pack_start (column, cell, TRUE);
2903 gtk_tree_view_column_add_attribute (column, cell,
2907 gtk_tree_view_append_column (view, column);
2909 /* set up treeview properties */
2910 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
2911 gtk_tree_view_set_row_separator_func (view, when_row_is_separator,
2913 gtk_tree_sortable_set_sort_column_id (sortable,
2915 GTK_SORT_DESCENDING);
2916 gtk_tree_sortable_set_sort_func (sortable,
2917 COL_WHEN_DATE, sort_by_date,
2920 gtk_tree_view_set_search_column (view, COL_WHEN_TEXT);
2922 /* set up signals */
2923 g_signal_connect (selection, "changed",
2924 G_CALLBACK (log_window_when_changed_cb),
2927 g_object_unref (store);
2931 what_row_is_separator (GtkTreeModel *model,
2937 gtk_tree_model_get (model, iter,
2938 COL_WHAT_TYPE, &type,
2941 return (type == WHAT_TYPE_SEPARATOR);
2945 log_window_what_changed_cb (GtkTreeSelection *selection,
2946 EmpathyLogWindow *self)
2949 GtkTreeModel *model;
2952 DEBUG ("log_window_what_changed_cb");
2954 view = gtk_tree_selection_get_tree_view (selection);
2955 model = gtk_tree_view_get_model (view);
2957 /* If 'Anything' is selected, everything else should be deselected */
2958 if (gtk_tree_model_get_iter_first (model, &iter))
2960 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2962 g_signal_handlers_block_by_func (selection,
2963 log_window_what_changed_cb,
2966 gtk_tree_selection_unselect_all (selection);
2967 gtk_tree_selection_select_iter (selection, &iter);
2969 g_signal_handlers_unblock_by_func (selection,
2970 log_window_what_changed_cb,
2975 /* The dates need to be updated if we're not searching */
2976 log_window_chats_get_messages (self, self->priv->hits == NULL);
2980 log_window_what_collapse_row_cb (GtkTreeView *tree_view,
2985 /* Reject collapsing */
2992 EventSubtype subtype;
2998 log_window_what_setup (EmpathyLogWindow *self)
3001 GtkTreeModel *model;
3002 GtkTreeSelection *selection;
3003 GtkTreeViewColumn *column;
3005 GtkTreeStore *store;
3006 GtkCellRenderer *cell;
3008 struct event events [] = {
3009 { TPL_EVENT_MASK_ANY, 0, NULL, _("Anything") },
3010 { WHAT_TYPE_SEPARATOR, 0, NULL, "separator" },
3011 { TPL_EVENT_MASK_TEXT, 0, "format-justify-fill", _("Text chats") },
3012 #ifdef HAVE_CALL_LOGS
3013 { TPL_EVENT_MASK_CALL, EVENT_CALL_ALL, EMPATHY_IMAGE_CALL, _("Calls") },
3016 #ifdef HAVE_CALL_LOGS
3017 struct event call_events [] = {
3018 { TPL_EVENT_MASK_CALL, EVENT_CALL_INCOMING, EMPATHY_IMAGE_CALL_INCOMING, _("Incoming calls") },
3019 { TPL_EVENT_MASK_CALL, EVENT_CALL_OUTGOING, EMPATHY_IMAGE_CALL_OUTGOING, _("Outgoing calls") },
3020 { TPL_EVENT_MASK_CALL, EVENT_CALL_MISSED, EMPATHY_IMAGE_CALL_MISSED, _("Missed calls") }
3025 view = GTK_TREE_VIEW (self->priv->treeview_what);
3026 selection = gtk_tree_view_get_selection (view);
3029 store = gtk_tree_store_new (COL_WHAT_COUNT,
3030 G_TYPE_INT, /* history type */
3031 G_TYPE_INT, /* history subtype */
3032 G_TYPE_BOOLEAN, /* sensitive */
3033 G_TYPE_STRING, /* stringified history type */
3034 G_TYPE_STRING); /* icon */
3036 model = GTK_TREE_MODEL (store);
3038 gtk_tree_view_set_model (view, model);
3041 column = gtk_tree_view_column_new ();
3042 gtk_tree_view_column_set_title (column, _("What"));
3044 cell = gtk_cell_renderer_pixbuf_new ();
3045 gtk_tree_view_column_pack_start (column, cell, FALSE);
3046 gtk_tree_view_column_add_attribute (column, cell,
3047 "icon-name", COL_WHAT_ICON);
3049 cell = gtk_cell_renderer_text_new ();
3050 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
3051 gtk_tree_view_column_pack_start (column, cell, TRUE);
3052 gtk_tree_view_column_add_attribute (column, cell,
3053 "text", COL_WHAT_TEXT);
3054 gtk_tree_view_column_add_attribute (column, cell,
3055 "sensitive", COL_WHAT_SENSITIVE);
3057 gtk_tree_view_append_column (view, column);
3058 gtk_tree_view_set_search_column (view, COL_WHAT_TEXT);
3060 /* set up treeview properties */
3061 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
3062 gtk_tree_view_set_show_expanders (view, FALSE);
3063 gtk_tree_view_set_level_indentation (view, 12);
3064 gtk_tree_view_expand_all (view);
3065 gtk_tree_view_set_row_separator_func (view, what_row_is_separator,
3069 for (i = 0; i < G_N_ELEMENTS (events); i++)
3071 gtk_tree_store_append (store, &iter, NULL);
3072 gtk_tree_store_set (store, &iter,
3073 COL_WHAT_TYPE, events[i].type,
3074 COL_WHAT_SUBTYPE, events[i].subtype,
3075 COL_WHAT_SENSITIVE, TRUE,
3076 COL_WHAT_TEXT, events[i].text,
3077 COL_WHAT_ICON, events[i].icon,
3081 #ifdef HAVE_CALL_LOGS
3082 gtk_tree_model_iter_nth_child (model, &parent, NULL, 3);
3083 for (i = 0; i < G_N_ELEMENTS (call_events); i++)
3085 gtk_tree_store_append (store, &iter, &parent);
3086 gtk_tree_store_set (store, &iter,
3087 COL_WHAT_TYPE, call_events[i].type,
3088 COL_WHAT_SUBTYPE, call_events[i].subtype,
3089 COL_WHAT_SENSITIVE, TRUE,
3090 COL_WHAT_TEXT, call_events[i].text,
3091 COL_WHAT_ICON, call_events[i].icon,
3096 gtk_tree_view_expand_all (view);
3098 /* select 'Anything' */
3099 if (gtk_tree_model_get_iter_first (model, &iter))
3100 gtk_tree_selection_select_iter (selection, &iter);
3102 /* set up signals */
3103 g_signal_connect (view, "test-collapse-row",
3104 G_CALLBACK (log_window_what_collapse_row_cb),
3106 g_signal_connect (selection, "changed",
3107 G_CALLBACK (log_window_what_changed_cb),
3110 g_object_unref (store);
3114 log_window_maybe_expand_events (void)
3116 GtkTreeModel *model = GTK_TREE_MODEL (log_window->priv->store_events);
3118 /* If there's only one result, expand it */
3119 if (gtk_tree_model_iter_n_children (model, NULL) == 1)
3120 webkit_web_view_execute_script (
3121 WEBKIT_WEB_VIEW (log_window->priv->webview),
3122 "javascript:expandAll()");
3126 show_spinner (gpointer data)
3130 if (log_window == NULL)
3133 g_object_get (log_window->priv->spinner, "active", &active, NULL);
3136 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3143 show_events (TplActionChain *chain,
3146 log_window_maybe_expand_events ();
3147 gtk_spinner_stop (GTK_SPINNER (log_window->priv->spinner));
3148 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3151 _tpl_action_chain_continue (chain);
3155 start_spinner (void)
3157 gtk_spinner_start (GTK_SPINNER (log_window->priv->spinner));
3158 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3161 g_timeout_add (1000, show_spinner, NULL);
3162 _tpl_action_chain_append (log_window->priv->chain, show_events, NULL);
3166 log_window_got_messages_for_date_cb (GObject *manager,
3167 GAsyncResult *result,
3170 Ctx *ctx = user_data;
3171 GtkTreeModel *model;
3175 GError *error = NULL;
3178 if (log_window == NULL)
3184 if (log_window->priv->count != ctx->count)
3187 if (!tpl_log_manager_get_events_for_date_finish (TPL_LOG_MANAGER (manager),
3188 result, &events, &error))
3190 DEBUG ("Unable to retrieve messages for the selected date: %s. Aborting",
3192 g_error_free (error);
3196 for (l = events; l; l = l->next)
3198 TplEvent *event = l->data;
3199 gboolean append = TRUE;
3201 #ifdef HAVE_CALL_LOGS
3202 if (TPL_IS_CALL_EVENT (l->data)
3203 && ctx->event_mask & TPL_EVENT_MASK_CALL
3204 && ctx->event_mask != TPL_EVENT_MASK_ANY)
3206 TplCallEvent *call = l->data;
3210 if (ctx->subtype & EVENT_CALL_ALL)
3216 TplCallEndReason reason = tpl_call_event_get_end_reason (call);
3217 TplEntity *sender = tpl_event_get_sender (event);
3218 TplEntity *receiver = tpl_event_get_receiver (event);
3220 if (reason == TPL_CALL_END_REASON_NO_ANSWER)
3222 if (ctx->subtype & EVENT_CALL_MISSED)
3225 else if (ctx->subtype & EVENT_CALL_OUTGOING
3226 && tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
3230 else if (ctx->subtype & EVENT_CALL_INCOMING
3231 && tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF)
3241 EmpathyMessage *msg = empathy_message_from_tpl_log_event (event);
3242 log_window_append_message (event, msg);
3243 tp_clear_object (&msg);
3246 g_object_unref (event);
3248 g_list_free (events);
3250 model = GTK_TREE_MODEL (log_window->priv->store_events);
3251 n = gtk_tree_model_iter_n_children (model, NULL) - 1;
3253 if (n >= 0 && gtk_tree_model_iter_nth_child (model, &iter, NULL, n))
3258 path = gtk_tree_model_get_path (model, &iter);
3259 str = gtk_tree_path_to_string (path);
3261 script = g_strdup_printf ("javascript:scrollToRow([%s]);",
3262 g_strdelimit (str, ":", ','));
3264 webkit_web_view_execute_script (
3265 WEBKIT_WEB_VIEW (log_window->priv->webview),
3268 gtk_tree_path_free (path);
3276 _tpl_action_chain_continue (log_window->priv->chain);
3280 get_events_for_date (TplActionChain *chain, gpointer user_data)
3282 Ctx *ctx = user_data;
3284 tpl_log_manager_get_events_for_date_async (ctx->self->priv->log_manager,
3285 ctx->account, ctx->entity, ctx->event_mask,
3287 log_window_got_messages_for_date_cb,
3292 log_window_get_messages_for_dates (EmpathyLogWindow *self,
3295 GList *accounts, *targets, *acc, *targ, *l;
3296 TplEventTypeMask event_mask;
3297 EventSubtype subtype;
3298 GDate *date, *anytime, *separator;
3300 if (!log_window_get_selected (self,
3301 &accounts, &targets, NULL, NULL, &event_mask, &subtype))
3304 anytime = g_date_new_dmy (2, 1, -1);
3305 separator = g_date_new_dmy (1, 1, -1);
3307 _tpl_action_chain_clear (self->priv->chain);
3308 self->priv->count++;
3310 for (acc = accounts, targ = targets;
3311 acc != NULL && targ != NULL;
3312 acc = acc->next, targ = targ->next)
3314 TpAccount *account = acc->data;
3315 TplEntity *target = targ->data;
3317 for (l = dates; l != NULL; l = l->next)
3322 if (g_date_compare (date, anytime) != 0)
3326 ctx = ctx_new (self, account, target, date, event_mask, subtype,
3328 _tpl_action_chain_append (self->priv->chain, get_events_for_date, ctx);
3332 GtkTreeView *view = GTK_TREE_VIEW (self->priv->treeview_when);
3333 GtkTreeModel *model = gtk_tree_view_get_model (view);
3338 for (next = gtk_tree_model_get_iter_first (model, &iter);
3340 next = gtk_tree_model_iter_next (model, &iter))
3344 gtk_tree_model_get (model, &iter,
3348 if (g_date_compare (d, anytime) != 0 &&
3349 g_date_compare (d, separator) != 0)
3351 ctx = ctx_new (self, account, target, d,
3352 event_mask, subtype, self->priv->count);
3353 _tpl_action_chain_append (self->priv->chain, get_events_for_date, ctx);
3363 _tpl_action_chain_start (self->priv->chain);
3365 g_list_free_full (accounts, g_object_unref);
3366 g_list_free_full (targets, g_object_unref);
3367 g_date_free (separator);
3368 g_date_free (anytime);
3372 log_manager_got_dates_cb (GObject *manager,
3373 GAsyncResult *result,
3376 Ctx *ctx = user_data;
3378 GtkTreeModel *model;
3379 GtkListStore *store;
3383 GError *error = NULL;
3385 if (log_window == NULL)
3391 if (log_window->priv->count != ctx->count)
3394 if (!tpl_log_manager_get_dates_finish (TPL_LOG_MANAGER (manager),
3395 result, &dates, &error))
3397 DEBUG ("Unable to retrieve messages' dates: %s. Aborting",
3402 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
3403 model = gtk_tree_view_get_model (view);
3404 store = GTK_LIST_STORE (model);
3406 for (l = dates; l != NULL; l = l->next)
3408 GDate *date = l->data;
3410 /* Add the date if it's not already there */
3411 has_element = FALSE;
3412 gtk_tree_model_foreach (model, model_has_date, date);
3415 gchar *text = format_date_for_display (date);
3417 gtk_list_store_append (store, &iter);
3418 gtk_list_store_set (store, &iter,
3419 COL_WHEN_DATE, date,
3420 COL_WHEN_TEXT, text,
3421 COL_WHEN_ICON, CALENDAR_ICON,
3428 if (gtk_tree_model_get_iter_first (model, &iter))
3430 gchar *separator = NULL;
3432 if (gtk_tree_model_iter_next (model, &iter))
3434 gtk_tree_model_get (model, &iter,
3435 COL_WHEN_TEXT, &separator,
3439 if (g_strcmp0 (separator, "separator") != 0)
3443 date = g_date_new_dmy (1, 1, -1);
3445 gtk_list_store_prepend (store, &iter);
3446 gtk_list_store_set (store, &iter,
3447 COL_WHEN_DATE, date,
3448 COL_WHEN_TEXT, "separator",
3453 date = g_date_new_dmy (2, 1, -1);
3455 gtk_list_store_prepend (store, &iter);
3456 gtk_list_store_set (store, &iter,
3457 COL_WHEN_DATE, date,
3458 COL_WHEN_TEXT, _("Anytime"),
3467 g_list_free_full (dates, g_free);
3470 _tpl_action_chain_continue (log_window->priv->chain);
3474 select_date (TplActionChain *chain, gpointer user_data)
3477 GtkTreeModel *model;
3478 GtkTreeSelection *selection;
3481 gboolean selected = FALSE;
3483 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
3484 model = gtk_tree_view_get_model (view);
3485 selection = gtk_tree_view_get_selection (view);
3487 if (log_window->priv->current_dates != NULL)
3489 for (next = gtk_tree_model_get_iter_first (model, &iter);
3491 next = gtk_tree_model_iter_next (model, &iter))
3495 gtk_tree_model_get (model, &iter,
3496 COL_WHEN_DATE, &date,
3499 if (g_list_find_custom (log_window->priv->current_dates, date,
3500 (GCompareFunc) g_date_compare) != NULL)
3504 gtk_tree_selection_select_iter (selection, &iter);
3505 path = gtk_tree_model_get_path (model, &iter);
3506 gtk_tree_view_scroll_to_cell (view, path, NULL, FALSE, 0, 0);
3509 gtk_tree_path_free (path);
3518 /* Show messages of the most recent date */
3519 if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 2))
3520 gtk_tree_selection_select_iter (selection, &iter);
3523 _tpl_action_chain_continue (log_window->priv->chain);
3527 get_dates_for_entity (TplActionChain *chain, gpointer user_data)
3529 Ctx *ctx = user_data;
3531 tpl_log_manager_get_dates_async (ctx->self->priv->log_manager,
3532 ctx->account, ctx->entity, ctx->event_mask,
3533 log_manager_got_dates_cb, ctx);
3537 log_window_chats_get_messages (EmpathyLogWindow *self,
3538 gboolean force_get_dates)
3540 GList *accounts, *targets, *dates;
3541 TplEventTypeMask event_mask;
3543 GtkTreeModel *model;
3544 GtkListStore *store;
3545 GtkTreeSelection *selection;
3547 if (!log_window_get_selected (self, &accounts, &targets, NULL,
3548 &dates, &event_mask, NULL))
3551 view = GTK_TREE_VIEW (self->priv->treeview_when);
3552 selection = gtk_tree_view_get_selection (view);
3553 model = gtk_tree_view_get_model (view);
3554 store = GTK_LIST_STORE (model);
3556 /* Clear all current messages shown in the textview */
3557 gtk_tree_store_clear (self->priv->store_events);
3559 _tpl_action_chain_clear (self->priv->chain);
3560 self->priv->count++;
3562 /* If there's a search use the returned hits */
3563 if (self->priv->hits != NULL)
3565 if (force_get_dates)
3567 g_signal_handlers_block_by_func (selection,
3568 log_window_when_changed_cb,
3571 gtk_list_store_clear (store);
3573 g_signal_handlers_unblock_by_func (selection,
3574 log_window_when_changed_cb,
3577 populate_dates_from_search_hits (accounts, targets);
3581 populate_events_from_search_hits (accounts, targets, dates);
3584 /* Either use the supplied date or get the last */
3585 else if (force_get_dates || dates == NULL)
3589 if (self->priv->current_dates != NULL)
3591 g_list_free_full (self->priv->current_dates,
3592 (GDestroyNotify) g_date_free);
3593 self->priv->current_dates = NULL;
3596 if (gtk_tree_selection_count_selected_rows (selection) > 0)
3601 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
3603 for (l = paths; l != NULL; l = l->next)
3605 GtkTreePath *path = l->data;
3608 gtk_tree_model_get_iter (model, &iter, path);
3609 gtk_tree_model_get (model, &iter,
3610 COL_WHEN_DATE, &date,
3613 /* The list takes ownership of the date. */
3614 self->priv->current_dates =
3615 g_list_prepend (self->priv->current_dates, date);
3618 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
3621 g_signal_handlers_block_by_func (selection,
3622 log_window_when_changed_cb,
3625 gtk_list_store_clear (store);
3627 g_signal_handlers_unblock_by_func (selection,
3628 log_window_when_changed_cb,
3631 /* Get a list of dates and show them on the treeview */
3632 for (targ = targets, acc = accounts;
3633 targ != NULL && acc != NULL;
3634 targ = targ->next, acc = acc->next)
3636 TpAccount *account = acc->data;
3637 TplEntity *target = targ->data;
3638 Ctx *ctx = ctx_new (self, account, target, NULL, event_mask, 0,
3641 _tpl_action_chain_append (self->priv->chain, get_dates_for_entity, ctx);
3643 _tpl_action_chain_append (self->priv->chain, select_date, NULL);
3644 _tpl_action_chain_start (self->priv->chain);
3648 /* Show messages of the selected date */
3649 log_window_get_messages_for_dates (self, dates);
3652 g_list_free_full (accounts, g_object_unref);
3653 g_list_free_full (targets, g_object_unref);
3654 g_list_free_full (dates, (GFreeFunc) g_date_free);
3658 EmpathyAccountChooserFilterResultCallback callback;
3660 } FilterCallbackData;
3663 got_entities (GObject *manager,
3664 GAsyncResult *result,
3667 FilterCallbackData *data = user_data;
3669 GError *error = NULL;
3671 if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager),
3672 result, &entities, &error))
3674 DEBUG ("Could not get entities: %s", error->message);
3675 g_error_free (error);
3676 data->callback (FALSE, data->user_data);
3680 data->callback (entities != NULL, data->user_data);
3682 g_list_free_full (entities, g_object_unref);
3685 g_slice_free (FilterCallbackData, data);
3689 empathy_account_chooser_filter_has_logs (TpAccount *account,
3690 EmpathyAccountChooserFilterResultCallback callback,
3691 gpointer callback_data,
3694 TplLogManager *manager = tpl_log_manager_dup_singleton ();
3695 FilterCallbackData *cb_data = g_slice_new0 (FilterCallbackData);
3697 cb_data->callback = callback;
3698 cb_data->user_data = callback_data;
3700 tpl_log_manager_get_entities_async (manager, account, got_entities, cb_data);
3702 g_object_unref (manager);
3706 log_window_logger_clear_account_cb (TpProxy *proxy,
3707 const GError *error,
3709 GObject *weak_object)
3711 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (user_data);
3714 g_warning ("Error when clearing logs: %s", error->message);
3716 /* Refresh the log viewer so the logs are cleared if the account
3717 * has been deleted */
3718 gtk_tree_store_clear (self->priv->store_events);
3719 log_window_who_populate (self);
3721 /* Re-filter the account chooser so the accounts without logs get
3723 empathy_account_chooser_refilter (
3724 EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser));
3728 log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem,
3729 EmpathyLogWindow *self)
3731 GtkWidget *dialog, *content_area, *hbox, *label;
3732 EmpathyAccountChooser *account_chooser;
3736 GError *error = NULL;
3738 account_chooser = (EmpathyAccountChooser *) empathy_account_chooser_new ();
3739 empathy_account_chooser_set_has_all_option (account_chooser, TRUE);
3741 empathy_account_chooser_refilter (account_chooser);
3743 /* Select the same account as in the history window */
3744 empathy_account_chooser_set_account (account_chooser,
3745 empathy_account_chooser_get_account (
3746 EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser)));
3748 dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (self),
3749 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING,
3751 _("Are you sure you want to delete all logs of previous conversations?"));
3753 gtk_dialog_add_buttons (GTK_DIALOG (dialog),
3754 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
3755 _("Clear All"), GTK_RESPONSE_APPLY,
3758 content_area = gtk_message_dialog_get_message_area (
3759 GTK_MESSAGE_DIALOG (dialog));
3761 hbox = gtk_hbox_new (FALSE, 6);
3762 label = gtk_label_new (_("Delete from:"));
3763 gtk_box_pack_start (GTK_BOX (hbox), label,
3765 gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (account_chooser),
3767 gtk_box_pack_start (GTK_BOX (content_area), hbox,
3770 gtk_widget_show_all (hbox);
3772 response_id = gtk_dialog_run (GTK_DIALOG (dialog));
3774 if (response_id != GTK_RESPONSE_APPLY)
3777 bus = tp_dbus_daemon_dup (&error);
3780 g_warning ("Could not delete logs: %s", error->message);
3781 g_error_free (error);
3785 logger = g_object_new (TP_TYPE_PROXY,
3786 "bus-name", "org.freedesktop.Telepathy.Logger",
3787 "object-path", "/org/freedesktop/Telepathy/Logger",
3790 g_object_unref (bus);
3792 tp_proxy_add_interface_by_id (logger, EMP_IFACE_QUARK_LOGGER);
3794 if (empathy_account_chooser_has_all_selected (account_chooser))
3796 DEBUG ("Deleting logs for all the accounts");
3798 emp_cli_logger_call_clear (logger, -1,
3799 log_window_logger_clear_account_cb,
3800 self, NULL, G_OBJECT (self));
3806 account = empathy_account_chooser_get_account (account_chooser);
3808 DEBUG ("Deleting logs for %s", tp_proxy_get_object_path (account));
3810 emp_cli_logger_call_clear_account (logger, -1,
3811 tp_proxy_get_object_path (account),
3812 log_window_logger_clear_account_cb,
3813 self, NULL, G_OBJECT (self));
3816 g_object_unref (logger);
3818 gtk_widget_destroy (dialog);