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>
26 #include "empathy-log-window.h"
28 #include <glib/gi18n-lib.h>
29 #include <telepathy-glib/proxy-subclass.h>
30 #include <webkit/webkit.h>
32 #include "action-chain-internal.h"
33 #include "empathy-account-chooser.h"
34 #include "empathy-call-utils.h"
35 #include "empathy-camera-monitor.h"
36 #include "empathy-geometry.h"
37 #include "empathy-gsettings.h"
38 #include "empathy-images.h"
39 #include "empathy-individual-information-dialog.h"
40 #include "empathy-request-util.h"
41 #include "empathy-theme-manager.h"
42 #include "empathy-ui-utils.h"
43 #include "empathy-utils.h"
44 #include "empathy-webkit-utils.h"
45 #include "extensions.h"
47 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
48 #include "empathy-debug.h"
50 #define EMPATHY_NS "http://live.gnome.org/Empathy"
52 G_DEFINE_TYPE (EmpathyLogWindow, empathy_log_window, GTK_TYPE_WINDOW);
54 struct _EmpathyLogWindowPriv
58 GtkWidget *button_profile;
59 GtkWidget *button_chat;
60 GtkWidget *button_call;
61 GtkWidget *button_video;
63 GtkWidget *search_entry;
68 GtkWidget *treeview_who;
69 GtkWidget *treeview_what;
70 GtkWidget *treeview_when;
73 GtkTreeStore *store_events;
75 GtkWidget *account_chooser;
79 /* List of selected GDates, free with g_list_free_full (l, g_date_free) */
82 TplActionChain *chain;
83 TplLogManager *log_manager;
85 /* Hash of TpChannel<->TpAccount for use by the observer until we can
86 * get a TpAccount from a TpConnection or wherever */
88 TpBaseClient *observer;
90 EmpathyContact *selected_contact;
91 EmpathyContact *events_contact;
93 EmpathyCameraMonitor *camera_monitor;
94 GBinding *button_video_binding;
96 /* Used to cancel logger calls when no longer needed */
99 /* List of owned TplLogSearchHits, free with tpl_log_search_hit_free */
103 /* Only used while waiting for the account chooser to be ready */
104 TpAccount *selected_account;
105 gchar *selected_chat_id;
106 gboolean selected_is_chatroom;
108 GSettings *gsettings_chat;
109 GSettings *gsettings_desktop;
112 static void log_window_search_entry_changed_cb (GtkWidget *entry,
113 EmpathyLogWindow *self);
114 static void log_window_search_entry_activate_cb (GtkWidget *widget,
115 EmpathyLogWindow *self);
116 static void log_window_search_entry_icon_pressed_cb (GtkEntry *entry,
117 GtkEntryIconPosition icon_pos,
120 static void log_window_who_populate (EmpathyLogWindow *self);
121 static void log_window_who_setup (EmpathyLogWindow *self);
122 static void log_window_when_setup (EmpathyLogWindow *self);
123 static void log_window_what_setup (EmpathyLogWindow *self);
124 static void log_window_events_setup (EmpathyLogWindow *self);
125 static void log_window_chats_accounts_changed_cb (GtkWidget *combobox,
126 EmpathyLogWindow *self);
127 static void log_window_chats_set_selected (EmpathyLogWindow *self);
128 static void log_window_chats_get_messages (EmpathyLogWindow *self,
129 gboolean force_get_dates);
130 static void log_window_when_changed_cb (GtkTreeSelection *selection,
131 EmpathyLogWindow *self);
132 static void log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem,
133 EmpathyLogWindow *self);
134 static void start_spinner (void);
136 static void log_window_create_observer (EmpathyLogWindow *window);
137 static gboolean log_window_events_button_press_event (GtkWidget *webview,
138 GdkEventButton *event, EmpathyLogWindow *self);
139 static void log_window_update_buttons_sensitivity (EmpathyLogWindow *self);
142 empathy_account_chooser_filter_has_logs (TpAccount *account,
143 EmpathyAccountChooserFilterResultCallback callback,
144 gpointer callback_data,
166 COL_WHO_NAME_SORT_KEY,
195 COL_EVENTS_PRETTY_DATE,
204 #define CALENDAR_ICON "stock_calendar"
206 /* Seconds between two messages to be considered one conversation */
207 #define MAX_GAP 30*60
209 #define WHAT_TYPE_SEPARATOR -1
213 EVENT_CALL_INCOMING = 1 << 0,
214 EVENT_CALL_OUTGOING = 1 << 1,
215 EVENT_CALL_MISSED = 1 << 2,
216 EVENT_CALL_ALL = 1 << 3,
220 log_window_get_selected (EmpathyLogWindow *window,
225 TplEventTypeMask *event_mask,
226 EventSubtype *subtype);
228 static EmpathyLogWindow *log_window = NULL;
230 static gboolean has_element;
233 #define _date_copy(d) g_date_new_julian (g_date_get_julian (d))
238 EmpathyLogWindow *self;
242 TplEventTypeMask event_mask;
243 EventSubtype subtype;
248 ctx_new (EmpathyLogWindow *self,
252 TplEventTypeMask event_mask,
253 EventSubtype subtype,
256 Ctx *ctx = g_slice_new0 (Ctx);
260 ctx->account = g_object_ref (account);
262 ctx->entity = g_object_ref (entity);
264 ctx->date = _date_copy (date);
265 ctx->event_mask = event_mask;
266 ctx->subtype = subtype;
275 tp_clear_object (&ctx->account);
276 tp_clear_object (&ctx->entity);
277 tp_clear_pointer (&ctx->date, g_date_free);
279 g_slice_free (Ctx, ctx);
283 select_account_once_ready (EmpathyLogWindow *self,
285 const gchar *chat_id,
286 gboolean is_chatroom)
288 EmpathyAccountChooser *account_chooser;
290 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
292 tp_clear_object (&self->priv->selected_account);
293 self->priv->selected_account = g_object_ref (account);
295 g_free (self->priv->selected_chat_id);
296 self->priv->selected_chat_id = g_strdup (chat_id);
298 self->priv->selected_is_chatroom = is_chatroom;
300 empathy_account_chooser_set_account (account_chooser,
301 self->priv->selected_account);
305 toolbutton_profile_clicked (GtkToolButton *toolbutton,
306 EmpathyLogWindow *self)
308 FolksIndividual *individual;
310 g_return_if_fail (self != NULL);
311 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
313 individual = empathy_ensure_individual_from_tp_contact (
314 empathy_contact_get_tp_contact (self->priv->selected_contact));
316 empathy_display_individual_info (individual);
318 g_object_unref (individual);
322 toolbutton_chat_clicked (GtkToolButton *toolbutton,
323 EmpathyLogWindow *self)
325 g_return_if_fail (self != NULL);
326 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
328 empathy_chat_with_contact (self->priv->selected_contact,
329 gtk_get_current_event_time ());
333 toolbutton_av_clicked (GtkToolButton *toolbutton,
334 EmpathyLogWindow *self)
338 g_return_if_fail (self != NULL);
339 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
341 video = (GTK_WIDGET (toolbutton) == self->priv->button_video);
343 empathy_call_new_with_streams (
344 empathy_contact_get_id (self->priv->selected_contact),
345 empathy_contact_get_account (self->priv->selected_contact),
346 TRUE, video, gtk_get_current_event_time ());
350 insert_or_change_row (EmpathyLogWindow *self,
356 char *str = gtk_tree_path_to_string (path);
357 char *script, *text, *date, *stock_icon;
360 gtk_tree_model_get (model, iter,
361 COL_EVENTS_TEXT, &text,
362 COL_EVENTS_PRETTY_DATE, &date,
363 COL_EVENTS_ICON, &stock_icon,
366 if (!tp_str_empty (stock_icon))
368 GtkIconInfo *icon_info = gtk_icon_theme_lookup_icon (
369 gtk_icon_theme_get_default (),
371 GTK_ICON_SIZE_MENU, 0);
373 if (icon_info != NULL)
374 icon = g_strdup (gtk_icon_info_get_filename (icon_info));
376 gtk_icon_info_free (icon_info);
379 script = g_strdup_printf ("javascript:%s([%s], '%s', '%s', '%s');",
381 g_strdelimit (str, ":", ','),
383 icon != NULL ? icon : "",
386 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
398 store_events_row_inserted (GtkTreeModel *model,
401 EmpathyLogWindow *self)
403 insert_or_change_row (self, "insertRow", model, path, iter);
407 store_events_row_changed (GtkTreeModel *model,
410 EmpathyLogWindow *self)
412 insert_or_change_row (self, "changeRow", model, path, iter);
416 store_events_row_deleted (GtkTreeModel *model,
418 EmpathyLogWindow *self)
420 char *str = gtk_tree_path_to_string (path);
423 script = g_strdup_printf ("javascript:deleteRow([%s]);",
424 g_strdelimit (str, ":", ','));
426 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
434 store_events_has_child_rows (GtkTreeModel *model,
437 EmpathyLogWindow *self)
439 char *str = gtk_tree_path_to_string (path);
442 script = g_strdup_printf ("javascript:hasChildRows([%s], %u);",
443 g_strdelimit (str, ":", ','),
444 gtk_tree_model_iter_has_child (model, iter));
446 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
454 store_events_rows_reordered (GtkTreeModel *model,
458 EmpathyLogWindow *self)
460 char *str = gtk_tree_path_to_string (path);
461 int i, children = gtk_tree_model_iter_n_children (model, iter);
462 char **new_order_strv, *new_order_s;
465 new_order_strv = g_new0 (char *, children + 1);
467 for (i = 0; i < children; i++)
468 new_order_strv[i] = g_strdup_printf ("%i", new_order[i]);
470 new_order_s = g_strjoinv (",", new_order_strv);
472 script = g_strdup_printf ("javascript:reorderRows([%s], [%s]);",
473 str == NULL ? "" : g_strdelimit (str, ":", ','),
476 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
481 g_free (new_order_s);
482 g_strfreev (new_order_strv);
486 events_webview_handle_navigation (WebKitWebView *webview,
487 WebKitWebFrame *frame,
488 WebKitNetworkRequest *request,
489 WebKitWebNavigationAction *navigation_action,
490 WebKitWebPolicyDecision *policy_decision,
491 EmpathyLogWindow *window)
493 empathy_url_show (GTK_WIDGET (webview),
494 webkit_network_request_get_uri (request));
496 webkit_web_policy_decision_ignore (policy_decision);
501 empathy_log_window_constructor (GType type,
503 GObjectConstructParam *props)
507 if (log_window != NULL)
509 retval = (GObject *) log_window;
513 retval = G_OBJECT_CLASS (empathy_log_window_parent_class)
514 ->constructor (type, n_props, props);
516 log_window = EMPATHY_LOG_WINDOW (retval);
517 g_object_add_weak_pointer (retval, (gpointer) &log_window);
524 empathy_log_window_dispose (GObject *object)
526 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (object);
528 if (self->priv->source != 0)
530 g_source_remove (self->priv->source);
531 self->priv->source = 0;
534 if (self->priv->current_dates != NULL)
536 g_list_free_full (self->priv->current_dates,
537 (GDestroyNotify) g_date_free);
538 self->priv->current_dates = NULL;
541 tp_clear_pointer (&self->priv->chain, _tpl_action_chain_free);
542 tp_clear_pointer (&self->priv->channels, g_hash_table_unref);
544 tp_clear_object (&self->priv->observer);
545 tp_clear_object (&self->priv->log_manager);
546 tp_clear_object (&self->priv->selected_account);
547 tp_clear_object (&self->priv->selected_contact);
548 tp_clear_object (&self->priv->events_contact);
549 tp_clear_object (&self->priv->camera_monitor);
551 tp_clear_object (&self->priv->gsettings_chat);
552 tp_clear_object (&self->priv->gsettings_desktop);
554 tp_clear_object (&self->priv->store_events);
556 G_OBJECT_CLASS (empathy_log_window_parent_class)->dispose (object);
560 empathy_log_window_finalize (GObject *object)
562 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (object);
564 g_free (self->priv->last_find);
565 g_free (self->priv->selected_chat_id);
567 G_OBJECT_CLASS (empathy_log_window_parent_class)->finalize (object);
571 empathy_log_window_class_init (
572 EmpathyLogWindowClass *empathy_log_window_class)
574 GObjectClass *object_class = G_OBJECT_CLASS (empathy_log_window_class);
576 g_type_class_add_private (empathy_log_window_class,
577 sizeof (EmpathyLogWindowPriv));
579 object_class->constructor = empathy_log_window_constructor;
580 object_class->dispose = empathy_log_window_dispose;
581 object_class->finalize = empathy_log_window_finalize;
585 empathy_log_window_init (EmpathyLogWindow *self)
587 EmpathyAccountChooser *account_chooser;
591 GtkWidget *vbox, *accounts, *search, *label, *closeitem;
592 GtkWidget *scrolledwindow_events;
595 self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
596 EMPATHY_TYPE_LOG_WINDOW, EmpathyLogWindowPriv);
598 self->priv->chain = _tpl_action_chain_new_async (NULL, NULL, NULL);
600 self->priv->camera_monitor = empathy_camera_monitor_dup_singleton ();
602 self->priv->log_manager = tpl_log_manager_dup_singleton ();
604 self->priv->gsettings_chat = g_settings_new (EMPATHY_PREFS_CHAT_SCHEMA);
605 self->priv->gsettings_desktop = g_settings_new (
606 EMPATHY_PREFS_DESKTOP_INTERFACE_SCHEMA);
608 gtk_window_set_title (GTK_WINDOW (self), _("History"));
609 gtk_widget_set_can_focus (GTK_WIDGET (self), FALSE);
610 gtk_window_set_default_size (GTK_WINDOW (self), 800, 600);
612 filename = empathy_file_lookup ("empathy-log-window.ui", "libempathy-gtk");
613 gui = empathy_builder_get_file (filename,
614 "vbox1", &self->priv->vbox,
615 "toolbutton_profile", &self->priv->button_profile,
616 "toolbutton_chat", &self->priv->button_chat,
617 "toolbutton_call", &self->priv->button_call,
618 "toolbutton_video", &self->priv->button_video,
619 "toolbutton_accounts", &accounts,
620 "toolbutton_search", &search,
621 "imagemenuitem_close", &closeitem,
622 "treeview_who", &self->priv->treeview_who,
623 "treeview_what", &self->priv->treeview_what,
624 "treeview_when", &self->priv->treeview_when,
625 "scrolledwindow_events", &scrolledwindow_events,
626 "notebook", &self->priv->notebook,
627 "spinner", &self->priv->spinner,
631 empathy_builder_connect (gui, self,
632 "toolbutton_profile", "clicked", toolbutton_profile_clicked,
633 "toolbutton_chat", "clicked", toolbutton_chat_clicked,
634 "toolbutton_call", "clicked", toolbutton_av_clicked,
635 "toolbutton_video", "clicked", toolbutton_av_clicked,
636 "imagemenuitem_delete", "activate", log_window_delete_menu_clicked_cb,
639 gtk_container_add (GTK_CONTAINER (self), self->priv->vbox);
641 g_object_unref (gui);
643 g_signal_connect_swapped (closeitem, "activate",
644 G_CALLBACK (gtk_widget_destroy), self);
646 /* Account chooser for chats */
647 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
649 self->priv->account_chooser = empathy_account_chooser_new ();
650 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
651 empathy_account_chooser_set_has_all_option (account_chooser, TRUE);
652 empathy_account_chooser_set_filter (account_chooser,
653 empathy_account_chooser_filter_has_logs, NULL);
654 empathy_account_chooser_set_all (account_chooser);
656 gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->account_chooser),
657 GTK_STYLE_CLASS_RAISED);
659 g_signal_connect (self->priv->account_chooser, "changed",
660 G_CALLBACK (log_window_chats_accounts_changed_cb),
663 label = gtk_label_new (_("Show"));
665 gtk_box_pack_start (GTK_BOX (vbox),
666 self->priv->account_chooser,
669 gtk_box_pack_start (GTK_BOX (vbox),
673 gtk_widget_show_all (vbox);
674 gtk_container_add (GTK_CONTAINER (accounts), vbox);
677 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
679 self->priv->search_entry = gtk_entry_new ();
680 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
681 GTK_ENTRY_ICON_SECONDARY, "edit-find-symbolic");
682 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
683 GTK_ENTRY_ICON_SECONDARY, FALSE);
685 label = gtk_label_new (_("Search"));
687 gtk_box_pack_start (GTK_BOX (vbox),
688 self->priv->search_entry,
691 gtk_box_pack_start (GTK_BOX (vbox),
695 gtk_widget_show_all (vbox);
696 gtk_container_add (GTK_CONTAINER (search), vbox);
698 g_signal_connect (self->priv->search_entry, "changed",
699 G_CALLBACK (log_window_search_entry_changed_cb),
702 g_signal_connect (self->priv->search_entry, "activate",
703 G_CALLBACK (log_window_search_entry_activate_cb),
706 g_signal_connect (self->priv->search_entry, "icon-press",
707 G_CALLBACK (log_window_search_entry_icon_pressed_cb),
711 log_window_events_setup (self);
712 log_window_who_setup (self);
713 log_window_what_setup (self);
714 log_window_when_setup (self);
716 log_window_create_observer (self);
718 log_window_who_populate (self);
721 self->priv->webview = webkit_web_view_new ();
722 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow_events),
723 GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
724 gtk_container_add (GTK_CONTAINER (scrolledwindow_events),
725 self->priv->webview);
726 gtk_widget_show (self->priv->webview);
728 empathy_webkit_bind_font_setting (WEBKIT_WEB_VIEW (self->priv->webview),
729 self->priv->gsettings_desktop,
730 EMPATHY_PREFS_DESKTOP_INTERFACE_FONT_NAME);
732 filename = empathy_file_lookup ("empathy-log-window.html", "data");
733 gfile = g_file_new_for_path (filename);
736 uri = g_file_get_uri (gfile);
737 webkit_web_view_load_uri (WEBKIT_WEB_VIEW (self->priv->webview), uri);
738 g_object_unref (gfile);
741 /* handle all navigation externally */
742 g_signal_connect (self->priv->webview, "navigation-policy-decision-requested",
743 G_CALLBACK (events_webview_handle_navigation), self);
745 /* listen to changes to the treemodel */
746 g_signal_connect (self->priv->store_events, "row-inserted",
747 G_CALLBACK (store_events_row_inserted), self);
748 g_signal_connect (self->priv->store_events, "row-changed",
749 G_CALLBACK (store_events_row_changed), self);
750 g_signal_connect (self->priv->store_events, "row-deleted",
751 G_CALLBACK (store_events_row_deleted), self);
752 g_signal_connect (self->priv->store_events, "rows-reordered",
753 G_CALLBACK (store_events_rows_reordered), self);
754 g_signal_connect (self->priv->store_events, "row-has-child-toggled",
755 G_CALLBACK (store_events_has_child_rows), self);
757 /* track clicked row */
758 g_signal_connect (self->priv->webview, "button-press-event",
759 G_CALLBACK (log_window_events_button_press_event), self);
761 log_window_update_buttons_sensitivity (self);
762 gtk_widget_show (GTK_WIDGET (self));
764 empathy_geometry_bind (GTK_WINDOW (self), "log-window");
768 empathy_log_window_show (TpAccount *account,
769 const gchar *chat_id,
770 gboolean is_chatroom,
773 log_window = g_object_new (EMPATHY_TYPE_LOG_WINDOW, NULL);
775 gtk_window_present (GTK_WINDOW (log_window));
777 if (account != NULL && chat_id != NULL)
778 select_account_once_ready (log_window, account, chat_id, is_chatroom);
781 gtk_window_set_transient_for (GTK_WINDOW (log_window),
782 GTK_WINDOW (parent));
784 return GTK_WIDGET (log_window);
788 account_equal (TpAccount *a,
791 return g_str_equal (tp_proxy_get_object_path (a),
792 tp_proxy_get_object_path (b));
796 entity_equal (TplEntity *a,
799 return g_str_equal (tpl_entity_get_identifier (a),
800 tpl_entity_get_identifier (b));
804 is_same_confroom (TplEvent *e1,
807 TplEntity *sender1 = tpl_event_get_sender (e1);
808 TplEntity *receiver1 = tpl_event_get_receiver (e1);
809 TplEntity *sender2 = tpl_event_get_sender (e2);
810 TplEntity *receiver2 = tpl_event_get_receiver (e2);
811 TplEntity *room1, *room2;
813 if (receiver1 == NULL || receiver2 == NULL)
816 if (tpl_entity_get_entity_type (sender1) == TPL_ENTITY_ROOM)
818 else if (tpl_entity_get_entity_type (receiver1) == TPL_ENTITY_ROOM)
823 if (tpl_entity_get_entity_type (sender2) == TPL_ENTITY_ROOM)
825 else if (tpl_entity_get_entity_type (receiver2) == TPL_ENTITY_ROOM)
830 return g_str_equal (tpl_entity_get_identifier (room1),
831 tpl_entity_get_identifier (room2));
835 maybe_refresh_logs (TpChannel *channel,
838 GList *accounts = NULL, *entities = NULL, *dates = NULL;
840 TplEventTypeMask event_mask;
841 GDate *anytime = NULL, *today = NULL;
842 GDateTime *now = NULL;
843 gboolean refresh = FALSE;
847 if (!log_window_get_selected (log_window,
848 &accounts, &entities, &anyone, &dates, &event_mask, NULL))
850 DEBUG ("Could not get selected rows");
854 type = tp_channel_get_channel_type (channel);
856 /* If the channel type is not in the What pane, whatever has happened
857 * won't be displayed in the events pane. */
858 if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_TEXT) &&
859 !(event_mask & TPL_EVENT_MASK_TEXT))
861 if ((!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA) ||
862 !tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_CALL)) &&
863 !(event_mask & TPL_EVENT_MASK_CALL))
866 anytime = g_date_new_dmy (2, 1, -1);
867 now = g_date_time_new_now_local ();
868 today = g_date_new_dmy (g_date_time_get_day_of_month (now),
869 g_date_time_get_month (now),
870 g_date_time_get_year (now));
872 /* If Today (or anytime) isn't selected, anything that has happened now
873 * won't be displayed. */
874 if (!g_list_find_custom (dates, anytime, (GCompareFunc) g_date_compare) &&
875 !g_list_find_custom (dates, today, (GCompareFunc) g_date_compare))
884 for (acc = accounts, ent = entities;
885 acc != NULL && ent != NULL;
886 acc = g_list_next (acc), ent = g_list_next (ent))
888 if (!account_equal (account, acc->data))
891 if (!tp_strdiff (tp_channel_get_identifier (channel),
892 tpl_entity_get_identifier (ent->data)))
900 tp_clear_pointer (&anytime, g_date_free);
901 tp_clear_pointer (&today, g_date_free);
902 tp_clear_pointer (&now, g_date_time_unref);
903 g_list_free_full (accounts, g_object_unref);
904 g_list_free_full (entities, g_object_unref);
905 g_list_free_full (dates, (GFreeFunc) g_date_free);
909 DEBUG ("Refreshing logs after received event");
911 /* FIXME: We need to populate the entities in case we
912 * didn't have any previous logs with this contact. */
913 log_window_chats_get_messages (log_window, FALSE);
918 on_msg_sent (TpTextChannel *channel,
919 TpSignalledMessage *message,
922 EmpathyLogWindow *self)
924 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
926 maybe_refresh_logs (TP_CHANNEL (channel), account);
930 on_msg_received (TpTextChannel *channel,
931 TpSignalledMessage *message,
932 EmpathyLogWindow *self)
934 TpMessage *msg = TP_MESSAGE (message);
935 TpChannelTextMessageType type = tp_message_get_message_type (msg);
936 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
938 if (type != TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL &&
939 type != TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION)
942 maybe_refresh_logs (TP_CHANNEL (channel), account);
946 on_channel_ended (TpChannel *channel,
950 EmpathyLogWindow *self)
952 if (self->priv->channels != NULL)
953 g_hash_table_remove (self->priv->channels, channel);
957 on_call_ended (TpChannel *channel,
961 EmpathyLogWindow *self)
963 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
965 maybe_refresh_logs (channel, account);
967 if (self->priv->channels != NULL)
968 g_hash_table_remove (self->priv->channels, channel);
972 observe_channels (TpSimpleObserver *observer,
974 TpConnection *connection,
976 TpChannelDispatchOperation *dispatch_operation,
978 TpObserveChannelsContext *context,
981 EmpathyLogWindow *self = user_data;
985 for (l = channels; l != NULL; l = g_list_next (l))
987 TpChannel *channel = l->data;
988 const gchar *type = tp_channel_get_channel_type (channel);
990 if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_TEXT))
992 TpTextChannel *text_channel = TP_TEXT_CHANNEL (channel);
994 g_hash_table_insert (self->priv->channels,
995 g_object_ref (channel), g_object_ref (account));
997 tp_g_signal_connect_object (text_channel, "message-sent",
998 G_CALLBACK (on_msg_sent), self, 0);
999 tp_g_signal_connect_object (text_channel, "message-received",
1000 G_CALLBACK (on_msg_received), self, 0);
1001 tp_g_signal_connect_object (channel, "invalidated",
1002 G_CALLBACK (on_channel_ended), self, 0);
1004 else if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_CALL) ||
1005 !tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA))
1007 g_hash_table_insert (self->priv->channels,
1008 g_object_ref (channel), g_object_ref (account));
1010 tp_g_signal_connect_object (channel, "invalidated",
1011 G_CALLBACK (on_call_ended), self, 0);
1015 g_warning ("Unknown channel type: %s", type);
1019 tp_observe_channels_context_accept (context);
1023 log_window_create_observer (EmpathyLogWindow *self)
1025 TpAccountManager *am;
1027 am = tp_account_manager_dup ();
1029 self->priv->observer = tp_simple_observer_new_with_am (am, TRUE, "LogWindow",
1030 TRUE, observe_channels,
1031 g_object_ref (self), g_object_unref);
1033 self->priv->channels = g_hash_table_new_full (g_direct_hash, g_direct_equal,
1034 g_object_unref, g_object_unref);
1036 tp_base_client_take_observer_filter (self->priv->observer,
1038 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1039 TP_IFACE_CHANNEL_TYPE_TEXT,
1041 tp_base_client_take_observer_filter (self->priv->observer,
1043 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1044 TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA,
1046 tp_base_client_take_observer_filter (self->priv->observer,
1048 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1049 TP_IFACE_CHANNEL_TYPE_CALL,
1052 tp_base_client_register (self->priv->observer, NULL);
1054 g_object_unref (am);
1058 event_get_target (TplEvent *event)
1060 TplEntity *sender = tpl_event_get_sender (event);
1061 TplEntity *receiver = tpl_event_get_receiver (event);
1063 if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
1070 model_is_parent (GtkTreeModel *model,
1074 TplEvent *stored_event;
1077 gboolean found = FALSE;
1080 if (gtk_tree_model_iter_parent (model, &parent, iter))
1083 gtk_tree_model_get (model, iter,
1084 COL_EVENTS_ACCOUNT, &account,
1085 COL_EVENTS_TARGET, &target,
1086 COL_EVENTS_EVENT, &stored_event,
1089 if (G_OBJECT_TYPE (event) == G_OBJECT_TYPE (stored_event) &&
1090 account_equal (account, tpl_event_get_account (event)) &&
1091 (entity_equal (target, event_get_target (event)) ||
1092 is_same_confroom (event, stored_event)))
1097 gtk_tree_model_iter_nth_child (model, &child, iter,
1098 gtk_tree_model_iter_n_children (model, iter) - 1);
1100 gtk_tree_model_get (model, &child,
1101 COL_EVENTS_TS, ×tamp,
1104 if (ABS (tpl_event_get_timestamp (event) - timestamp) < MAX_GAP)
1106 /* The gap is smaller than 30 min */
1111 g_object_unref (stored_event);
1112 g_object_unref (account);
1113 g_object_unref (target);
1119 get_display_string_for_chat_message (EmpathyMessage *message,
1122 EmpathyContact *sender, *receiver, *target;
1123 TplEntity *ent_sender, *ent_receiver;
1124 const gchar *format;
1126 sender = empathy_message_get_sender (message);
1127 receiver = empathy_message_get_receiver (message);
1129 ent_sender = tpl_event_get_sender (event);
1130 ent_receiver = tpl_event_get_receiver (event);
1132 /* If this is a MUC, we want to show "Chat in <room>". */
1133 if (tpl_entity_get_entity_type (ent_sender) == TPL_ENTITY_ROOM ||
1134 (ent_receiver != NULL &&
1135 tpl_entity_get_entity_type (ent_receiver) == TPL_ENTITY_ROOM))
1136 format = _("Chat in %s");
1138 format = _("Chat with %s");
1140 if (tpl_entity_get_entity_type (ent_sender) == TPL_ENTITY_ROOM)
1142 else if (ent_receiver != NULL &&
1143 tpl_entity_get_entity_type (ent_receiver) == TPL_ENTITY_ROOM)
1145 else if (empathy_contact_is_user (sender))
1150 return g_markup_printf_escaped (format, empathy_contact_get_alias (target));
1154 get_parent_iter_for_message (TplEvent *event,
1155 EmpathyMessage *message,
1156 GtkTreeIter *parent)
1158 GtkTreeStore *store;
1159 GtkTreeModel *model;
1161 gboolean parent_found = FALSE;
1164 store = log_window->priv->store_events;
1165 model = GTK_TREE_MODEL (store);
1167 for (next = gtk_tree_model_get_iter_first (model, &iter);
1169 next = gtk_tree_model_iter_next (model, &iter))
1171 if ((parent_found = model_is_parent (model, &iter, event)))
1182 gchar *body, *pretty_date;
1184 date = g_date_time_new_from_unix_local (
1185 tpl_event_get_timestamp (event));
1187 pretty_date = g_date_time_format (date,
1188 C_("A date with the time", "%A, %e %B %Y %X"));
1190 body = get_display_string_for_chat_message (message, event);
1192 gtk_tree_store_append (store, &iter, NULL);
1193 gtk_tree_store_set (store, &iter,
1194 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1195 COL_EVENTS_PRETTY_DATE, pretty_date,
1196 COL_EVENTS_TEXT, body,
1197 COL_EVENTS_ICON, "format-justify-fill",
1198 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1199 COL_EVENTS_TARGET, event_get_target (event),
1200 COL_EVENTS_EVENT, event,
1206 g_free (pretty_date);
1207 g_date_time_unref (date);
1211 static const gchar *
1212 get_icon_for_event (TplEvent *event)
1214 const gchar *icon = NULL;
1216 if (TPL_IS_TEXT_EVENT (event))
1218 TplTextEvent *text = TPL_TEXT_EVENT (event);
1220 if (!tp_str_empty (tpl_text_event_get_supersedes_token (text)))
1221 icon = EMPATHY_IMAGE_EDIT_MESSAGE;
1223 else if (TPL_IS_CALL_EVENT (event))
1225 TplCallEvent *call = TPL_CALL_EVENT (event);
1226 TpCallStateChangeReason reason = tpl_call_event_get_end_reason (call);
1227 TplEntity *sender = tpl_event_get_sender (event);
1228 TplEntity *receiver = tpl_event_get_receiver (event);
1230 if (reason == TP_CALL_STATE_CHANGE_REASON_NO_ANSWER)
1231 icon = EMPATHY_IMAGE_CALL_MISSED;
1232 else if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
1233 icon = EMPATHY_IMAGE_CALL_OUTGOING;
1234 else if (tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF)
1235 icon = EMPATHY_IMAGE_CALL_INCOMING;
1242 log_window_append_chat_message (TplEvent *event,
1243 EmpathyMessage *message)
1245 GtkTreeStore *store = log_window->priv->store_events;
1246 GtkTreeIter iter, parent;
1247 gchar *pretty_date, *alias, *body;
1250 EmpathyStringParser *parsers;
1253 date = g_date_time_new_from_unix_local (
1254 tpl_event_get_timestamp (event));
1256 pretty_date = g_date_time_format (date, "%X");
1258 get_parent_iter_for_message (event, message, &parent);
1260 alias = g_markup_escape_text (
1261 tpl_entity_get_alias (tpl_event_get_sender (event)), -1);
1263 /* escape the text */
1264 parsers = empathy_webkit_get_string_parser (
1265 g_settings_get_boolean (log_window->priv->gsettings_chat,
1266 EMPATHY_PREFS_CHAT_SHOW_SMILEYS));
1267 msg = g_string_new ("");
1269 empathy_string_parser_substr (empathy_message_get_body (message), -1,
1272 msg_escaped = g_strescape (msg->str, NULL);
1274 if (tpl_text_event_get_message_type (TPL_TEXT_EVENT (event))
1275 == TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION)
1277 /* Translators: this is an emote: '* Danielle waves' */
1278 body = g_strdup_printf (_("<i>* %s %s</i>"), alias, msg_escaped);
1282 /* Translators: this is a message: 'Danielle: hello'
1283 * The string in bold is the sender's name */
1284 body = g_strdup_printf (_("<b>%s:</b> %s"), alias, msg_escaped);
1287 g_free (msg_escaped);
1289 gtk_tree_store_append (store, &iter, &parent);
1290 gtk_tree_store_set (store, &iter,
1291 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1292 COL_EVENTS_PRETTY_DATE, pretty_date,
1293 COL_EVENTS_TEXT, body,
1294 COL_EVENTS_ICON, get_icon_for_event (event),
1295 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1296 COL_EVENTS_TARGET, event_get_target (event),
1297 COL_EVENTS_EVENT, event,
1300 g_string_free (msg, TRUE);
1303 g_free (pretty_date);
1304 g_date_time_unref (date);
1308 log_window_append_call (TplEvent *event,
1309 EmpathyMessage *message)
1311 TplCallEvent *call = TPL_CALL_EVENT (event);
1312 GtkTreeStore *store = log_window->priv->store_events;
1313 GtkTreeIter iter, child;
1314 gchar *pretty_date, *duration, *finished;
1315 GDateTime *started_date, *finished_date;
1318 /* If searching, only add the call if the search string appears anywhere */
1319 if (!EMP_STR_EMPTY (log_window->priv->last_find))
1321 if (strstr (tpl_entity_get_identifier (tpl_event_get_sender (event)),
1322 log_window->priv->last_find) == NULL &&
1323 strstr (tpl_entity_get_identifier (tpl_event_get_receiver (event)),
1324 log_window->priv->last_find) == NULL &&
1325 strstr (tpl_call_event_get_detailed_end_reason (call),
1326 log_window->priv->last_find) == NULL)
1328 DEBUG ("TplCallEvent doesn't match search string, ignoring");
1333 started_date = g_date_time_new_from_unix_local (
1334 tpl_event_get_timestamp (event));
1336 pretty_date = g_date_time_format (started_date,
1337 C_("A date with the time", "%A, %e %B %Y %X"));
1339 gtk_tree_store_append (store, &iter, NULL);
1340 gtk_tree_store_set (store, &iter,
1341 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1342 COL_EVENTS_PRETTY_DATE, pretty_date,
1343 COL_EVENTS_TEXT, empathy_message_get_body (message),
1344 COL_EVENTS_ICON, get_icon_for_event (event),
1345 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1346 COL_EVENTS_TARGET, event_get_target (event),
1347 COL_EVENTS_EVENT, event,
1350 if (tpl_call_event_get_end_reason (call) != TP_CALL_STATE_CHANGE_REASON_NO_ANSWER)
1355 span = tpl_call_event_get_duration (TPL_CALL_EVENT (event));
1359 tmp = g_strdup_printf ("%" G_GINT64_FORMAT, span);
1360 duration = g_strdup_printf (
1361 ngettext ("%s second", "%s seconds", span), tmp);
1366 tmp = g_strdup_printf ("%" G_GINT64_FORMAT, span / 60);
1367 duration = g_strdup_printf (
1368 ngettext ("%s minute", "%s minutes", span / 60), tmp);
1372 finished_date = g_date_time_add (started_date, -span);
1373 finished = g_date_time_format (finished_date, "%X");
1374 g_date_time_unref (finished_date);
1376 body = g_strdup_printf (_("Call took %s, ended at %s"),
1377 duration, finished);
1382 gtk_tree_store_append (store, &child, &iter);
1383 gtk_tree_store_set (store, &child,
1384 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1385 COL_EVENTS_TEXT, body,
1386 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1387 COL_EVENTS_TARGET, event_get_target (event),
1388 COL_EVENTS_EVENT, event,
1394 g_free (pretty_date);
1395 g_date_time_unref (started_date);
1399 log_window_append_message (TplEvent *event,
1400 EmpathyMessage *message)
1402 if (TPL_IS_TEXT_EVENT (event))
1403 log_window_append_chat_message (event, message);
1404 else if (TPL_IS_CALL_EVENT (event))
1405 log_window_append_call (event, message);
1407 DEBUG ("Message type not handled");
1411 add_all_accounts_and_entities (GList **accounts,
1415 GtkTreeModel *model;
1418 view = GTK_TREE_VIEW (log_window->priv->treeview_who);
1419 model = gtk_tree_view_get_model (view);
1421 if (!gtk_tree_model_get_iter_first (model, &iter))
1430 gtk_tree_model_get (model, &iter,
1431 COL_WHO_ACCOUNT, &account,
1432 COL_WHO_TARGET, &entity,
1433 COL_WHO_TYPE, &type,
1436 if (type != COL_TYPE_NORMAL)
1439 if (accounts != NULL)
1440 *accounts = g_list_append (*accounts, account);
1442 if (entities != NULL)
1443 *entities = g_list_append (*entities, entity);
1445 while (gtk_tree_model_iter_next (model, &iter));
1449 log_window_get_selected (EmpathyLogWindow *self,
1454 TplEventTypeMask *event_mask,
1455 EventSubtype *subtype)
1458 GtkTreeModel *model;
1459 GtkTreeSelection *selection;
1461 TplEventTypeMask ev = 0;
1462 EventSubtype st = 0;
1466 view = GTK_TREE_VIEW (self->priv->treeview_who);
1467 model = gtk_tree_view_get_model (view);
1468 selection = gtk_tree_view_get_selection (view);
1470 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1474 if (accounts != NULL)
1476 if (entities != NULL)
1481 for (l = paths; l != NULL; l = l->next)
1483 GtkTreePath *path = l->data;
1487 gtk_tree_model_get_iter (model, &iter, path);
1488 gtk_tree_model_get (model, &iter,
1489 COL_WHO_ACCOUNT, &account,
1490 COL_WHO_TARGET, &entity,
1491 COL_WHO_TYPE, &type,
1494 if (type == COL_TYPE_ANY)
1496 if (accounts != NULL || entities != NULL)
1497 add_all_accounts_and_entities (accounts, entities);
1503 if (accounts != NULL)
1504 *accounts = g_list_append (*accounts, g_object_ref (account));
1506 if (entities != NULL)
1507 *entities = g_list_append (*entities, g_object_ref (entity));
1509 g_object_unref (account);
1510 g_object_unref (entity);
1512 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1514 view = GTK_TREE_VIEW (self->priv->treeview_what);
1515 model = gtk_tree_view_get_model (view);
1516 selection = gtk_tree_view_get_selection (view);
1518 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1519 for (l = paths; l != NULL; l = l->next)
1521 GtkTreePath *path = l->data;
1522 TplEventTypeMask mask;
1523 EventSubtype submask;
1525 gtk_tree_model_get_iter (model, &iter, path);
1526 gtk_tree_model_get (model, &iter,
1527 COL_WHAT_TYPE, &mask,
1528 COL_WHAT_SUBTYPE, &submask,
1534 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1536 view = GTK_TREE_VIEW (self->priv->treeview_when);
1537 model = gtk_tree_view_get_model (view);
1538 selection = gtk_tree_view_get_selection (view);
1544 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1545 for (l = paths; l != NULL; l = l->next)
1547 GtkTreePath *path = l->data;
1550 gtk_tree_model_get_iter (model, &iter, path);
1551 gtk_tree_model_get (model, &iter,
1552 COL_WHEN_DATE, &date,
1555 *dates = g_list_append (*dates, date);
1557 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1560 if (event_mask != NULL)
1563 if (subtype != NULL)
1570 model_has_entity (GtkTreeModel *model,
1575 TplLogSearchHit *hit = data;
1578 gboolean ret = FALSE;
1580 gtk_tree_model_get (model, iter,
1582 COL_WHO_ACCOUNT, &a,
1585 if (e != NULL && entity_equal (hit->target, e) &&
1586 a != NULL && account_equal (hit->account, a))
1588 ret = has_element = TRUE;
1591 tp_clear_object (&e);
1592 tp_clear_object (&a);
1598 model_has_date (GtkTreeModel *model,
1606 gtk_tree_model_get (model, iter,
1610 if (!g_date_compare (date, d))
1622 get_events_for_date (TplActionChain *chain, gpointer user_data);
1625 populate_events_from_search_hits (GList *accounts,
1629 TplEventTypeMask event_mask;
1630 EventSubtype subtype;
1633 gboolean is_anytime = FALSE;
1635 if (!log_window_get_selected (log_window,
1636 NULL, NULL, NULL, NULL, &event_mask, &subtype))
1639 anytime = g_date_new_dmy (2, 1, -1);
1640 if (g_list_find_custom (dates, anytime, (GCompareFunc) g_date_compare))
1643 for (l = log_window->priv->hits; l != NULL; l = l->next)
1645 TplLogSearchHit *hit = l->data;
1647 gboolean found = FALSE;
1649 /* Protect against invalid data (corrupt or old log files). */
1650 if (hit->account == NULL || hit->target == NULL)
1653 for (acc = accounts, targ = targets;
1654 acc != NULL && targ != NULL && !found;
1655 acc = acc->next, targ = targ->next)
1657 TpAccount *account = acc->data;
1658 TplEntity *target = targ->data;
1660 if (account_equal (hit->account, account) &&
1661 entity_equal (hit->target, target))
1669 g_list_find_custom (dates, hit->date, (GCompareFunc) g_date_compare)
1674 ctx = ctx_new (log_window, hit->account, hit->target, hit->date,
1675 event_mask, subtype, log_window->priv->count);
1676 _tpl_action_chain_append (log_window->priv->chain,
1677 get_events_for_date, ctx);
1682 _tpl_action_chain_start (log_window->priv->chain);
1684 g_date_free (anytime);
1688 format_date_for_display (GDate *date)
1694 /* g_date_strftime sucks */
1696 now = g_date_new ();
1697 g_date_set_time_t (now, time (NULL));
1699 days_elapsed = g_date_days_between (date, now);
1701 if (days_elapsed < 0)
1705 else if (days_elapsed == 0)
1707 text = g_strdup (_("Today"));
1709 else if (days_elapsed == 1)
1711 text = g_strdup (_("Yesterday"));
1717 dt = g_date_time_new_utc (g_date_get_year (date),
1718 g_date_get_month (date), g_date_get_day (date),
1721 if (days_elapsed <= 7)
1722 text = g_date_time_format (dt, "%A");
1724 text = g_date_time_format (dt,
1725 /* Translators: A date such as '23 May 2010' (strftime format) */
1728 g_date_time_unref (dt);
1737 add_date_if_needed (EmpathyLogWindow *self,
1740 GtkTreeModel *model;
1741 GtkListStore *store;
1744 model = gtk_tree_view_get_model (GTK_TREE_VIEW (
1745 log_window->priv->treeview_when));
1746 store = GTK_LIST_STORE (model);
1748 /* Add the date if it's not already there */
1749 has_element = FALSE;
1750 gtk_tree_model_foreach (model, model_has_date, date);
1754 text = format_date_for_display (date);
1756 gtk_list_store_insert_with_values (store, NULL, -1,
1757 COL_WHEN_DATE, date,
1758 COL_WHEN_TEXT, text,
1759 COL_WHEN_ICON, CALENDAR_ICON,
1766 populate_dates_from_search_hits (GList *accounts,
1771 GtkTreeModel *model;
1772 GtkListStore *store;
1773 GtkTreeSelection *selection;
1776 if (log_window == NULL)
1779 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
1780 model = gtk_tree_view_get_model (view);
1781 store = GTK_LIST_STORE (model);
1782 selection = gtk_tree_view_get_selection (view);
1784 for (l = log_window->priv->hits; l != NULL; l = l->next)
1786 TplLogSearchHit *hit = l->data;
1788 gboolean found = FALSE;
1790 /* Protect against invalid data (corrupt or old log files). */
1791 if (hit->account == NULL || hit->target == NULL)
1794 for (acc = accounts, targ = targets;
1795 acc != NULL && targ != NULL && !found;
1796 acc = acc->next, targ = targ->next)
1798 TpAccount *account = acc->data;
1799 TplEntity *target = targ->data;
1801 if (account_equal (hit->account, account) &&
1802 entity_equal (hit->target, target))
1809 add_date_if_needed (log_window, hit->date);
1812 if (gtk_tree_model_get_iter_first (model, &iter))
1816 date = g_date_new_dmy (1, 1, -1),
1818 gtk_list_store_prepend (store, &iter);
1819 gtk_list_store_set (store, &iter,
1820 COL_WHEN_DATE, date,
1821 COL_WHEN_TEXT, "separator",
1826 date = g_date_new_dmy (2, 1, -1),
1827 gtk_list_store_prepend (store, &iter);
1828 gtk_list_store_set (store, &iter,
1829 COL_WHEN_DATE, date,
1830 COL_WHEN_TEXT, _("Anytime"),
1835 if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 2))
1836 gtk_tree_selection_select_iter (selection, &iter);
1841 add_event_to_store (EmpathyLogWindow *self,
1845 GtkListStore *store;
1846 TplEntityType type = tpl_entity_get_entity_type (entity);
1847 EmpathyContact *contact;
1850 gboolean room = type == TPL_ENTITY_ROOM;
1852 store = GTK_LIST_STORE (gtk_tree_view_get_model (
1853 GTK_TREE_VIEW (log_window->priv->treeview_who)));
1855 contact = empathy_contact_from_tpl_contact (account, entity);
1857 name = empathy_contact_get_alias (contact);
1858 sort_key = g_utf8_collate_key (name, -1);
1860 gtk_list_store_insert_with_values (store, NULL, -1,
1861 COL_WHO_TYPE, COL_TYPE_NORMAL,
1862 COL_WHO_ICON, room ? EMPATHY_IMAGE_GROUP_MESSAGE
1863 : EMPATHY_IMAGE_AVATAR_DEFAULT,
1865 COL_WHO_NAME_SORT_KEY, sort_key,
1866 COL_WHO_ID, tpl_entity_get_identifier (entity),
1867 COL_WHO_ACCOUNT, account,
1868 COL_WHO_TARGET, entity,
1872 g_object_unref (contact);
1876 populate_entities_from_search_hits (void)
1878 EmpathyAccountChooser *account_chooser;
1881 GtkTreeModel *model;
1882 GtkTreeSelection *selection;
1884 GtkListStore *store;
1887 view = GTK_TREE_VIEW (log_window->priv->treeview_who);
1888 model = gtk_tree_view_get_model (view);
1889 store = GTK_LIST_STORE (model);
1890 selection = gtk_tree_view_get_selection (view);
1892 gtk_list_store_clear (store);
1894 account_chooser = EMPATHY_ACCOUNT_CHOOSER (log_window->priv->account_chooser);
1895 account = empathy_account_chooser_get_account (account_chooser);
1897 for (l = log_window->priv->hits; l; l = l->next)
1899 TplLogSearchHit *hit = l->data;
1901 /* Protect against invalid data (corrupt or old log files). */
1902 if (hit->account == NULL || hit->target == NULL)
1905 /* Filter based on the selected account */
1906 if (account != NULL && !account_equal (account, hit->account))
1909 /* Add the entity if it's not already there */
1910 has_element = FALSE;
1911 gtk_tree_model_foreach (model, model_has_entity, hit);
1914 add_event_to_store (log_window, hit->account, hit->target);
1918 if (gtk_tree_model_get_iter_first (model, &iter))
1920 gtk_list_store_prepend (store, &iter);
1921 gtk_list_store_set (store, &iter,
1922 COL_WHO_TYPE, COL_TYPE_SEPARATOR,
1923 COL_WHO_NAME, "separator",
1926 gtk_list_store_prepend (store, &iter);
1927 gtk_list_store_set (store, &iter,
1928 COL_WHO_TYPE, COL_TYPE_ANY,
1929 COL_WHO_NAME, _("Anyone"),
1933 /* Select 'Anyone' */
1934 if (gtk_tree_model_get_iter_first (model, &iter))
1935 gtk_tree_selection_select_iter (selection, &iter);
1939 log_manager_searched_new_cb (GObject *manager,
1940 GAsyncResult *result,
1945 GtkTreeSelection *selection;
1946 GError *error = NULL;
1948 if (log_window == NULL)
1951 if (!tpl_log_manager_search_finish (TPL_LOG_MANAGER (manager),
1952 result, &hits, &error))
1954 DEBUG ("%s. Aborting", error->message);
1955 g_error_free (error);
1959 tp_clear_pointer (&log_window->priv->hits, tpl_log_manager_search_free);
1960 log_window->priv->hits = hits;
1962 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
1963 selection = gtk_tree_view_get_selection (view);
1965 g_signal_handlers_unblock_by_func (selection,
1966 log_window_when_changed_cb,
1969 populate_entities_from_search_hits ();
1973 log_window_find_populate (EmpathyLogWindow *self,
1974 const gchar *search_criteria)
1977 GtkTreeModel *model;
1978 GtkTreeSelection *selection;
1979 GtkListStore *store;
1981 gtk_tree_store_clear (self->priv->store_events);
1983 view = GTK_TREE_VIEW (self->priv->treeview_who);
1984 model = gtk_tree_view_get_model (view);
1985 store = GTK_LIST_STORE (model);
1987 gtk_list_store_clear (store);
1989 view = GTK_TREE_VIEW (self->priv->treeview_when);
1990 model = gtk_tree_view_get_model (view);
1991 store = GTK_LIST_STORE (model);
1992 selection = gtk_tree_view_get_selection (view);
1994 gtk_list_store_clear (store);
1996 if (EMP_STR_EMPTY (search_criteria))
1998 tp_clear_pointer (&self->priv->hits, tpl_log_manager_search_free);
1999 webkit_web_view_set_highlight_text_matches (
2000 WEBKIT_WEB_VIEW (self->priv->webview), FALSE);
2001 log_window_who_populate (self);
2005 g_signal_handlers_block_by_func (selection,
2006 log_window_when_changed_cb,
2009 /* highlight the search text */
2010 webkit_web_view_mark_text_matches (WEBKIT_WEB_VIEW (self->priv->webview),
2011 search_criteria, FALSE, 0);
2013 tpl_log_manager_search_async (self->priv->log_manager,
2014 search_criteria, TPL_EVENT_MASK_ANY,
2015 log_manager_searched_new_cb, NULL);
2019 start_find_search (EmpathyLogWindow *self)
2023 str = gtk_entry_get_text (GTK_ENTRY (self->priv->search_entry));
2025 /* Don't find the same crap again */
2026 if (self->priv->last_find && !tp_strdiff (self->priv->last_find, str))
2029 g_free (self->priv->last_find);
2030 self->priv->last_find = g_strdup (str);
2032 log_window_find_populate (self, str);
2038 log_window_search_entry_changed_cb (GtkWidget *entry,
2039 EmpathyLogWindow *self)
2043 str = gtk_entry_get_text (GTK_ENTRY (self->priv->search_entry));
2045 if (!tp_str_empty (str))
2047 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
2048 GTK_ENTRY_ICON_SECONDARY, "edit-clear-symbolic");
2049 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
2050 GTK_ENTRY_ICON_SECONDARY, TRUE);
2054 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
2055 GTK_ENTRY_ICON_SECONDARY, "edit-find-symbolic");
2056 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
2057 GTK_ENTRY_ICON_SECONDARY, FALSE);
2060 if (self->priv->source != 0)
2061 g_source_remove (self->priv->source);
2062 self->priv->source = g_timeout_add (500, (GSourceFunc) start_find_search,
2067 log_window_search_entry_activate_cb (GtkWidget *entry,
2068 EmpathyLogWindow *self)
2070 start_find_search (self);
2074 log_window_search_entry_icon_pressed_cb (GtkEntry *entry,
2075 GtkEntryIconPosition icon_pos,
2079 if (icon_pos != GTK_ENTRY_ICON_SECONDARY)
2082 gtk_entry_buffer_set_text (gtk_entry_get_buffer (entry),
2087 do_update_buttons_sensitivity (EmpathyLogWindow *self)
2089 EmpathyCapabilities capabilities;
2090 gboolean profile, chat, call, video;
2092 tp_clear_object (&self->priv->button_video_binding);
2094 if (self->priv->selected_contact != NULL)
2096 capabilities = empathy_contact_get_capabilities (
2097 self->priv->selected_contact);
2099 profile = chat = TRUE;
2100 call = capabilities & EMPATHY_CAPABILITIES_AUDIO;
2101 video = capabilities & EMPATHY_CAPABILITIES_VIDEO;
2105 profile = chat = call = video = FALSE;
2108 gtk_widget_set_sensitive (self->priv->button_profile, profile);
2109 gtk_widget_set_sensitive (self->priv->button_chat, chat);
2110 gtk_widget_set_sensitive (self->priv->button_call, call);
2114 self->priv->button_video_binding = g_object_bind_property (
2115 self->priv->camera_monitor, "available",
2116 self->priv->button_video, "sensitive",
2117 G_BINDING_SYNC_CREATE);
2121 /* Don't override the binding */
2122 gtk_widget_set_sensitive (self->priv->button_video, video);
2127 contact_capabilities_changed_cb (EmpathyContact *contact,
2129 EmpathyLogWindow *self)
2131 do_update_buttons_sensitivity (self);
2135 log_window_update_buttons_sensitivity (EmpathyLogWindow *self)
2138 GtkTreeModel *model;
2139 GtkTreeSelection *selection;
2146 if (self->priv->selected_contact != NULL)
2148 g_signal_handlers_disconnect_by_func (self->priv->selected_contact,
2149 contact_capabilities_changed_cb, self);
2151 tp_clear_object (&self->priv->selected_contact);
2154 view = GTK_TREE_VIEW (self->priv->treeview_who);
2155 model = gtk_tree_view_get_model (view);
2156 selection = gtk_tree_view_get_selection (view);
2158 if (!gtk_tree_model_get_iter_first (model, &iter))
2161 if (gtk_tree_selection_count_selected_rows (selection) != 1)
2164 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2167 paths = gtk_tree_selection_get_selected_rows (selection, &model);
2168 g_return_if_fail (paths != NULL);
2171 gtk_tree_model_get_iter (model, &iter, path);
2172 gtk_tree_model_get (model, &iter,
2173 COL_WHO_ACCOUNT, &account,
2174 COL_WHO_TARGET, &target,
2177 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
2179 self->priv->selected_contact = empathy_contact_from_tpl_contact (account,
2182 g_object_unref (account);
2183 g_object_unref (target);
2188 /* If the Who pane doesn't contain a contact (e.g. it has many
2189 * selected, or has 'Anyone', let's try to get the contact from
2190 * the selected event. */
2192 if (self->priv->events_contact != NULL)
2193 self->priv->selected_contact = g_object_ref (self->priv->events_contact);
2196 if (self->priv->selected_contact != NULL)
2198 tp_g_signal_connect_object (self->priv->selected_contact,
2199 "notify::capabilities", G_CALLBACK (contact_capabilities_changed_cb),
2203 do_update_buttons_sensitivity (self);
2207 log_window_update_what_iter_sensitivity (GtkTreeModel *model,
2211 GtkTreeStore *store = GTK_TREE_STORE (model);
2215 gtk_tree_store_set (store, iter,
2216 COL_WHAT_SENSITIVE, sensitive,
2219 for (next = gtk_tree_model_iter_children (model, &child, iter);
2221 next = gtk_tree_model_iter_next (model, &child))
2223 gtk_tree_store_set (store, &child,
2224 COL_WHAT_SENSITIVE, sensitive,
2230 log_window_update_what_sensitivity (EmpathyLogWindow *self)
2233 GtkTreeModel *model;
2235 GList *accounts, *targets, *acc, *targ;
2238 if (!log_window_get_selected (self, &accounts, &targets, NULL, NULL,
2242 view = GTK_TREE_VIEW (self->priv->treeview_what);
2243 model = gtk_tree_view_get_model (view);
2245 /* For each event type... */
2246 for (next = gtk_tree_model_get_iter_first (model, &iter);
2248 next = gtk_tree_model_iter_next (model, &iter))
2250 TplEventTypeMask type;
2252 gtk_tree_model_get (model, &iter,
2253 COL_WHAT_TYPE, &type,
2256 /* ...we set the type and its subtypes (if any) unsensitive... */
2257 log_window_update_what_iter_sensitivity (model, &iter, FALSE);
2259 for (acc = accounts, targ = targets;
2260 acc != NULL && targ != NULL;
2261 acc = acc->next, targ = targ->next)
2263 TpAccount *account = acc->data;
2264 TplEntity *target = targ->data;
2266 if (tpl_log_manager_exists (self->priv->log_manager,
2267 account, target, type))
2269 /* And then we set it (and its subtypes, again, if any)
2270 * as sensitive if there are logs of that type. */
2271 log_window_update_what_iter_sensitivity (model, &iter, TRUE);
2277 g_list_free_full (accounts, g_object_unref);
2278 g_list_free_full (targets, g_object_unref);
2282 log_window_who_changed_cb (GtkTreeSelection *selection,
2283 EmpathyLogWindow *self)
2286 GtkTreeModel *model;
2289 DEBUG ("log_window_who_changed_cb");
2291 view = gtk_tree_selection_get_tree_view (selection);
2292 model = gtk_tree_view_get_model (view);
2294 if (gtk_tree_model_get_iter_first (model, &iter))
2296 /* If 'Anyone' is selected, everything else should be deselected */
2297 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2299 g_signal_handlers_block_by_func (selection,
2300 log_window_who_changed_cb,
2303 gtk_tree_selection_unselect_all (selection);
2304 gtk_tree_selection_select_iter (selection, &iter);
2306 g_signal_handlers_unblock_by_func (selection,
2307 log_window_who_changed_cb,
2312 log_window_update_what_sensitivity (self);
2313 log_window_update_buttons_sensitivity (self);
2315 /* The contact changed, so the dates need to be updated */
2316 log_window_chats_get_messages (self, TRUE);
2320 log_manager_got_entities_cb (GObject *manager,
2321 GAsyncResult *result,
2324 Ctx *ctx = user_data;
2328 GtkTreeModel *model;
2329 GtkTreeSelection *selection;
2330 GtkListStore *store;
2332 GError *error = NULL;
2333 gboolean select_account = FALSE;
2335 if (log_window == NULL)
2338 if (log_window->priv->count != ctx->count)
2341 if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager),
2342 result, &entities, &error))
2344 DEBUG ("%s. Aborting", error->message);
2345 g_error_free (error);
2349 view = GTK_TREE_VIEW (ctx->self->priv->treeview_who);
2350 model = gtk_tree_view_get_model (view);
2351 selection = gtk_tree_view_get_selection (view);
2352 store = GTK_LIST_STORE (model);
2354 /* Block signals to stop the logs being retrieved prematurely */
2355 g_signal_handlers_block_by_func (selection,
2356 log_window_who_changed_cb, ctx->self);
2358 for (l = entities; l; l = l->next)
2360 add_event_to_store (ctx->self, ctx->account, l->data);
2362 if (ctx->self->priv->selected_account != NULL &&
2363 !tp_strdiff (tp_proxy_get_object_path (ctx->account),
2364 tp_proxy_get_object_path (ctx->self->priv->selected_account)))
2365 select_account = TRUE;
2367 g_list_free_full (entities, g_object_unref);
2369 if (gtk_tree_model_get_iter_first (model, &iter))
2373 gtk_tree_model_get (model, &iter,
2374 COL_WHO_TYPE, &type,
2377 if (type != COL_TYPE_ANY)
2379 gtk_list_store_prepend (store, &iter);
2380 gtk_list_store_set (store, &iter,
2381 COL_WHO_TYPE, COL_TYPE_SEPARATOR,
2382 COL_WHO_NAME, "separator",
2385 gtk_list_store_prepend (store, &iter);
2386 gtk_list_store_set (store, &iter,
2387 COL_WHO_TYPE, COL_TYPE_ANY,
2388 COL_WHO_NAME, _("Anyone"),
2393 /* Unblock signals */
2394 g_signal_handlers_unblock_by_func (selection,
2395 log_window_who_changed_cb,
2398 /* We display the selected account if we populate the model with chats from
2401 log_window_chats_set_selected (ctx->self);
2404 _tpl_action_chain_continue (log_window->priv->chain);
2409 get_entities_for_account (TplActionChain *chain, gpointer user_data)
2411 Ctx *ctx = user_data;
2413 tpl_log_manager_get_entities_async (ctx->self->priv->log_manager, ctx->account,
2414 log_manager_got_entities_cb, ctx);
2418 select_first_entity (TplActionChain *chain, gpointer user_data)
2420 EmpathyLogWindow *self = user_data;
2422 GtkTreeModel *model;
2423 GtkTreeSelection *selection;
2426 view = GTK_TREE_VIEW (self->priv->treeview_who);
2427 model = gtk_tree_view_get_model (view);
2428 selection = gtk_tree_view_get_selection (view);
2430 if (gtk_tree_model_get_iter_first (model, &iter))
2431 gtk_tree_selection_select_iter (selection, &iter);
2433 _tpl_action_chain_continue (self->priv->chain);
2437 log_window_who_populate (EmpathyLogWindow *self)
2439 EmpathyAccountChooser *account_chooser;
2441 gboolean all_accounts;
2443 GtkTreeModel *model;
2444 GtkTreeSelection *selection;
2445 GtkListStore *store;
2448 if (self->priv->hits != NULL)
2450 populate_entities_from_search_hits ();
2454 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
2455 account = empathy_account_chooser_dup_account (account_chooser);
2456 all_accounts = empathy_account_chooser_has_all_selected (account_chooser);
2458 view = GTK_TREE_VIEW (self->priv->treeview_who);
2459 model = gtk_tree_view_get_model (view);
2460 selection = gtk_tree_view_get_selection (view);
2461 store = GTK_LIST_STORE (model);
2463 /* Block signals to stop the logs being retrieved prematurely */
2464 g_signal_handlers_block_by_func (selection,
2465 log_window_who_changed_cb,
2468 gtk_list_store_clear (store);
2470 /* Unblock signals */
2471 g_signal_handlers_unblock_by_func (selection,
2472 log_window_who_changed_cb,
2475 _tpl_action_chain_clear (self->priv->chain);
2476 self->priv->count++;
2478 if (!all_accounts && account == NULL)
2482 else if (!all_accounts)
2484 ctx = ctx_new (self, account, NULL, NULL, 0, 0, self->priv->count);
2485 _tpl_action_chain_append (self->priv->chain, get_entities_for_account, ctx);
2489 TpAccountManager *manager;
2490 GList *accounts, *l;
2492 manager = empathy_account_chooser_get_account_manager (account_chooser);
2493 accounts = tp_account_manager_dup_valid_accounts (manager);
2495 for (l = accounts; l != NULL; l = l->next)
2499 ctx = ctx_new (self, account, NULL, NULL, 0, 0, self->priv->count);
2500 _tpl_action_chain_append (self->priv->chain,
2501 get_entities_for_account, ctx);
2504 g_list_free_full (accounts, g_object_unref);
2506 _tpl_action_chain_append (self->priv->chain, select_first_entity, self);
2507 _tpl_action_chain_start (self->priv->chain);
2511 sort_by_name_key (GtkTreeModel *model,
2520 gtk_tree_model_get (model, a,
2521 COL_WHO_TYPE, &type1,
2522 COL_WHO_NAME_SORT_KEY, &key1,
2525 gtk_tree_model_get (model, b,
2526 COL_WHO_TYPE, &type2,
2527 COL_WHO_NAME_SORT_KEY, &key2,
2530 if (type1 == COL_TYPE_ANY)
2532 else if (type2 == COL_TYPE_ANY)
2534 else if (type1 == COL_TYPE_SEPARATOR)
2536 else if (type2 == COL_TYPE_SEPARATOR)
2539 ret = g_strcmp0 (key1, key2);
2548 who_row_is_separator (GtkTreeModel *model,
2554 gtk_tree_model_get (model, iter,
2555 COL_WHO_TYPE, &type,
2558 return (type == COL_TYPE_SEPARATOR);
2562 log_window_find_row (EmpathyLogWindow *self,
2563 GdkEventButton *event)
2565 WebKitHitTestResult *hit = webkit_web_view_get_hit_test_result (
2566 WEBKIT_WEB_VIEW (self->priv->webview), event);
2567 WebKitDOMNode *inner_node;
2569 tp_clear_object (&self->priv->events_contact);
2572 "inner-node", &inner_node,
2575 if (inner_node != NULL)
2577 GtkTreeModel *model = GTK_TREE_MODEL (self->priv->store_events);
2578 WebKitDOMNode *node;
2579 const char *path = NULL;
2582 /* walk back up the DOM tree looking for a node with empathy:path set */
2583 for (node = inner_node; node != NULL;
2584 node = webkit_dom_node_get_parent_node (node))
2586 if (!WEBKIT_DOM_IS_ELEMENT (node))
2589 path = webkit_dom_element_get_attribute_ns (
2590 WEBKIT_DOM_ELEMENT (node), EMPATHY_NS, "path");
2592 if (!tp_str_empty (path))
2596 /* look up the contact for this path */
2597 if (!tp_str_empty (path) &&
2598 gtk_tree_model_get_iter_from_string (model, &iter, path))
2603 gtk_tree_model_get (model, &iter,
2604 COL_EVENTS_ACCOUNT, &account,
2605 COL_EVENTS_TARGET, &target,
2608 self->priv->events_contact = empathy_contact_from_tpl_contact (
2611 g_object_unref (account);
2612 g_object_unref (target);
2615 g_object_unref (inner_node);
2618 g_object_unref (hit);
2620 log_window_update_buttons_sensitivity (self);
2624 log_window_events_button_press_event (GtkWidget *webview,
2625 GdkEventButton *event,
2626 EmpathyLogWindow *self)
2628 switch (event->button)
2631 log_window_find_row (self, event);
2635 empathy_webkit_context_menu_for_event (
2636 WEBKIT_WEB_VIEW (webview), event, 0);
2647 log_window_events_setup (EmpathyLogWindow *self)
2649 GtkTreeSortable *sortable;
2650 GtkTreeStore *store;
2653 self->priv->store_events = store = gtk_tree_store_new (COL_EVENTS_COUNT,
2654 G_TYPE_INT, /* type */
2655 G_TYPE_INT64, /* timestamp */
2656 G_TYPE_STRING, /* stringified date */
2657 G_TYPE_STRING, /* icon */
2658 G_TYPE_STRING, /* name */
2659 TP_TYPE_ACCOUNT, /* account */
2660 TPL_TYPE_ENTITY, /* target */
2661 TPL_TYPE_EVENT); /* event */
2663 sortable = GTK_TREE_SORTABLE (store);
2665 gtk_tree_sortable_set_sort_column_id (sortable,
2667 GTK_SORT_ASCENDING);
2671 log_window_who_setup (EmpathyLogWindow *self)
2674 GtkTreeModel *model;
2675 GtkTreeSelection *selection;
2676 GtkTreeSortable *sortable;
2677 GtkTreeViewColumn *column;
2678 GtkListStore *store;
2679 GtkCellRenderer *cell;
2681 view = GTK_TREE_VIEW (self->priv->treeview_who);
2682 selection = gtk_tree_view_get_selection (view);
2685 store = gtk_list_store_new (COL_WHO_COUNT,
2686 G_TYPE_INT, /* type */
2687 G_TYPE_STRING, /* icon */
2688 G_TYPE_STRING, /* name */
2689 G_TYPE_STRING, /* name sort key */
2690 G_TYPE_STRING, /* id */
2691 TP_TYPE_ACCOUNT, /* account */
2692 TPL_TYPE_ENTITY); /* target */
2694 model = GTK_TREE_MODEL (store);
2695 sortable = GTK_TREE_SORTABLE (store);
2697 gtk_tree_view_set_model (view, model);
2700 column = gtk_tree_view_column_new ();
2701 gtk_tree_view_column_set_title (column, _("Who"));
2703 cell = gtk_cell_renderer_pixbuf_new ();
2704 gtk_tree_view_column_pack_start (column, cell, FALSE);
2705 gtk_tree_view_column_add_attribute (column, cell,
2709 cell = gtk_cell_renderer_text_new ();
2710 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2711 gtk_tree_view_column_pack_start (column, cell, TRUE);
2712 gtk_tree_view_column_add_attribute (column, cell,
2716 gtk_tree_view_append_column (view, column);
2718 /* set up treeview properties */
2719 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
2720 gtk_tree_view_set_row_separator_func (view, who_row_is_separator,
2723 gtk_tree_sortable_set_sort_column_id (sortable,
2724 COL_WHO_NAME_SORT_KEY,
2725 GTK_SORT_ASCENDING);
2726 gtk_tree_sortable_set_sort_func (sortable,
2727 COL_WHO_NAME_SORT_KEY, sort_by_name_key,
2730 gtk_tree_view_set_search_column (view, COL_WHO_NAME);
2731 gtk_tree_view_set_tooltip_column (view, COL_WHO_ID);
2733 /* set up signals */
2734 g_signal_connect (selection, "changed",
2735 G_CALLBACK (log_window_who_changed_cb), self);
2737 g_object_unref (store);
2741 log_window_chats_accounts_changed_cb (GtkWidget *combobox,
2742 EmpathyLogWindow *self)
2744 /* Clear all current messages shown in the textview */
2745 gtk_tree_store_clear (self->priv->store_events);
2747 log_window_who_populate (self);
2751 log_window_chats_set_selected (EmpathyLogWindow *self)
2754 GtkTreeModel *model;
2755 GtkTreeSelection *selection;
2760 view = GTK_TREE_VIEW (self->priv->treeview_who);
2761 model = gtk_tree_view_get_model (view);
2762 selection = gtk_tree_view_get_selection (view);
2764 for (next = gtk_tree_model_get_iter_first (model, &iter);
2766 next = gtk_tree_model_iter_next (model, &iter))
2768 TpAccount *this_account;
2769 TplEntity *this_target;
2770 const gchar *this_chat_id;
2771 gboolean this_is_chatroom;
2774 gtk_tree_model_get (model, &iter,
2775 COL_WHO_TYPE, &this_type,
2776 COL_WHO_ACCOUNT, &this_account,
2777 COL_WHO_TARGET, &this_target,
2780 if (this_type != COL_TYPE_NORMAL)
2783 this_chat_id = tpl_entity_get_identifier (this_target);
2784 this_is_chatroom = tpl_entity_get_entity_type (this_target)
2787 if (this_account == self->priv->selected_account &&
2788 !tp_strdiff (this_chat_id, self->priv->selected_chat_id) &&
2789 this_is_chatroom == self->priv->selected_is_chatroom)
2791 gtk_tree_selection_select_iter (selection, &iter);
2792 path = gtk_tree_model_get_path (model, &iter);
2793 gtk_tree_view_scroll_to_cell (view, path, NULL, TRUE, 0.5, 0.0);
2794 gtk_tree_path_free (path);
2795 g_object_unref (this_account);
2796 g_object_unref (this_target);
2800 g_object_unref (this_account);
2801 g_object_unref (this_target);
2804 tp_clear_object (&self->priv->selected_account);
2805 tp_clear_pointer (&self->priv->selected_chat_id, g_free);
2809 sort_by_date (GtkTreeModel *model,
2814 GDate *date1, *date2;
2817 gtk_tree_model_get (model, a,
2818 COL_WHEN_DATE, &date1,
2821 gtk_tree_model_get (model, b,
2822 COL_WHEN_DATE, &date2,
2825 result = g_date_compare (date1, date2);
2827 g_date_free (date1);
2828 g_date_free (date2);
2833 when_row_is_separator (GtkTreeModel *model,
2840 gtk_tree_model_get (model, iter,
2841 COL_WHEN_TEXT, &when,
2844 ret = !tp_strdiff (when, "separator");
2850 log_window_when_changed_cb (GtkTreeSelection *selection,
2851 EmpathyLogWindow *self)
2854 GtkTreeModel *model;
2857 DEBUG ("log_window_when_changed_cb");
2859 view = gtk_tree_selection_get_tree_view (selection);
2860 model = gtk_tree_view_get_model (view);
2862 /* If 'Anytime' is selected, everything else should be deselected */
2863 if (gtk_tree_model_get_iter_first (model, &iter))
2865 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2867 g_signal_handlers_block_by_func (selection,
2868 log_window_when_changed_cb,
2871 gtk_tree_selection_unselect_all (selection);
2872 gtk_tree_selection_select_iter (selection, &iter);
2874 g_signal_handlers_unblock_by_func (selection,
2875 log_window_when_changed_cb,
2880 log_window_chats_get_messages (self, FALSE);
2884 log_window_when_setup (EmpathyLogWindow *self)
2887 GtkTreeModel *model;
2888 GtkTreeSelection *selection;
2889 GtkTreeSortable *sortable;
2890 GtkTreeViewColumn *column;
2891 GtkListStore *store;
2892 GtkCellRenderer *cell;
2894 view = GTK_TREE_VIEW (self->priv->treeview_when);
2895 selection = gtk_tree_view_get_selection (view);
2898 store = gtk_list_store_new (COL_WHEN_COUNT,
2899 G_TYPE_DATE, /* date */
2900 G_TYPE_STRING, /* stringified date */
2901 G_TYPE_STRING); /* icon */
2903 model = GTK_TREE_MODEL (store);
2904 sortable = GTK_TREE_SORTABLE (store);
2906 gtk_tree_view_set_model (view, model);
2909 column = gtk_tree_view_column_new ();
2910 gtk_tree_view_column_set_title (column, _("When"));
2912 cell = gtk_cell_renderer_pixbuf_new ();
2913 gtk_tree_view_column_pack_start (column, cell, FALSE);
2914 gtk_tree_view_column_add_attribute (column, cell,
2915 "icon-name", COL_WHEN_ICON);
2917 cell = gtk_cell_renderer_text_new ();
2918 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2919 gtk_tree_view_column_pack_start (column, cell, TRUE);
2920 gtk_tree_view_column_add_attribute (column, cell,
2924 gtk_tree_view_append_column (view, column);
2926 /* set up treeview properties */
2927 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
2928 gtk_tree_view_set_row_separator_func (view, when_row_is_separator,
2930 gtk_tree_sortable_set_sort_column_id (sortable,
2932 GTK_SORT_DESCENDING);
2933 gtk_tree_sortable_set_sort_func (sortable,
2934 COL_WHEN_DATE, sort_by_date,
2937 gtk_tree_view_set_search_column (view, COL_WHEN_TEXT);
2939 /* set up signals */
2940 g_signal_connect (selection, "changed",
2941 G_CALLBACK (log_window_when_changed_cb),
2944 g_object_unref (store);
2948 what_row_is_separator (GtkTreeModel *model,
2954 gtk_tree_model_get (model, iter,
2955 COL_WHAT_TYPE, &type,
2958 return (type == WHAT_TYPE_SEPARATOR);
2962 log_window_what_changed_cb (GtkTreeSelection *selection,
2963 EmpathyLogWindow *self)
2966 GtkTreeModel *model;
2969 DEBUG ("log_window_what_changed_cb");
2971 view = gtk_tree_selection_get_tree_view (selection);
2972 model = gtk_tree_view_get_model (view);
2974 /* If 'Anything' is selected, everything else should be deselected */
2975 if (gtk_tree_model_get_iter_first (model, &iter))
2977 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2979 g_signal_handlers_block_by_func (selection,
2980 log_window_what_changed_cb,
2983 gtk_tree_selection_unselect_all (selection);
2984 gtk_tree_selection_select_iter (selection, &iter);
2986 g_signal_handlers_unblock_by_func (selection,
2987 log_window_what_changed_cb,
2992 /* The dates need to be updated if we're not searching */
2993 log_window_chats_get_messages (self, self->priv->hits == NULL);
2997 log_window_what_collapse_row_cb (GtkTreeView *tree_view,
3002 /* Reject collapsing */
3009 EventSubtype subtype;
3015 log_window_what_setup (EmpathyLogWindow *self)
3018 GtkTreeModel *model;
3019 GtkTreeSelection *selection;
3020 GtkTreeViewColumn *column;
3022 GtkTreeStore *store;
3023 GtkCellRenderer *cell;
3027 struct event events [] = {
3028 { TPL_EVENT_MASK_ANY, 0, NULL, _("Anything") },
3029 { WHAT_TYPE_SEPARATOR, 0, NULL, "separator" },
3030 { TPL_EVENT_MASK_TEXT, 0, "format-justify-fill", _("Text chats") },
3031 { TPL_EVENT_MASK_CALL, EVENT_CALL_ALL, EMPATHY_IMAGE_CALL, _("Calls") },
3034 struct event call_events [] = {
3035 { TPL_EVENT_MASK_CALL, EVENT_CALL_INCOMING, EMPATHY_IMAGE_CALL_INCOMING, _("Incoming calls") },
3036 { TPL_EVENT_MASK_CALL, EVENT_CALL_OUTGOING, EMPATHY_IMAGE_CALL_OUTGOING, _("Outgoing calls") },
3037 { TPL_EVENT_MASK_CALL, EVENT_CALL_MISSED, EMPATHY_IMAGE_CALL_MISSED, _("Missed calls") }
3040 view = GTK_TREE_VIEW (self->priv->treeview_what);
3041 selection = gtk_tree_view_get_selection (view);
3044 store = gtk_tree_store_new (COL_WHAT_COUNT,
3045 G_TYPE_INT, /* history type */
3046 G_TYPE_INT, /* history subtype */
3047 G_TYPE_BOOLEAN, /* sensitive */
3048 G_TYPE_STRING, /* stringified history type */
3049 G_TYPE_STRING); /* icon */
3051 model = GTK_TREE_MODEL (store);
3053 gtk_tree_view_set_model (view, model);
3056 column = gtk_tree_view_column_new ();
3057 gtk_tree_view_column_set_title (column, _("What"));
3059 cell = gtk_cell_renderer_pixbuf_new ();
3060 gtk_tree_view_column_pack_start (column, cell, FALSE);
3061 gtk_tree_view_column_add_attribute (column, cell,
3062 "icon-name", COL_WHAT_ICON);
3064 cell = gtk_cell_renderer_text_new ();
3065 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
3066 gtk_tree_view_column_pack_start (column, cell, TRUE);
3067 gtk_tree_view_column_add_attribute (column, cell,
3068 "text", COL_WHAT_TEXT);
3069 gtk_tree_view_column_add_attribute (column, cell,
3070 "sensitive", COL_WHAT_SENSITIVE);
3072 gtk_tree_view_append_column (view, column);
3073 gtk_tree_view_set_search_column (view, COL_WHAT_TEXT);
3075 /* set up treeview properties */
3076 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
3077 gtk_tree_view_set_show_expanders (view, FALSE);
3078 gtk_tree_view_set_level_indentation (view, 12);
3079 gtk_tree_view_expand_all (view);
3080 gtk_tree_view_set_row_separator_func (view, what_row_is_separator,
3084 for (i = 0; i < G_N_ELEMENTS (events); i++)
3086 gtk_tree_store_append (store, &iter, NULL);
3087 gtk_tree_store_set (store, &iter,
3088 COL_WHAT_TYPE, events[i].type,
3089 COL_WHAT_SUBTYPE, events[i].subtype,
3090 COL_WHAT_SENSITIVE, TRUE,
3091 COL_WHAT_TEXT, events[i].text,
3092 COL_WHAT_ICON, events[i].icon,
3096 gtk_tree_model_iter_nth_child (model, &parent, NULL, 3);
3097 for (i = 0; i < G_N_ELEMENTS (call_events); i++)
3099 gtk_tree_store_append (store, &iter, &parent);
3100 gtk_tree_store_set (store, &iter,
3101 COL_WHAT_TYPE, call_events[i].type,
3102 COL_WHAT_SUBTYPE, call_events[i].subtype,
3103 COL_WHAT_SENSITIVE, TRUE,
3104 COL_WHAT_TEXT, call_events[i].text,
3105 COL_WHAT_ICON, call_events[i].icon,
3109 gtk_tree_view_expand_all (view);
3111 /* select 'Anything' */
3112 if (gtk_tree_model_get_iter_first (model, &iter))
3113 gtk_tree_selection_select_iter (selection, &iter);
3115 /* set up signals */
3116 g_signal_connect (view, "test-collapse-row",
3117 G_CALLBACK (log_window_what_collapse_row_cb),
3119 g_signal_connect (selection, "changed",
3120 G_CALLBACK (log_window_what_changed_cb),
3123 g_object_unref (store);
3127 log_window_maybe_expand_events (void)
3129 GtkTreeModel *model = GTK_TREE_MODEL (log_window->priv->store_events);
3131 /* If there's only one result, expand it */
3132 if (gtk_tree_model_iter_n_children (model, NULL) == 1)
3133 webkit_web_view_execute_script (
3134 WEBKIT_WEB_VIEW (log_window->priv->webview),
3135 "javascript:expandAll()");
3139 show_spinner (gpointer data)
3143 if (log_window == NULL)
3146 g_object_get (log_window->priv->spinner, "active", &active, NULL);
3149 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3156 show_events (TplActionChain *chain,
3159 log_window_maybe_expand_events ();
3160 gtk_spinner_stop (GTK_SPINNER (log_window->priv->spinner));
3161 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3164 _tpl_action_chain_continue (chain);
3168 start_spinner (void)
3170 gtk_spinner_start (GTK_SPINNER (log_window->priv->spinner));
3171 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3174 g_timeout_add (1000, show_spinner, NULL);
3175 _tpl_action_chain_append (log_window->priv->chain, show_events, NULL);
3179 log_window_got_messages_for_date_cb (GObject *manager,
3180 GAsyncResult *result,
3183 Ctx *ctx = user_data;
3184 GtkTreeModel *model;
3188 GError *error = NULL;
3191 if (log_window == NULL)
3197 if (log_window->priv->count != ctx->count)
3200 if (!tpl_log_manager_get_events_for_date_finish (TPL_LOG_MANAGER (manager),
3201 result, &events, &error))
3203 DEBUG ("Unable to retrieve messages for the selected date: %s. Aborting",
3205 g_error_free (error);
3209 for (l = events; l; l = l->next)
3211 TplEvent *event = l->data;
3212 gboolean append = TRUE;
3214 if (TPL_IS_CALL_EVENT (l->data)
3215 && ctx->event_mask & TPL_EVENT_MASK_CALL
3216 && ctx->event_mask != TPL_EVENT_MASK_ANY)
3218 TplCallEvent *call = l->data;
3222 if (ctx->subtype & EVENT_CALL_ALL)
3228 TpCallStateChangeReason reason =
3229 tpl_call_event_get_end_reason (call);
3230 TplEntity *sender = tpl_event_get_sender (event);
3231 TplEntity *receiver = tpl_event_get_receiver (event);
3233 if (reason == TP_CALL_STATE_CHANGE_REASON_NO_ANSWER)
3235 if (ctx->subtype & EVENT_CALL_MISSED)
3238 else if (ctx->subtype & EVENT_CALL_OUTGOING
3239 && tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
3243 else if (ctx->subtype & EVENT_CALL_INCOMING
3244 && tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF)
3253 EmpathyMessage *msg = empathy_message_from_tpl_log_event (event);
3254 log_window_append_message (event, msg);
3255 tp_clear_object (&msg);
3258 g_object_unref (event);
3260 g_list_free (events);
3262 model = GTK_TREE_MODEL (log_window->priv->store_events);
3263 n = gtk_tree_model_iter_n_children (model, NULL) - 1;
3265 if (n >= 0 && gtk_tree_model_iter_nth_child (model, &iter, NULL, n))
3270 path = gtk_tree_model_get_path (model, &iter);
3271 str = gtk_tree_path_to_string (path);
3273 script = g_strdup_printf ("javascript:scrollToRow([%s]);",
3274 g_strdelimit (str, ":", ','));
3276 webkit_web_view_execute_script (
3277 WEBKIT_WEB_VIEW (log_window->priv->webview),
3280 gtk_tree_path_free (path);
3288 _tpl_action_chain_continue (log_window->priv->chain);
3292 get_events_for_date (TplActionChain *chain, gpointer user_data)
3294 Ctx *ctx = user_data;
3296 tpl_log_manager_get_events_for_date_async (ctx->self->priv->log_manager,
3297 ctx->account, ctx->entity, ctx->event_mask,
3299 log_window_got_messages_for_date_cb,
3304 log_window_get_messages_for_dates (EmpathyLogWindow *self,
3307 GList *accounts, *targets, *acc, *targ, *l;
3308 TplEventTypeMask event_mask;
3309 EventSubtype subtype;
3310 GDate *date, *anytime, *separator;
3312 if (!log_window_get_selected (self,
3313 &accounts, &targets, NULL, NULL, &event_mask, &subtype))
3316 anytime = g_date_new_dmy (2, 1, -1);
3317 separator = g_date_new_dmy (1, 1, -1);
3319 _tpl_action_chain_clear (self->priv->chain);
3320 self->priv->count++;
3322 for (acc = accounts, targ = targets;
3323 acc != NULL && targ != NULL;
3324 acc = acc->next, targ = targ->next)
3326 TpAccount *account = acc->data;
3327 TplEntity *target = targ->data;
3329 for (l = dates; l != NULL; l = l->next)
3334 if (g_date_compare (date, anytime) != 0)
3338 ctx = ctx_new (self, account, target, date, event_mask, subtype,
3340 _tpl_action_chain_append (self->priv->chain, get_events_for_date, ctx);
3344 GtkTreeView *view = GTK_TREE_VIEW (self->priv->treeview_when);
3345 GtkTreeModel *model = gtk_tree_view_get_model (view);
3350 for (next = gtk_tree_model_get_iter_first (model, &iter);
3352 next = gtk_tree_model_iter_next (model, &iter))
3356 gtk_tree_model_get (model, &iter,
3360 if (g_date_compare (d, anytime) != 0 &&
3361 g_date_compare (d, separator) != 0)
3363 ctx = ctx_new (self, account, target, d,
3364 event_mask, subtype, self->priv->count);
3365 _tpl_action_chain_append (self->priv->chain, get_events_for_date, ctx);
3375 _tpl_action_chain_start (self->priv->chain);
3377 g_list_free_full (accounts, g_object_unref);
3378 g_list_free_full (targets, g_object_unref);
3379 g_date_free (separator);
3380 g_date_free (anytime);
3384 log_manager_got_dates_cb (GObject *manager,
3385 GAsyncResult *result,
3388 Ctx *ctx = user_data;
3390 GtkTreeModel *model;
3391 GtkListStore *store;
3395 GError *error = NULL;
3397 if (log_window == NULL)
3403 if (log_window->priv->count != ctx->count)
3406 if (!tpl_log_manager_get_dates_finish (TPL_LOG_MANAGER (manager),
3407 result, &dates, &error))
3409 DEBUG ("Unable to retrieve messages' dates: %s. Aborting",
3414 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
3415 model = gtk_tree_view_get_model (view);
3416 store = GTK_LIST_STORE (model);
3418 for (l = dates; l != NULL; l = l->next)
3420 add_date_if_needed (log_window, l->data);
3423 if (gtk_tree_model_get_iter_first (model, &iter))
3425 gchar *separator = NULL;
3427 if (gtk_tree_model_iter_next (model, &iter))
3429 gtk_tree_model_get (model, &iter,
3430 COL_WHEN_TEXT, &separator,
3434 if (g_strcmp0 (separator, "separator") != 0)
3438 date = g_date_new_dmy (1, 1, -1);
3440 gtk_list_store_prepend (store, &iter);
3441 gtk_list_store_set (store, &iter,
3442 COL_WHEN_DATE, date,
3443 COL_WHEN_TEXT, "separator",
3448 date = g_date_new_dmy (2, 1, -1);
3450 gtk_list_store_prepend (store, &iter);
3451 gtk_list_store_set (store, &iter,
3452 COL_WHEN_DATE, date,
3453 COL_WHEN_TEXT, _("Anytime"),
3462 g_list_free_full (dates, g_free);
3465 _tpl_action_chain_continue (log_window->priv->chain);
3469 select_date (TplActionChain *chain, gpointer user_data)
3472 GtkTreeModel *model;
3473 GtkTreeSelection *selection;
3476 gboolean selected = FALSE;
3478 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
3479 model = gtk_tree_view_get_model (view);
3480 selection = gtk_tree_view_get_selection (view);
3482 if (log_window->priv->current_dates != NULL)
3484 for (next = gtk_tree_model_get_iter_first (model, &iter);
3486 next = gtk_tree_model_iter_next (model, &iter))
3490 gtk_tree_model_get (model, &iter,
3491 COL_WHEN_DATE, &date,
3494 if (g_list_find_custom (log_window->priv->current_dates, date,
3495 (GCompareFunc) g_date_compare) != NULL)
3499 gtk_tree_selection_select_iter (selection, &iter);
3500 path = gtk_tree_model_get_path (model, &iter);
3501 gtk_tree_view_scroll_to_cell (view, path, NULL, FALSE, 0, 0);
3504 gtk_tree_path_free (path);
3513 /* Show messages of the most recent date */
3514 if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 2))
3515 gtk_tree_selection_select_iter (selection, &iter);
3518 _tpl_action_chain_continue (log_window->priv->chain);
3522 get_dates_for_entity (TplActionChain *chain, gpointer user_data)
3524 Ctx *ctx = user_data;
3526 tpl_log_manager_get_dates_async (ctx->self->priv->log_manager,
3527 ctx->account, ctx->entity, ctx->event_mask,
3528 log_manager_got_dates_cb, ctx);
3532 log_window_chats_get_messages (EmpathyLogWindow *self,
3533 gboolean force_get_dates)
3535 GList *accounts, *targets, *dates;
3536 TplEventTypeMask event_mask;
3538 GtkTreeModel *model;
3539 GtkListStore *store;
3540 GtkTreeSelection *selection;
3542 if (!log_window_get_selected (self, &accounts, &targets, NULL,
3543 &dates, &event_mask, NULL))
3546 view = GTK_TREE_VIEW (self->priv->treeview_when);
3547 selection = gtk_tree_view_get_selection (view);
3548 model = gtk_tree_view_get_model (view);
3549 store = GTK_LIST_STORE (model);
3551 /* Clear all current messages shown in the textview */
3552 gtk_tree_store_clear (self->priv->store_events);
3554 _tpl_action_chain_clear (self->priv->chain);
3555 self->priv->count++;
3557 /* If there's a search use the returned hits */
3558 if (self->priv->hits != NULL)
3560 if (force_get_dates)
3562 g_signal_handlers_block_by_func (selection,
3563 log_window_when_changed_cb,
3566 gtk_list_store_clear (store);
3568 g_signal_handlers_unblock_by_func (selection,
3569 log_window_when_changed_cb,
3572 populate_dates_from_search_hits (accounts, targets);
3576 populate_events_from_search_hits (accounts, targets, dates);
3579 /* Either use the supplied date or get the last */
3580 else if (force_get_dates || dates == NULL)
3584 if (self->priv->current_dates != NULL)
3586 g_list_free_full (self->priv->current_dates,
3587 (GDestroyNotify) g_date_free);
3588 self->priv->current_dates = NULL;
3591 if (gtk_tree_selection_count_selected_rows (selection) > 0)
3596 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
3598 for (l = paths; l != NULL; l = l->next)
3600 GtkTreePath *path = l->data;
3603 gtk_tree_model_get_iter (model, &iter, path);
3604 gtk_tree_model_get (model, &iter,
3605 COL_WHEN_DATE, &date,
3608 /* The list takes ownership of the date. */
3609 self->priv->current_dates =
3610 g_list_prepend (self->priv->current_dates, date);
3613 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
3616 g_signal_handlers_block_by_func (selection,
3617 log_window_when_changed_cb,
3620 gtk_list_store_clear (store);
3622 g_signal_handlers_unblock_by_func (selection,
3623 log_window_when_changed_cb,
3626 /* Get a list of dates and show them on the treeview */
3627 for (targ = targets, acc = accounts;
3628 targ != NULL && acc != NULL;
3629 targ = targ->next, acc = acc->next)
3631 TpAccount *account = acc->data;
3632 TplEntity *target = targ->data;
3633 Ctx *ctx = ctx_new (self, account, target, NULL, event_mask, 0,
3636 _tpl_action_chain_append (self->priv->chain, get_dates_for_entity, ctx);
3638 _tpl_action_chain_append (self->priv->chain, select_date, NULL);
3639 _tpl_action_chain_start (self->priv->chain);
3643 /* Show messages of the selected date */
3644 log_window_get_messages_for_dates (self, dates);
3647 g_list_free_full (accounts, g_object_unref);
3648 g_list_free_full (targets, g_object_unref);
3649 g_list_free_full (dates, (GFreeFunc) g_date_free);
3653 EmpathyAccountChooserFilterResultCallback callback;
3655 } FilterCallbackData;
3658 got_entities (GObject *manager,
3659 GAsyncResult *result,
3662 FilterCallbackData *data = user_data;
3664 GError *error = NULL;
3666 if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager),
3667 result, &entities, &error))
3669 DEBUG ("Could not get entities: %s", error->message);
3670 g_error_free (error);
3671 data->callback (FALSE, data->user_data);
3675 data->callback (entities != NULL, data->user_data);
3677 g_list_free_full (entities, g_object_unref);
3680 g_slice_free (FilterCallbackData, data);
3684 empathy_account_chooser_filter_has_logs (TpAccount *account,
3685 EmpathyAccountChooserFilterResultCallback callback,
3686 gpointer callback_data,
3689 TplLogManager *manager = tpl_log_manager_dup_singleton ();
3690 FilterCallbackData *cb_data = g_slice_new0 (FilterCallbackData);
3692 cb_data->callback = callback;
3693 cb_data->user_data = callback_data;
3695 tpl_log_manager_get_entities_async (manager, account, got_entities, cb_data);
3697 g_object_unref (manager);
3701 log_window_logger_clear_account_cb (TpProxy *proxy,
3702 const GError *error,
3704 GObject *weak_object)
3706 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (user_data);
3709 g_warning ("Error when clearing logs: %s", error->message);
3711 /* Refresh the log viewer so the logs are cleared if the account
3712 * has been deleted */
3713 gtk_tree_store_clear (self->priv->store_events);
3714 log_window_who_populate (self);
3716 /* Re-filter the account chooser so the accounts without logs get
3718 empathy_account_chooser_refilter (
3719 EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser));
3723 log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem,
3724 EmpathyLogWindow *self)
3726 GtkWidget *dialog, *content_area, *hbox, *label;
3727 EmpathyAccountChooser *account_chooser;
3731 GError *error = NULL;
3733 account_chooser = (EmpathyAccountChooser *) empathy_account_chooser_new ();
3734 empathy_account_chooser_set_has_all_option (account_chooser, TRUE);
3736 empathy_account_chooser_refilter (account_chooser);
3738 /* Select the same account as in the history window */
3739 empathy_account_chooser_set_account (account_chooser,
3740 empathy_account_chooser_get_account (
3741 EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser)));
3743 dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (self),
3744 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING,
3746 _("Are you sure you want to delete all logs of previous conversations?"));
3748 gtk_dialog_add_buttons (GTK_DIALOG (dialog),
3749 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
3750 _("Clear All"), GTK_RESPONSE_APPLY,
3753 content_area = gtk_message_dialog_get_message_area (
3754 GTK_MESSAGE_DIALOG (dialog));
3756 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
3757 label = gtk_label_new (_("Delete from:"));
3758 gtk_box_pack_start (GTK_BOX (hbox), label,
3760 gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (account_chooser),
3762 gtk_box_pack_start (GTK_BOX (content_area), hbox,
3765 gtk_widget_show_all (hbox);
3767 response_id = gtk_dialog_run (GTK_DIALOG (dialog));
3769 if (response_id != GTK_RESPONSE_APPLY)
3772 bus = tp_dbus_daemon_dup (&error);
3775 g_warning ("Could not delete logs: %s", error->message);
3776 g_error_free (error);
3780 logger = g_object_new (TP_TYPE_PROXY,
3781 "bus-name", "org.freedesktop.Telepathy.Logger",
3782 "object-path", "/org/freedesktop/Telepathy/Logger",
3785 g_object_unref (bus);
3787 tp_proxy_add_interface_by_id (logger, EMP_IFACE_QUARK_LOGGER);
3789 if (empathy_account_chooser_has_all_selected (account_chooser))
3791 DEBUG ("Deleting logs for all the accounts");
3793 emp_cli_logger_call_clear (logger, -1,
3794 log_window_logger_clear_account_cb,
3795 self, NULL, G_OBJECT (self));
3801 account = empathy_account_chooser_get_account (account_chooser);
3803 DEBUG ("Deleting logs for %s", tp_proxy_get_object_path (account));
3805 emp_cli_logger_call_clear_account (logger, -1,
3806 tp_proxy_get_object_path (account),
3807 log_window_logger_clear_account_cb,
3808 self, NULL, G_OBJECT (self));
3811 g_object_unref (logger);
3813 gtk_widget_destroy (dialog);