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>
31 #include "action-chain-internal.h"
32 #include "empathy-account-chooser.h"
33 #include "empathy-call-utils.h"
34 #include "empathy-camera-monitor.h"
35 #include "empathy-geometry.h"
36 #include "empathy-gsettings.h"
37 #include "empathy-images.h"
38 #include "empathy-individual-information-dialog.h"
39 #include "empathy-request-util.h"
40 #include "empathy-theme-manager.h"
41 #include "empathy-ui-utils.h"
42 #include "empathy-utils.h"
43 #include "empathy-webkit-utils.h"
44 #include "extensions.h"
46 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
47 #include "empathy-debug.h"
49 #define EMPATHY_NS "http://live.gnome.org/Empathy"
51 G_DEFINE_TYPE (EmpathyLogWindow, empathy_log_window, GTK_TYPE_WINDOW);
53 struct _EmpathyLogWindowPriv
57 GtkWidget *button_profile;
58 GtkWidget *button_chat;
59 GtkWidget *button_call;
60 GtkWidget *button_video;
62 GtkWidget *search_entry;
67 GtkWidget *treeview_who;
68 GtkWidget *treeview_what;
69 GtkWidget *treeview_when;
72 GtkTreeStore *store_events;
74 GtkWidget *account_chooser;
78 /* List of selected GDates, free with g_list_free_full (l, g_date_free) */
81 TplActionChain *chain;
82 TplLogManager *log_manager;
84 /* Hash of TpChannel<->TpAccount for use by the observer until we can
85 * get a TpAccount from a TpConnection or wherever */
87 TpBaseClient *observer;
89 EmpathyContact *selected_contact;
90 EmpathyContact *events_contact;
92 EmpathyCameraMonitor *camera_monitor;
93 GBinding *button_video_binding;
95 /* Used to cancel logger calls when no longer needed */
98 /* List of owned TplLogSearchHits, free with tpl_log_search_hit_free */
102 /* Only used while waiting for the account chooser to be ready */
103 TpAccount *selected_account;
104 gchar *selected_chat_id;
105 gboolean selected_is_chatroom;
107 GSettings *gsettings_chat;
108 GSettings *gsettings_desktop;
111 static void log_window_search_entry_changed_cb (GtkWidget *entry,
112 EmpathyLogWindow *self);
113 static void log_window_search_entry_activate_cb (GtkWidget *widget,
114 EmpathyLogWindow *self);
115 static void log_window_search_entry_icon_pressed_cb (GtkEntry *entry,
116 GtkEntryIconPosition icon_pos,
119 static void log_window_who_populate (EmpathyLogWindow *self);
120 static void log_window_who_setup (EmpathyLogWindow *self);
121 static void log_window_when_setup (EmpathyLogWindow *self);
122 static void log_window_what_setup (EmpathyLogWindow *self);
123 static void log_window_events_setup (EmpathyLogWindow *self);
124 static void log_window_chats_accounts_changed_cb (GtkWidget *combobox,
125 EmpathyLogWindow *self);
126 static void log_window_chats_set_selected (EmpathyLogWindow *self);
127 static void log_window_chats_get_messages (EmpathyLogWindow *self,
128 gboolean force_get_dates);
129 static void log_window_when_changed_cb (GtkTreeSelection *selection,
130 EmpathyLogWindow *self);
131 static void log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem,
132 EmpathyLogWindow *self);
133 static void start_spinner (void);
135 static void log_window_create_observer (EmpathyLogWindow *window);
136 static gboolean log_window_events_button_press_event (GtkWidget *webview,
137 GdkEventButton *event, EmpathyLogWindow *self);
138 static void log_window_update_buttons_sensitivity (EmpathyLogWindow *self);
141 empathy_account_chooser_filter_has_logs (TpAccount *account,
142 EmpathyAccountChooserFilterResultCallback callback,
143 gpointer callback_data,
165 COL_WHO_NAME_SORT_KEY,
194 COL_EVENTS_PRETTY_DATE,
203 #define CALENDAR_ICON "stock_calendar"
205 /* Seconds between two messages to be considered one conversation */
206 #define MAX_GAP 30*60
208 #define WHAT_TYPE_SEPARATOR -1
212 EVENT_CALL_INCOMING = 1 << 0,
213 EVENT_CALL_OUTGOING = 1 << 1,
214 EVENT_CALL_MISSED = 1 << 2,
215 EVENT_CALL_ALL = 1 << 3,
219 log_window_get_selected (EmpathyLogWindow *window,
224 TplEventTypeMask *event_mask,
225 EventSubtype *subtype);
227 static EmpathyLogWindow *log_window = NULL;
229 static gboolean has_element;
232 #define _date_copy(d) g_date_new_julian (g_date_get_julian (d))
237 EmpathyLogWindow *self;
241 TplEventTypeMask event_mask;
242 EventSubtype subtype;
247 ctx_new (EmpathyLogWindow *self,
251 TplEventTypeMask event_mask,
252 EventSubtype subtype,
255 Ctx *ctx = g_slice_new0 (Ctx);
259 ctx->account = g_object_ref (account);
261 ctx->entity = g_object_ref (entity);
263 ctx->date = _date_copy (date);
264 ctx->event_mask = event_mask;
265 ctx->subtype = subtype;
274 tp_clear_object (&ctx->account);
275 tp_clear_object (&ctx->entity);
276 tp_clear_pointer (&ctx->date, g_date_free);
278 g_slice_free (Ctx, ctx);
282 select_account_once_ready (EmpathyLogWindow *self,
284 const gchar *chat_id,
285 gboolean is_chatroom)
287 EmpathyAccountChooser *account_chooser;
289 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
291 tp_clear_object (&self->priv->selected_account);
292 self->priv->selected_account = g_object_ref (account);
294 g_free (self->priv->selected_chat_id);
295 self->priv->selected_chat_id = g_strdup (chat_id);
297 self->priv->selected_is_chatroom = is_chatroom;
299 empathy_account_chooser_set_account (account_chooser,
300 self->priv->selected_account);
304 toolbutton_profile_clicked (GtkToolButton *toolbutton,
305 EmpathyLogWindow *self)
307 FolksIndividual *individual;
309 g_return_if_fail (self != NULL);
310 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
312 individual = empathy_ensure_individual_from_tp_contact (
313 empathy_contact_get_tp_contact (self->priv->selected_contact));
315 empathy_display_individual_info (individual);
317 g_object_unref (individual);
321 toolbutton_chat_clicked (GtkToolButton *toolbutton,
322 EmpathyLogWindow *self)
324 g_return_if_fail (self != NULL);
325 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
327 empathy_chat_with_contact (self->priv->selected_contact,
328 gtk_get_current_event_time ());
332 toolbutton_av_clicked (GtkToolButton *toolbutton,
333 EmpathyLogWindow *self)
337 g_return_if_fail (self != NULL);
338 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
340 video = (GTK_WIDGET (toolbutton) == self->priv->button_video);
342 empathy_call_new_with_streams (
343 empathy_contact_get_id (self->priv->selected_contact),
344 empathy_contact_get_account (self->priv->selected_contact),
345 TRUE, video, gtk_get_current_event_time ());
349 insert_or_change_row (EmpathyLogWindow *self,
355 char *str = gtk_tree_path_to_string (path);
356 char *script, *text, *date, *stock_icon;
359 gtk_tree_model_get (model, iter,
360 COL_EVENTS_TEXT, &text,
361 COL_EVENTS_PRETTY_DATE, &date,
362 COL_EVENTS_ICON, &stock_icon,
365 if (!tp_str_empty (stock_icon))
367 GtkIconInfo *icon_info = gtk_icon_theme_lookup_icon (
368 gtk_icon_theme_get_default (),
370 GTK_ICON_SIZE_MENU, 0);
372 if (icon_info != NULL)
373 icon = g_strdup (gtk_icon_info_get_filename (icon_info));
375 gtk_icon_info_free (icon_info);
378 script = g_strdup_printf ("javascript:%s([%s], '%s', '%s', '%s');",
380 g_strdelimit (str, ":", ','),
382 icon != NULL ? icon : "",
385 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
397 store_events_row_inserted (GtkTreeModel *model,
400 EmpathyLogWindow *self)
402 insert_or_change_row (self, "insertRow", model, path, iter);
406 store_events_row_changed (GtkTreeModel *model,
409 EmpathyLogWindow *self)
411 insert_or_change_row (self, "changeRow", model, path, iter);
415 store_events_row_deleted (GtkTreeModel *model,
417 EmpathyLogWindow *self)
419 char *str = gtk_tree_path_to_string (path);
422 script = g_strdup_printf ("javascript:deleteRow([%s]);",
423 g_strdelimit (str, ":", ','));
425 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
433 store_events_has_child_rows (GtkTreeModel *model,
436 EmpathyLogWindow *self)
438 char *str = gtk_tree_path_to_string (path);
441 script = g_strdup_printf ("javascript:hasChildRows([%s], %u);",
442 g_strdelimit (str, ":", ','),
443 gtk_tree_model_iter_has_child (model, iter));
445 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
453 store_events_rows_reordered (GtkTreeModel *model,
457 EmpathyLogWindow *self)
459 char *str = gtk_tree_path_to_string (path);
460 int i, children = gtk_tree_model_iter_n_children (model, iter);
461 char **new_order_strv, *new_order_s;
464 new_order_strv = g_new0 (char *, children + 1);
466 for (i = 0; i < children; i++)
467 new_order_strv[i] = g_strdup_printf ("%i", new_order[i]);
469 new_order_s = g_strjoinv (",", new_order_strv);
471 script = g_strdup_printf ("javascript:reorderRows([%s], [%s]);",
472 str == NULL ? "" : g_strdelimit (str, ":", ','),
475 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
480 g_free (new_order_s);
481 g_strfreev (new_order_strv);
485 events_webview_handle_navigation (WebKitWebView *webview,
486 WebKitWebFrame *frame,
487 WebKitNetworkRequest *request,
488 WebKitWebNavigationAction *navigation_action,
489 WebKitWebPolicyDecision *policy_decision,
490 EmpathyLogWindow *window)
492 empathy_url_show (GTK_WIDGET (webview),
493 webkit_network_request_get_uri (request));
495 webkit_web_policy_decision_ignore (policy_decision);
500 empathy_log_window_constructor (GType type,
502 GObjectConstructParam *props)
506 if (log_window != NULL)
508 retval = (GObject *) log_window;
512 retval = G_OBJECT_CLASS (empathy_log_window_parent_class)
513 ->constructor (type, n_props, props);
515 log_window = EMPATHY_LOG_WINDOW (retval);
516 g_object_add_weak_pointer (retval, (gpointer) &log_window);
523 empathy_log_window_dispose (GObject *object)
525 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (object);
527 if (self->priv->source != 0)
529 g_source_remove (self->priv->source);
530 self->priv->source = 0;
533 if (self->priv->current_dates != NULL)
535 g_list_free_full (self->priv->current_dates,
536 (GDestroyNotify) g_date_free);
537 self->priv->current_dates = NULL;
540 tp_clear_pointer (&self->priv->chain, _tpl_action_chain_free);
541 tp_clear_pointer (&self->priv->channels, g_hash_table_unref);
543 tp_clear_object (&self->priv->observer);
544 tp_clear_object (&self->priv->log_manager);
545 tp_clear_object (&self->priv->selected_account);
546 tp_clear_object (&self->priv->selected_contact);
547 tp_clear_object (&self->priv->events_contact);
548 tp_clear_object (&self->priv->camera_monitor);
550 tp_clear_object (&self->priv->gsettings_chat);
551 tp_clear_object (&self->priv->gsettings_desktop);
553 tp_clear_object (&self->priv->store_events);
555 G_OBJECT_CLASS (empathy_log_window_parent_class)->dispose (object);
559 empathy_log_window_finalize (GObject *object)
561 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (object);
563 g_free (self->priv->last_find);
564 g_free (self->priv->selected_chat_id);
566 G_OBJECT_CLASS (empathy_log_window_parent_class)->finalize (object);
570 empathy_log_window_class_init (
571 EmpathyLogWindowClass *empathy_log_window_class)
573 GObjectClass *object_class = G_OBJECT_CLASS (empathy_log_window_class);
575 g_type_class_add_private (empathy_log_window_class,
576 sizeof (EmpathyLogWindowPriv));
578 object_class->constructor = empathy_log_window_constructor;
579 object_class->dispose = empathy_log_window_dispose;
580 object_class->finalize = empathy_log_window_finalize;
584 empathy_log_window_init (EmpathyLogWindow *self)
586 EmpathyAccountChooser *account_chooser;
590 GtkWidget *vbox, *accounts, *search, *label, *closeitem;
591 GtkWidget *scrolledwindow_events;
594 self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
595 EMPATHY_TYPE_LOG_WINDOW, EmpathyLogWindowPriv);
597 self->priv->chain = _tpl_action_chain_new_async (NULL, NULL, NULL);
599 self->priv->camera_monitor = empathy_camera_monitor_dup_singleton ();
601 self->priv->log_manager = tpl_log_manager_dup_singleton ();
603 self->priv->gsettings_chat = g_settings_new (EMPATHY_PREFS_CHAT_SCHEMA);
604 self->priv->gsettings_desktop = g_settings_new (
605 EMPATHY_PREFS_DESKTOP_INTERFACE_SCHEMA);
607 gtk_window_set_title (GTK_WINDOW (self), _("History"));
608 gtk_widget_set_can_focus (GTK_WIDGET (self), FALSE);
609 gtk_window_set_default_size (GTK_WINDOW (self), 800, 600);
611 filename = empathy_file_lookup ("empathy-log-window.ui", "libempathy-gtk");
612 gui = empathy_builder_get_file (filename,
613 "vbox1", &self->priv->vbox,
614 "toolbutton_profile", &self->priv->button_profile,
615 "toolbutton_chat", &self->priv->button_chat,
616 "toolbutton_call", &self->priv->button_call,
617 "toolbutton_video", &self->priv->button_video,
618 "toolbutton_accounts", &accounts,
619 "toolbutton_search", &search,
620 "imagemenuitem_close", &closeitem,
621 "treeview_who", &self->priv->treeview_who,
622 "treeview_what", &self->priv->treeview_what,
623 "treeview_when", &self->priv->treeview_when,
624 "scrolledwindow_events", &scrolledwindow_events,
625 "notebook", &self->priv->notebook,
626 "spinner", &self->priv->spinner,
630 empathy_builder_connect (gui, self,
631 "toolbutton_profile", "clicked", toolbutton_profile_clicked,
632 "toolbutton_chat", "clicked", toolbutton_chat_clicked,
633 "toolbutton_call", "clicked", toolbutton_av_clicked,
634 "toolbutton_video", "clicked", toolbutton_av_clicked,
635 "imagemenuitem_delete", "activate", log_window_delete_menu_clicked_cb,
638 gtk_container_add (GTK_CONTAINER (self), self->priv->vbox);
640 g_object_unref (gui);
642 g_signal_connect_swapped (closeitem, "activate",
643 G_CALLBACK (gtk_widget_destroy), self);
645 /* Account chooser for chats */
646 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
648 self->priv->account_chooser = empathy_account_chooser_new ();
649 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
650 empathy_account_chooser_set_has_all_option (account_chooser, TRUE);
651 empathy_account_chooser_set_filter (account_chooser,
652 empathy_account_chooser_filter_has_logs, NULL);
653 empathy_account_chooser_set_all (account_chooser);
655 gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->account_chooser),
656 GTK_STYLE_CLASS_RAISED);
658 g_signal_connect (self->priv->account_chooser, "changed",
659 G_CALLBACK (log_window_chats_accounts_changed_cb),
662 label = gtk_label_new (_("Show"));
664 gtk_box_pack_start (GTK_BOX (vbox),
665 self->priv->account_chooser,
668 gtk_box_pack_start (GTK_BOX (vbox),
672 gtk_widget_show_all (vbox);
673 gtk_container_add (GTK_CONTAINER (accounts), vbox);
676 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
678 self->priv->search_entry = gtk_entry_new ();
679 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
680 GTK_ENTRY_ICON_SECONDARY, "edit-find-symbolic");
681 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
682 GTK_ENTRY_ICON_SECONDARY, FALSE);
684 label = gtk_label_new (_("Search"));
686 gtk_box_pack_start (GTK_BOX (vbox),
687 self->priv->search_entry,
690 gtk_box_pack_start (GTK_BOX (vbox),
694 gtk_widget_show_all (vbox);
695 gtk_container_add (GTK_CONTAINER (search), vbox);
697 g_signal_connect (self->priv->search_entry, "changed",
698 G_CALLBACK (log_window_search_entry_changed_cb),
701 g_signal_connect (self->priv->search_entry, "activate",
702 G_CALLBACK (log_window_search_entry_activate_cb),
705 g_signal_connect (self->priv->search_entry, "icon-press",
706 G_CALLBACK (log_window_search_entry_icon_pressed_cb),
710 log_window_events_setup (self);
711 log_window_who_setup (self);
712 log_window_what_setup (self);
713 log_window_when_setup (self);
715 log_window_create_observer (self);
717 log_window_who_populate (self);
720 self->priv->webview = webkit_web_view_new ();
721 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow_events),
722 GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
723 gtk_container_add (GTK_CONTAINER (scrolledwindow_events),
724 self->priv->webview);
725 gtk_widget_show (self->priv->webview);
727 empathy_webkit_bind_font_setting (WEBKIT_WEB_VIEW (self->priv->webview),
728 self->priv->gsettings_desktop,
729 EMPATHY_PREFS_DESKTOP_INTERFACE_FONT_NAME);
731 filename = empathy_file_lookup ("empathy-log-window.html", "data");
732 gfile = g_file_new_for_path (filename);
735 uri = g_file_get_uri (gfile);
736 webkit_web_view_load_uri (WEBKIT_WEB_VIEW (self->priv->webview), uri);
737 g_object_unref (gfile);
740 /* handle all navigation externally */
741 g_signal_connect (self->priv->webview, "navigation-policy-decision-requested",
742 G_CALLBACK (events_webview_handle_navigation), self);
744 /* listen to changes to the treemodel */
745 g_signal_connect (self->priv->store_events, "row-inserted",
746 G_CALLBACK (store_events_row_inserted), self);
747 g_signal_connect (self->priv->store_events, "row-changed",
748 G_CALLBACK (store_events_row_changed), self);
749 g_signal_connect (self->priv->store_events, "row-deleted",
750 G_CALLBACK (store_events_row_deleted), self);
751 g_signal_connect (self->priv->store_events, "rows-reordered",
752 G_CALLBACK (store_events_rows_reordered), self);
753 g_signal_connect (self->priv->store_events, "row-has-child-toggled",
754 G_CALLBACK (store_events_has_child_rows), self);
756 /* track clicked row */
757 g_signal_connect (self->priv->webview, "button-press-event",
758 G_CALLBACK (log_window_events_button_press_event), self);
760 log_window_update_buttons_sensitivity (self);
761 gtk_widget_show (GTK_WIDGET (self));
763 empathy_geometry_bind (GTK_WINDOW (self), "log-window");
767 empathy_log_window_show (TpAccount *account,
768 const gchar *chat_id,
769 gboolean is_chatroom,
772 log_window = g_object_new (EMPATHY_TYPE_LOG_WINDOW, NULL);
774 gtk_window_present (GTK_WINDOW (log_window));
776 if (account != NULL && chat_id != NULL)
777 select_account_once_ready (log_window, account, chat_id, is_chatroom);
780 gtk_window_set_transient_for (GTK_WINDOW (log_window),
781 GTK_WINDOW (parent));
783 return GTK_WIDGET (log_window);
787 account_equal (TpAccount *a,
790 return g_str_equal (tp_proxy_get_object_path (a),
791 tp_proxy_get_object_path (b));
795 entity_equal (TplEntity *a,
798 return g_str_equal (tpl_entity_get_identifier (a),
799 tpl_entity_get_identifier (b));
803 is_same_confroom (TplEvent *e1,
806 TplEntity *sender1 = tpl_event_get_sender (e1);
807 TplEntity *receiver1 = tpl_event_get_receiver (e1);
808 TplEntity *sender2 = tpl_event_get_sender (e2);
809 TplEntity *receiver2 = tpl_event_get_receiver (e2);
810 TplEntity *room1, *room2;
812 if (receiver1 == NULL || receiver2 == NULL)
815 if (tpl_entity_get_entity_type (sender1) == TPL_ENTITY_ROOM)
817 else if (tpl_entity_get_entity_type (receiver1) == TPL_ENTITY_ROOM)
822 if (tpl_entity_get_entity_type (sender2) == TPL_ENTITY_ROOM)
824 else if (tpl_entity_get_entity_type (receiver2) == TPL_ENTITY_ROOM)
829 return g_str_equal (tpl_entity_get_identifier (room1),
830 tpl_entity_get_identifier (room2));
834 maybe_refresh_logs (TpChannel *channel,
837 GList *accounts = NULL, *entities = NULL, *dates = NULL;
839 TplEventTypeMask event_mask;
840 GDate *anytime = NULL, *today = NULL;
841 GDateTime *now = NULL;
842 gboolean refresh = FALSE;
846 if (!log_window_get_selected (log_window,
847 &accounts, &entities, &anyone, &dates, &event_mask, NULL))
849 DEBUG ("Could not get selected rows");
853 type = tp_channel_get_channel_type (channel);
855 /* If the channel type is not in the What pane, whatever has happened
856 * won't be displayed in the events pane. */
857 if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_TEXT) &&
858 !(event_mask & TPL_EVENT_MASK_TEXT))
860 if ((!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA) ||
861 !tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_CALL)) &&
862 !(event_mask & TPL_EVENT_MASK_CALL))
865 anytime = g_date_new_dmy (2, 1, -1);
866 now = g_date_time_new_now_local ();
867 today = g_date_new_dmy (g_date_time_get_day_of_month (now),
868 g_date_time_get_month (now),
869 g_date_time_get_year (now));
871 /* If Today (or anytime) isn't selected, anything that has happened now
872 * won't be displayed. */
873 if (!g_list_find_custom (dates, anytime, (GCompareFunc) g_date_compare) &&
874 !g_list_find_custom (dates, today, (GCompareFunc) g_date_compare))
883 for (acc = accounts, ent = entities;
884 acc != NULL && ent != NULL;
885 acc = g_list_next (acc), ent = g_list_next (ent))
887 if (!account_equal (account, acc->data))
890 if (!tp_strdiff (tp_channel_get_identifier (channel),
891 tpl_entity_get_identifier (ent->data)))
899 tp_clear_pointer (&anytime, g_date_free);
900 tp_clear_pointer (&today, g_date_free);
901 tp_clear_pointer (&now, g_date_time_unref);
902 g_list_free_full (accounts, g_object_unref);
903 g_list_free_full (entities, g_object_unref);
904 g_list_free_full (dates, (GFreeFunc) g_date_free);
908 DEBUG ("Refreshing logs after received event");
910 /* FIXME: We need to populate the entities in case we
911 * didn't have any previous logs with this contact. */
912 log_window_chats_get_messages (log_window, FALSE);
917 on_msg_sent (TpTextChannel *channel,
918 TpSignalledMessage *message,
921 EmpathyLogWindow *self)
923 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
925 maybe_refresh_logs (TP_CHANNEL (channel), account);
929 on_msg_received (TpTextChannel *channel,
930 TpSignalledMessage *message,
931 EmpathyLogWindow *self)
933 TpMessage *msg = TP_MESSAGE (message);
934 TpChannelTextMessageType type = tp_message_get_message_type (msg);
935 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
937 if (type != TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL &&
938 type != TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION)
941 maybe_refresh_logs (TP_CHANNEL (channel), account);
945 on_channel_ended (TpChannel *channel,
949 EmpathyLogWindow *self)
951 if (self->priv->channels != NULL)
952 g_hash_table_remove (self->priv->channels, channel);
956 on_call_ended (TpChannel *channel,
960 EmpathyLogWindow *self)
962 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
964 maybe_refresh_logs (channel, account);
966 if (self->priv->channels != NULL)
967 g_hash_table_remove (self->priv->channels, channel);
971 observe_channels (TpSimpleObserver *observer,
973 TpConnection *connection,
975 TpChannelDispatchOperation *dispatch_operation,
977 TpObserveChannelsContext *context,
980 EmpathyLogWindow *self = user_data;
984 for (l = channels; l != NULL; l = g_list_next (l))
986 TpChannel *channel = l->data;
987 const gchar *type = tp_channel_get_channel_type (channel);
989 if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_TEXT))
991 TpTextChannel *text_channel = TP_TEXT_CHANNEL (channel);
993 g_hash_table_insert (self->priv->channels,
994 g_object_ref (channel), g_object_ref (account));
996 tp_g_signal_connect_object (text_channel, "message-sent",
997 G_CALLBACK (on_msg_sent), self, 0);
998 tp_g_signal_connect_object (text_channel, "message-received",
999 G_CALLBACK (on_msg_received), self, 0);
1000 tp_g_signal_connect_object (channel, "invalidated",
1001 G_CALLBACK (on_channel_ended), self, 0);
1003 else if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_CALL) ||
1004 !tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA))
1006 g_hash_table_insert (self->priv->channels,
1007 g_object_ref (channel), g_object_ref (account));
1009 tp_g_signal_connect_object (channel, "invalidated",
1010 G_CALLBACK (on_call_ended), self, 0);
1014 g_warning ("Unknown channel type: %s", type);
1018 tp_observe_channels_context_accept (context);
1022 log_window_create_observer (EmpathyLogWindow *self)
1024 TpAccountManager *am;
1026 am = tp_account_manager_dup ();
1028 self->priv->observer = tp_simple_observer_new_with_am (am, TRUE, "LogWindow",
1029 TRUE, observe_channels,
1030 g_object_ref (self), g_object_unref);
1032 self->priv->channels = g_hash_table_new_full (g_direct_hash, g_direct_equal,
1033 g_object_unref, g_object_unref);
1035 tp_base_client_take_observer_filter (self->priv->observer,
1037 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1038 TP_IFACE_CHANNEL_TYPE_TEXT,
1040 tp_base_client_take_observer_filter (self->priv->observer,
1042 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1043 TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA,
1045 tp_base_client_take_observer_filter (self->priv->observer,
1047 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1048 TP_IFACE_CHANNEL_TYPE_CALL,
1051 tp_base_client_register (self->priv->observer, NULL);
1053 g_object_unref (am);
1057 event_get_target (TplEvent *event)
1059 TplEntity *sender = tpl_event_get_sender (event);
1060 TplEntity *receiver = tpl_event_get_receiver (event);
1062 if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
1069 model_is_parent (GtkTreeModel *model,
1073 TplEvent *stored_event;
1076 gboolean found = FALSE;
1079 if (gtk_tree_model_iter_parent (model, &parent, iter))
1082 gtk_tree_model_get (model, iter,
1083 COL_EVENTS_ACCOUNT, &account,
1084 COL_EVENTS_TARGET, &target,
1085 COL_EVENTS_EVENT, &stored_event,
1088 if (G_OBJECT_TYPE (event) == G_OBJECT_TYPE (stored_event) &&
1089 account_equal (account, tpl_event_get_account (event)) &&
1090 (entity_equal (target, event_get_target (event)) ||
1091 is_same_confroom (event, stored_event)))
1096 gtk_tree_model_iter_nth_child (model, &child, iter,
1097 gtk_tree_model_iter_n_children (model, iter) - 1);
1099 gtk_tree_model_get (model, &child,
1100 COL_EVENTS_TS, ×tamp,
1103 if (ABS (tpl_event_get_timestamp (event) - timestamp) < MAX_GAP)
1105 /* The gap is smaller than 30 min */
1110 g_object_unref (stored_event);
1111 g_object_unref (account);
1112 g_object_unref (target);
1118 get_display_string_for_chat_message (EmpathyMessage *message,
1121 EmpathyContact *sender, *receiver, *target;
1122 TplEntity *ent_sender, *ent_receiver;
1123 const gchar *format;
1125 sender = empathy_message_get_sender (message);
1126 receiver = empathy_message_get_receiver (message);
1128 ent_sender = tpl_event_get_sender (event);
1129 ent_receiver = tpl_event_get_receiver (event);
1131 /* If this is a MUC, we want to show "Chat in <room>". */
1132 if (tpl_entity_get_entity_type (ent_sender) == TPL_ENTITY_ROOM ||
1133 (ent_receiver != NULL &&
1134 tpl_entity_get_entity_type (ent_receiver) == TPL_ENTITY_ROOM))
1135 format = _("Chat in %s");
1137 format = _("Chat with %s");
1139 if (tpl_entity_get_entity_type (ent_sender) == TPL_ENTITY_ROOM)
1141 else if (ent_receiver != NULL &&
1142 tpl_entity_get_entity_type (ent_receiver) == TPL_ENTITY_ROOM)
1144 else if (empathy_contact_is_user (sender))
1149 return g_markup_printf_escaped (format, empathy_contact_get_alias (target));
1153 get_parent_iter_for_message (TplEvent *event,
1154 EmpathyMessage *message,
1155 GtkTreeIter *parent)
1157 GtkTreeStore *store;
1158 GtkTreeModel *model;
1160 gboolean parent_found = FALSE;
1163 store = log_window->priv->store_events;
1164 model = GTK_TREE_MODEL (store);
1166 for (next = gtk_tree_model_get_iter_first (model, &iter);
1168 next = gtk_tree_model_iter_next (model, &iter))
1170 if ((parent_found = model_is_parent (model, &iter, event)))
1181 gchar *body, *pretty_date;
1183 date = g_date_time_new_from_unix_local (
1184 tpl_event_get_timestamp (event));
1186 pretty_date = g_date_time_format (date,
1187 C_("A date with the time", "%A, %e %B %Y %X"));
1189 body = get_display_string_for_chat_message (message, event);
1191 gtk_tree_store_append (store, &iter, NULL);
1192 gtk_tree_store_set (store, &iter,
1193 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1194 COL_EVENTS_PRETTY_DATE, pretty_date,
1195 COL_EVENTS_TEXT, body,
1196 COL_EVENTS_ICON, "format-justify-fill",
1197 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1198 COL_EVENTS_TARGET, event_get_target (event),
1199 COL_EVENTS_EVENT, event,
1205 g_free (pretty_date);
1206 g_date_time_unref (date);
1210 static const gchar *
1211 get_icon_for_event (TplEvent *event)
1213 const gchar *icon = NULL;
1215 if (TPL_IS_TEXT_EVENT (event))
1217 TplTextEvent *text = TPL_TEXT_EVENT (event);
1219 if (!tp_str_empty (tpl_text_event_get_supersedes_token (text)))
1220 icon = EMPATHY_IMAGE_EDIT_MESSAGE;
1222 else if (TPL_IS_CALL_EVENT (event))
1224 TplCallEvent *call = TPL_CALL_EVENT (event);
1225 TpCallStateChangeReason reason = tpl_call_event_get_end_reason (call);
1226 TplEntity *sender = tpl_event_get_sender (event);
1227 TplEntity *receiver = tpl_event_get_receiver (event);
1229 if (reason == TP_CALL_STATE_CHANGE_REASON_NO_ANSWER)
1230 icon = EMPATHY_IMAGE_CALL_MISSED;
1231 else if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
1232 icon = EMPATHY_IMAGE_CALL_OUTGOING;
1233 else if (tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF)
1234 icon = EMPATHY_IMAGE_CALL_INCOMING;
1241 log_window_append_chat_message (TplEvent *event,
1242 EmpathyMessage *message)
1244 GtkTreeStore *store = log_window->priv->store_events;
1245 GtkTreeIter iter, parent;
1246 gchar *pretty_date, *alias, *body;
1249 EmpathyStringParser *parsers;
1252 date = g_date_time_new_from_unix_local (
1253 tpl_event_get_timestamp (event));
1255 pretty_date = g_date_time_format (date, "%X");
1257 get_parent_iter_for_message (event, message, &parent);
1259 alias = g_markup_escape_text (
1260 tpl_entity_get_alias (tpl_event_get_sender (event)), -1);
1262 /* escape the text */
1263 parsers = empathy_webkit_get_string_parser (
1264 g_settings_get_boolean (log_window->priv->gsettings_chat,
1265 EMPATHY_PREFS_CHAT_SHOW_SMILEYS));
1266 msg = g_string_new ("");
1268 empathy_string_parser_substr (empathy_message_get_body (message), -1,
1271 msg_escaped = g_strescape (msg->str, NULL);
1273 if (tpl_text_event_get_message_type (TPL_TEXT_EVENT (event))
1274 == TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION)
1276 /* Translators: this is an emote: '* Danielle waves' */
1277 body = g_strdup_printf (_("<i>* %s %s</i>"), alias, msg_escaped);
1281 /* Translators: this is a message: 'Danielle: hello'
1282 * The string in bold is the sender's name */
1283 body = g_strdup_printf (_("<b>%s:</b> %s"), alias, msg_escaped);
1286 g_free (msg_escaped);
1288 gtk_tree_store_append (store, &iter, &parent);
1289 gtk_tree_store_set (store, &iter,
1290 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1291 COL_EVENTS_PRETTY_DATE, pretty_date,
1292 COL_EVENTS_TEXT, body,
1293 COL_EVENTS_ICON, get_icon_for_event (event),
1294 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1295 COL_EVENTS_TARGET, event_get_target (event),
1296 COL_EVENTS_EVENT, event,
1299 g_string_free (msg, TRUE);
1302 g_free (pretty_date);
1303 g_date_time_unref (date);
1307 log_window_append_call (TplEvent *event,
1308 EmpathyMessage *message)
1310 TplCallEvent *call = TPL_CALL_EVENT (event);
1311 GtkTreeStore *store = log_window->priv->store_events;
1312 GtkTreeIter iter, child;
1313 gchar *pretty_date, *duration, *finished;
1314 GDateTime *started_date, *finished_date;
1317 /* If searching, only add the call if the search string appears anywhere */
1318 if (!EMP_STR_EMPTY (log_window->priv->last_find))
1320 if (strstr (tpl_entity_get_identifier (tpl_event_get_sender (event)),
1321 log_window->priv->last_find) == NULL &&
1322 strstr (tpl_entity_get_identifier (tpl_event_get_receiver (event)),
1323 log_window->priv->last_find) == NULL &&
1324 strstr (tpl_call_event_get_detailed_end_reason (call),
1325 log_window->priv->last_find) == NULL)
1327 DEBUG ("TplCallEvent doesn't match search string, ignoring");
1332 started_date = g_date_time_new_from_unix_local (
1333 tpl_event_get_timestamp (event));
1335 pretty_date = g_date_time_format (started_date,
1336 C_("A date with the time", "%A, %e %B %Y %X"));
1338 gtk_tree_store_append (store, &iter, NULL);
1339 gtk_tree_store_set (store, &iter,
1340 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1341 COL_EVENTS_PRETTY_DATE, pretty_date,
1342 COL_EVENTS_TEXT, empathy_message_get_body (message),
1343 COL_EVENTS_ICON, get_icon_for_event (event),
1344 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1345 COL_EVENTS_TARGET, event_get_target (event),
1346 COL_EVENTS_EVENT, event,
1349 if (tpl_call_event_get_end_reason (call) != TP_CALL_STATE_CHANGE_REASON_NO_ANSWER)
1354 span = tpl_call_event_get_duration (TPL_CALL_EVENT (event));
1358 tmp = g_strdup_printf ("%" G_GINT64_FORMAT, span);
1359 duration = g_strdup_printf (
1360 ngettext ("%s second", "%s seconds", span), tmp);
1365 tmp = g_strdup_printf ("%" G_GINT64_FORMAT, span / 60);
1366 duration = g_strdup_printf (
1367 ngettext ("%s minute", "%s minutes", span / 60), tmp);
1371 finished_date = g_date_time_add (started_date, -span);
1372 finished = g_date_time_format (finished_date, "%X");
1373 g_date_time_unref (finished_date);
1375 body = g_strdup_printf (_("Call took %s, ended at %s"),
1376 duration, finished);
1381 gtk_tree_store_append (store, &child, &iter);
1382 gtk_tree_store_set (store, &child,
1383 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1384 COL_EVENTS_TEXT, body,
1385 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1386 COL_EVENTS_TARGET, event_get_target (event),
1387 COL_EVENTS_EVENT, event,
1393 g_free (pretty_date);
1394 g_date_time_unref (started_date);
1398 log_window_append_message (TplEvent *event,
1399 EmpathyMessage *message)
1401 if (TPL_IS_TEXT_EVENT (event))
1402 log_window_append_chat_message (event, message);
1403 else if (TPL_IS_CALL_EVENT (event))
1404 log_window_append_call (event, message);
1406 DEBUG ("Message type not handled");
1410 add_all_accounts_and_entities (GList **accounts,
1414 GtkTreeModel *model;
1417 view = GTK_TREE_VIEW (log_window->priv->treeview_who);
1418 model = gtk_tree_view_get_model (view);
1420 if (!gtk_tree_model_get_iter_first (model, &iter))
1429 gtk_tree_model_get (model, &iter,
1430 COL_WHO_ACCOUNT, &account,
1431 COL_WHO_TARGET, &entity,
1432 COL_WHO_TYPE, &type,
1435 if (type != COL_TYPE_NORMAL)
1438 if (accounts != NULL)
1439 *accounts = g_list_append (*accounts, account);
1441 if (entities != NULL)
1442 *entities = g_list_append (*entities, entity);
1444 while (gtk_tree_model_iter_next (model, &iter));
1448 log_window_get_selected (EmpathyLogWindow *self,
1453 TplEventTypeMask *event_mask,
1454 EventSubtype *subtype)
1457 GtkTreeModel *model;
1458 GtkTreeSelection *selection;
1460 TplEventTypeMask ev = 0;
1461 EventSubtype st = 0;
1465 view = GTK_TREE_VIEW (self->priv->treeview_who);
1466 model = gtk_tree_view_get_model (view);
1467 selection = gtk_tree_view_get_selection (view);
1469 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1473 if (accounts != NULL)
1475 if (entities != NULL)
1480 for (l = paths; l != NULL; l = l->next)
1482 GtkTreePath *path = l->data;
1486 gtk_tree_model_get_iter (model, &iter, path);
1487 gtk_tree_model_get (model, &iter,
1488 COL_WHO_ACCOUNT, &account,
1489 COL_WHO_TARGET, &entity,
1490 COL_WHO_TYPE, &type,
1493 if (type == COL_TYPE_ANY)
1495 if (accounts != NULL || entities != NULL)
1496 add_all_accounts_and_entities (accounts, entities);
1502 if (accounts != NULL)
1503 *accounts = g_list_append (*accounts, g_object_ref (account));
1505 if (entities != NULL)
1506 *entities = g_list_append (*entities, g_object_ref (entity));
1508 g_object_unref (account);
1509 g_object_unref (entity);
1511 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1513 view = GTK_TREE_VIEW (self->priv->treeview_what);
1514 model = gtk_tree_view_get_model (view);
1515 selection = gtk_tree_view_get_selection (view);
1517 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1518 for (l = paths; l != NULL; l = l->next)
1520 GtkTreePath *path = l->data;
1521 TplEventTypeMask mask;
1522 EventSubtype submask;
1524 gtk_tree_model_get_iter (model, &iter, path);
1525 gtk_tree_model_get (model, &iter,
1526 COL_WHAT_TYPE, &mask,
1527 COL_WHAT_SUBTYPE, &submask,
1533 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1535 view = GTK_TREE_VIEW (self->priv->treeview_when);
1536 model = gtk_tree_view_get_model (view);
1537 selection = gtk_tree_view_get_selection (view);
1543 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1544 for (l = paths; l != NULL; l = l->next)
1546 GtkTreePath *path = l->data;
1549 gtk_tree_model_get_iter (model, &iter, path);
1550 gtk_tree_model_get (model, &iter,
1551 COL_WHEN_DATE, &date,
1554 *dates = g_list_append (*dates, date);
1556 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1559 if (event_mask != NULL)
1562 if (subtype != NULL)
1569 model_has_entity (GtkTreeModel *model,
1574 TplLogSearchHit *hit = data;
1577 gboolean ret = FALSE;
1579 gtk_tree_model_get (model, iter,
1581 COL_WHO_ACCOUNT, &a,
1584 if (e != NULL && entity_equal (hit->target, e) &&
1585 a != NULL && account_equal (hit->account, a))
1587 ret = has_element = TRUE;
1590 tp_clear_object (&e);
1591 tp_clear_object (&a);
1597 model_has_date (GtkTreeModel *model,
1605 gtk_tree_model_get (model, iter,
1609 if (!g_date_compare (date, d))
1621 get_events_for_date (TplActionChain *chain, gpointer user_data);
1624 populate_events_from_search_hits (GList *accounts,
1628 TplEventTypeMask event_mask;
1629 EventSubtype subtype;
1632 gboolean is_anytime = FALSE;
1634 if (!log_window_get_selected (log_window,
1635 NULL, NULL, NULL, NULL, &event_mask, &subtype))
1638 anytime = g_date_new_dmy (2, 1, -1);
1639 if (g_list_find_custom (dates, anytime, (GCompareFunc) g_date_compare))
1642 for (l = log_window->priv->hits; l != NULL; l = l->next)
1644 TplLogSearchHit *hit = l->data;
1646 gboolean found = FALSE;
1648 /* Protect against invalid data (corrupt or old log files). */
1649 if (hit->account == NULL || hit->target == NULL)
1652 for (acc = accounts, targ = targets;
1653 acc != NULL && targ != NULL && !found;
1654 acc = acc->next, targ = targ->next)
1656 TpAccount *account = acc->data;
1657 TplEntity *target = targ->data;
1659 if (account_equal (hit->account, account) &&
1660 entity_equal (hit->target, target))
1668 g_list_find_custom (dates, hit->date, (GCompareFunc) g_date_compare)
1673 ctx = ctx_new (log_window, hit->account, hit->target, hit->date,
1674 event_mask, subtype, log_window->priv->count);
1675 _tpl_action_chain_append (log_window->priv->chain,
1676 get_events_for_date, ctx);
1681 _tpl_action_chain_start (log_window->priv->chain);
1683 g_date_free (anytime);
1687 format_date_for_display (GDate *date)
1693 /* g_date_strftime sucks */
1695 now = g_date_new ();
1696 g_date_set_time_t (now, time (NULL));
1698 days_elapsed = g_date_days_between (date, now);
1700 if (days_elapsed < 0)
1704 else if (days_elapsed == 0)
1706 text = g_strdup (_("Today"));
1708 else if (days_elapsed == 1)
1710 text = g_strdup (_("Yesterday"));
1716 dt = g_date_time_new_utc (g_date_get_year (date),
1717 g_date_get_month (date), g_date_get_day (date),
1720 if (days_elapsed <= 7)
1721 text = g_date_time_format (dt, "%A");
1723 text = g_date_time_format (dt,
1724 /* Translators: A date such as '23 May 2010' (strftime format) */
1727 g_date_time_unref (dt);
1736 add_date_if_needed (EmpathyLogWindow *self,
1739 GtkTreeModel *model;
1740 GtkListStore *store;
1743 model = gtk_tree_view_get_model (GTK_TREE_VIEW (
1744 log_window->priv->treeview_when));
1745 store = GTK_LIST_STORE (model);
1747 /* Add the date if it's not already there */
1748 has_element = FALSE;
1749 gtk_tree_model_foreach (model, model_has_date, date);
1753 text = format_date_for_display (date);
1755 gtk_list_store_insert_with_values (store, NULL, -1,
1756 COL_WHEN_DATE, date,
1757 COL_WHEN_TEXT, text,
1758 COL_WHEN_ICON, CALENDAR_ICON,
1765 populate_dates_from_search_hits (GList *accounts,
1770 GtkTreeModel *model;
1771 GtkListStore *store;
1772 GtkTreeSelection *selection;
1775 if (log_window == NULL)
1778 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
1779 model = gtk_tree_view_get_model (view);
1780 store = GTK_LIST_STORE (model);
1781 selection = gtk_tree_view_get_selection (view);
1783 for (l = log_window->priv->hits; l != NULL; l = l->next)
1785 TplLogSearchHit *hit = l->data;
1787 gboolean found = FALSE;
1789 /* Protect against invalid data (corrupt or old log files). */
1790 if (hit->account == NULL || hit->target == NULL)
1793 for (acc = accounts, targ = targets;
1794 acc != NULL && targ != NULL && !found;
1795 acc = acc->next, targ = targ->next)
1797 TpAccount *account = acc->data;
1798 TplEntity *target = targ->data;
1800 if (account_equal (hit->account, account) &&
1801 entity_equal (hit->target, target))
1808 add_date_if_needed (log_window, hit->date);
1811 if (gtk_tree_model_get_iter_first (model, &iter))
1815 date = g_date_new_dmy (1, 1, -1),
1817 gtk_list_store_prepend (store, &iter);
1818 gtk_list_store_set (store, &iter,
1819 COL_WHEN_DATE, date,
1820 COL_WHEN_TEXT, "separator",
1825 date = g_date_new_dmy (2, 1, -1),
1826 gtk_list_store_prepend (store, &iter);
1827 gtk_list_store_set (store, &iter,
1828 COL_WHEN_DATE, date,
1829 COL_WHEN_TEXT, _("Anytime"),
1834 if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 2))
1835 gtk_tree_selection_select_iter (selection, &iter);
1840 add_event_to_store (EmpathyLogWindow *self,
1844 GtkListStore *store;
1845 TplEntityType type = tpl_entity_get_entity_type (entity);
1846 EmpathyContact *contact;
1849 gboolean room = type == TPL_ENTITY_ROOM;
1851 store = GTK_LIST_STORE (gtk_tree_view_get_model (
1852 GTK_TREE_VIEW (log_window->priv->treeview_who)));
1854 contact = empathy_contact_from_tpl_contact (account, entity);
1856 name = empathy_contact_get_alias (contact);
1857 sort_key = g_utf8_collate_key (name, -1);
1859 gtk_list_store_insert_with_values (store, NULL, -1,
1860 COL_WHO_TYPE, COL_TYPE_NORMAL,
1861 COL_WHO_ICON, room ? EMPATHY_IMAGE_GROUP_MESSAGE
1862 : EMPATHY_IMAGE_AVATAR_DEFAULT,
1864 COL_WHO_NAME_SORT_KEY, sort_key,
1865 COL_WHO_ID, tpl_entity_get_identifier (entity),
1866 COL_WHO_ACCOUNT, account,
1867 COL_WHO_TARGET, entity,
1871 g_object_unref (contact);
1875 populate_entities_from_search_hits (void)
1877 EmpathyAccountChooser *account_chooser;
1880 GtkTreeModel *model;
1881 GtkTreeSelection *selection;
1883 GtkListStore *store;
1886 view = GTK_TREE_VIEW (log_window->priv->treeview_who);
1887 model = gtk_tree_view_get_model (view);
1888 store = GTK_LIST_STORE (model);
1889 selection = gtk_tree_view_get_selection (view);
1891 gtk_list_store_clear (store);
1893 account_chooser = EMPATHY_ACCOUNT_CHOOSER (log_window->priv->account_chooser);
1894 account = empathy_account_chooser_get_account (account_chooser);
1896 for (l = log_window->priv->hits; l; l = l->next)
1898 TplLogSearchHit *hit = l->data;
1900 /* Protect against invalid data (corrupt or old log files). */
1901 if (hit->account == NULL || hit->target == NULL)
1904 /* Filter based on the selected account */
1905 if (account != NULL && !account_equal (account, hit->account))
1908 /* Add the entity if it's not already there */
1909 has_element = FALSE;
1910 gtk_tree_model_foreach (model, model_has_entity, hit);
1913 add_event_to_store (log_window, hit->account, hit->target);
1917 if (gtk_tree_model_get_iter_first (model, &iter))
1919 gtk_list_store_prepend (store, &iter);
1920 gtk_list_store_set (store, &iter,
1921 COL_WHO_TYPE, COL_TYPE_SEPARATOR,
1922 COL_WHO_NAME, "separator",
1925 gtk_list_store_prepend (store, &iter);
1926 gtk_list_store_set (store, &iter,
1927 COL_WHO_TYPE, COL_TYPE_ANY,
1928 COL_WHO_NAME, _("Anyone"),
1932 /* Select 'Anyone' */
1933 if (gtk_tree_model_get_iter_first (model, &iter))
1934 gtk_tree_selection_select_iter (selection, &iter);
1938 log_manager_searched_new_cb (GObject *manager,
1939 GAsyncResult *result,
1944 GtkTreeSelection *selection;
1945 GError *error = NULL;
1947 if (log_window == NULL)
1950 if (!tpl_log_manager_search_finish (TPL_LOG_MANAGER (manager),
1951 result, &hits, &error))
1953 DEBUG ("%s. Aborting", error->message);
1954 g_error_free (error);
1958 tp_clear_pointer (&log_window->priv->hits, tpl_log_manager_search_free);
1959 log_window->priv->hits = hits;
1961 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
1962 selection = gtk_tree_view_get_selection (view);
1964 g_signal_handlers_unblock_by_func (selection,
1965 log_window_when_changed_cb,
1968 populate_entities_from_search_hits ();
1972 log_window_find_populate (EmpathyLogWindow *self,
1973 const gchar *search_criteria)
1976 GtkTreeModel *model;
1977 GtkTreeSelection *selection;
1978 GtkListStore *store;
1980 gtk_tree_store_clear (self->priv->store_events);
1982 view = GTK_TREE_VIEW (self->priv->treeview_who);
1983 model = gtk_tree_view_get_model (view);
1984 store = GTK_LIST_STORE (model);
1986 gtk_list_store_clear (store);
1988 view = GTK_TREE_VIEW (self->priv->treeview_when);
1989 model = gtk_tree_view_get_model (view);
1990 store = GTK_LIST_STORE (model);
1991 selection = gtk_tree_view_get_selection (view);
1993 gtk_list_store_clear (store);
1995 if (EMP_STR_EMPTY (search_criteria))
1997 tp_clear_pointer (&self->priv->hits, tpl_log_manager_search_free);
1998 webkit_web_view_set_highlight_text_matches (
1999 WEBKIT_WEB_VIEW (self->priv->webview), FALSE);
2000 log_window_who_populate (self);
2004 g_signal_handlers_block_by_func (selection,
2005 log_window_when_changed_cb,
2008 /* highlight the search text */
2009 webkit_web_view_mark_text_matches (WEBKIT_WEB_VIEW (self->priv->webview),
2010 search_criteria, FALSE, 0);
2012 tpl_log_manager_search_async (self->priv->log_manager,
2013 search_criteria, TPL_EVENT_MASK_ANY,
2014 log_manager_searched_new_cb, NULL);
2018 start_find_search (EmpathyLogWindow *self)
2022 str = gtk_entry_get_text (GTK_ENTRY (self->priv->search_entry));
2024 /* Don't find the same crap again */
2025 if (self->priv->last_find && !tp_strdiff (self->priv->last_find, str))
2028 g_free (self->priv->last_find);
2029 self->priv->last_find = g_strdup (str);
2031 log_window_find_populate (self, str);
2037 log_window_search_entry_changed_cb (GtkWidget *entry,
2038 EmpathyLogWindow *self)
2042 str = gtk_entry_get_text (GTK_ENTRY (self->priv->search_entry));
2044 if (!tp_str_empty (str))
2046 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
2047 GTK_ENTRY_ICON_SECONDARY, "edit-clear-symbolic");
2048 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
2049 GTK_ENTRY_ICON_SECONDARY, TRUE);
2053 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
2054 GTK_ENTRY_ICON_SECONDARY, "edit-find-symbolic");
2055 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
2056 GTK_ENTRY_ICON_SECONDARY, FALSE);
2059 if (self->priv->source != 0)
2060 g_source_remove (self->priv->source);
2061 self->priv->source = g_timeout_add (500, (GSourceFunc) start_find_search,
2066 log_window_search_entry_activate_cb (GtkWidget *entry,
2067 EmpathyLogWindow *self)
2069 start_find_search (self);
2073 log_window_search_entry_icon_pressed_cb (GtkEntry *entry,
2074 GtkEntryIconPosition icon_pos,
2078 if (icon_pos != GTK_ENTRY_ICON_SECONDARY)
2081 gtk_entry_buffer_set_text (gtk_entry_get_buffer (entry),
2086 do_update_buttons_sensitivity (EmpathyLogWindow *self)
2088 EmpathyCapabilities capabilities;
2089 gboolean profile, chat, call, video;
2091 tp_clear_object (&self->priv->button_video_binding);
2093 if (self->priv->selected_contact != NULL)
2095 capabilities = empathy_contact_get_capabilities (
2096 self->priv->selected_contact);
2098 profile = chat = TRUE;
2099 call = capabilities & EMPATHY_CAPABILITIES_AUDIO;
2100 video = capabilities & EMPATHY_CAPABILITIES_VIDEO;
2104 profile = chat = call = video = FALSE;
2107 gtk_widget_set_sensitive (self->priv->button_profile, profile);
2108 gtk_widget_set_sensitive (self->priv->button_chat, chat);
2109 gtk_widget_set_sensitive (self->priv->button_call, call);
2113 self->priv->button_video_binding = g_object_bind_property (
2114 self->priv->camera_monitor, "available",
2115 self->priv->button_video, "sensitive",
2116 G_BINDING_SYNC_CREATE);
2120 /* Don't override the binding */
2121 gtk_widget_set_sensitive (self->priv->button_video, video);
2126 contact_capabilities_changed_cb (EmpathyContact *contact,
2128 EmpathyLogWindow *self)
2130 do_update_buttons_sensitivity (self);
2134 log_window_update_buttons_sensitivity (EmpathyLogWindow *self)
2137 GtkTreeModel *model;
2138 GtkTreeSelection *selection;
2145 if (self->priv->selected_contact != NULL)
2147 g_signal_handlers_disconnect_by_func (self->priv->selected_contact,
2148 contact_capabilities_changed_cb, self);
2150 tp_clear_object (&self->priv->selected_contact);
2153 view = GTK_TREE_VIEW (self->priv->treeview_who);
2154 model = gtk_tree_view_get_model (view);
2155 selection = gtk_tree_view_get_selection (view);
2157 if (!gtk_tree_model_get_iter_first (model, &iter))
2160 if (gtk_tree_selection_count_selected_rows (selection) != 1)
2163 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2166 paths = gtk_tree_selection_get_selected_rows (selection, &model);
2167 g_return_if_fail (paths != NULL);
2170 gtk_tree_model_get_iter (model, &iter, path);
2171 gtk_tree_model_get (model, &iter,
2172 COL_WHO_ACCOUNT, &account,
2173 COL_WHO_TARGET, &target,
2176 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
2178 self->priv->selected_contact = empathy_contact_from_tpl_contact (account,
2181 g_object_unref (account);
2182 g_object_unref (target);
2187 /* If the Who pane doesn't contain a contact (e.g. it has many
2188 * selected, or has 'Anyone', let's try to get the contact from
2189 * the selected event. */
2191 if (self->priv->events_contact != NULL)
2192 self->priv->selected_contact = g_object_ref (self->priv->events_contact);
2195 if (self->priv->selected_contact != NULL)
2197 tp_g_signal_connect_object (self->priv->selected_contact,
2198 "notify::capabilities", G_CALLBACK (contact_capabilities_changed_cb),
2202 do_update_buttons_sensitivity (self);
2206 log_window_update_what_iter_sensitivity (GtkTreeModel *model,
2210 GtkTreeStore *store = GTK_TREE_STORE (model);
2214 gtk_tree_store_set (store, iter,
2215 COL_WHAT_SENSITIVE, sensitive,
2218 for (next = gtk_tree_model_iter_children (model, &child, iter);
2220 next = gtk_tree_model_iter_next (model, &child))
2222 gtk_tree_store_set (store, &child,
2223 COL_WHAT_SENSITIVE, sensitive,
2229 log_window_update_what_sensitivity (EmpathyLogWindow *self)
2232 GtkTreeModel *model;
2234 GList *accounts, *targets, *acc, *targ;
2237 if (!log_window_get_selected (self, &accounts, &targets, NULL, NULL,
2241 view = GTK_TREE_VIEW (self->priv->treeview_what);
2242 model = gtk_tree_view_get_model (view);
2244 /* For each event type... */
2245 for (next = gtk_tree_model_get_iter_first (model, &iter);
2247 next = gtk_tree_model_iter_next (model, &iter))
2249 TplEventTypeMask type;
2251 gtk_tree_model_get (model, &iter,
2252 COL_WHAT_TYPE, &type,
2255 /* ...we set the type and its subtypes (if any) unsensitive... */
2256 log_window_update_what_iter_sensitivity (model, &iter, FALSE);
2258 for (acc = accounts, targ = targets;
2259 acc != NULL && targ != NULL;
2260 acc = acc->next, targ = targ->next)
2262 TpAccount *account = acc->data;
2263 TplEntity *target = targ->data;
2265 if (tpl_log_manager_exists (self->priv->log_manager,
2266 account, target, type))
2268 /* And then we set it (and its subtypes, again, if any)
2269 * as sensitive if there are logs of that type. */
2270 log_window_update_what_iter_sensitivity (model, &iter, TRUE);
2276 g_list_free_full (accounts, g_object_unref);
2277 g_list_free_full (targets, g_object_unref);
2281 log_window_who_changed_cb (GtkTreeSelection *selection,
2282 EmpathyLogWindow *self)
2285 GtkTreeModel *model;
2288 DEBUG ("log_window_who_changed_cb");
2290 view = gtk_tree_selection_get_tree_view (selection);
2291 model = gtk_tree_view_get_model (view);
2293 if (gtk_tree_model_get_iter_first (model, &iter))
2295 /* If 'Anyone' is selected, everything else should be deselected */
2296 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2298 g_signal_handlers_block_by_func (selection,
2299 log_window_who_changed_cb,
2302 gtk_tree_selection_unselect_all (selection);
2303 gtk_tree_selection_select_iter (selection, &iter);
2305 g_signal_handlers_unblock_by_func (selection,
2306 log_window_who_changed_cb,
2311 log_window_update_what_sensitivity (self);
2312 log_window_update_buttons_sensitivity (self);
2314 /* The contact changed, so the dates need to be updated */
2315 log_window_chats_get_messages (self, TRUE);
2319 log_manager_got_entities_cb (GObject *manager,
2320 GAsyncResult *result,
2323 Ctx *ctx = user_data;
2327 GtkTreeModel *model;
2328 GtkTreeSelection *selection;
2329 GtkListStore *store;
2331 GError *error = NULL;
2332 gboolean select_account = FALSE;
2334 if (log_window == NULL)
2337 if (log_window->priv->count != ctx->count)
2340 if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager),
2341 result, &entities, &error))
2343 DEBUG ("%s. Aborting", error->message);
2344 g_error_free (error);
2348 view = GTK_TREE_VIEW (ctx->self->priv->treeview_who);
2349 model = gtk_tree_view_get_model (view);
2350 selection = gtk_tree_view_get_selection (view);
2351 store = GTK_LIST_STORE (model);
2353 /* Block signals to stop the logs being retrieved prematurely */
2354 g_signal_handlers_block_by_func (selection,
2355 log_window_who_changed_cb, ctx->self);
2357 for (l = entities; l; l = l->next)
2359 add_event_to_store (ctx->self, ctx->account, l->data);
2361 if (ctx->self->priv->selected_account != NULL &&
2362 !tp_strdiff (tp_proxy_get_object_path (ctx->account),
2363 tp_proxy_get_object_path (ctx->self->priv->selected_account)))
2364 select_account = TRUE;
2366 g_list_free_full (entities, g_object_unref);
2368 if (gtk_tree_model_get_iter_first (model, &iter))
2372 gtk_tree_model_get (model, &iter,
2373 COL_WHO_TYPE, &type,
2376 if (type != COL_TYPE_ANY)
2378 gtk_list_store_prepend (store, &iter);
2379 gtk_list_store_set (store, &iter,
2380 COL_WHO_TYPE, COL_TYPE_SEPARATOR,
2381 COL_WHO_NAME, "separator",
2384 gtk_list_store_prepend (store, &iter);
2385 gtk_list_store_set (store, &iter,
2386 COL_WHO_TYPE, COL_TYPE_ANY,
2387 COL_WHO_NAME, _("Anyone"),
2392 /* Unblock signals */
2393 g_signal_handlers_unblock_by_func (selection,
2394 log_window_who_changed_cb,
2397 /* We display the selected account if we populate the model with chats from
2400 log_window_chats_set_selected (ctx->self);
2403 _tpl_action_chain_continue (log_window->priv->chain);
2408 get_entities_for_account (TplActionChain *chain, gpointer user_data)
2410 Ctx *ctx = user_data;
2412 tpl_log_manager_get_entities_async (ctx->self->priv->log_manager, ctx->account,
2413 log_manager_got_entities_cb, ctx);
2417 select_first_entity (TplActionChain *chain, gpointer user_data)
2419 EmpathyLogWindow *self = user_data;
2421 GtkTreeModel *model;
2422 GtkTreeSelection *selection;
2425 view = GTK_TREE_VIEW (self->priv->treeview_who);
2426 model = gtk_tree_view_get_model (view);
2427 selection = gtk_tree_view_get_selection (view);
2429 if (gtk_tree_model_get_iter_first (model, &iter))
2430 gtk_tree_selection_select_iter (selection, &iter);
2432 _tpl_action_chain_continue (self->priv->chain);
2436 log_window_who_populate (EmpathyLogWindow *self)
2438 EmpathyAccountChooser *account_chooser;
2440 gboolean all_accounts;
2442 GtkTreeModel *model;
2443 GtkTreeSelection *selection;
2444 GtkListStore *store;
2447 if (self->priv->hits != NULL)
2449 populate_entities_from_search_hits ();
2453 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
2454 account = empathy_account_chooser_dup_account (account_chooser);
2455 all_accounts = empathy_account_chooser_has_all_selected (account_chooser);
2457 view = GTK_TREE_VIEW (self->priv->treeview_who);
2458 model = gtk_tree_view_get_model (view);
2459 selection = gtk_tree_view_get_selection (view);
2460 store = GTK_LIST_STORE (model);
2462 /* Block signals to stop the logs being retrieved prematurely */
2463 g_signal_handlers_block_by_func (selection,
2464 log_window_who_changed_cb,
2467 gtk_list_store_clear (store);
2469 /* Unblock signals */
2470 g_signal_handlers_unblock_by_func (selection,
2471 log_window_who_changed_cb,
2474 _tpl_action_chain_clear (self->priv->chain);
2475 self->priv->count++;
2477 if (!all_accounts && account == NULL)
2481 else if (!all_accounts)
2483 ctx = ctx_new (self, account, NULL, NULL, 0, 0, self->priv->count);
2484 _tpl_action_chain_append (self->priv->chain, get_entities_for_account, ctx);
2488 TpAccountManager *manager;
2489 GList *accounts, *l;
2491 manager = empathy_account_chooser_get_account_manager (account_chooser);
2492 accounts = tp_account_manager_dup_valid_accounts (manager);
2494 for (l = accounts; l != NULL; l = l->next)
2498 ctx = ctx_new (self, account, NULL, NULL, 0, 0, self->priv->count);
2499 _tpl_action_chain_append (self->priv->chain,
2500 get_entities_for_account, ctx);
2503 g_list_free_full (accounts, g_object_unref);
2505 _tpl_action_chain_append (self->priv->chain, select_first_entity, self);
2506 _tpl_action_chain_start (self->priv->chain);
2510 sort_by_name_key (GtkTreeModel *model,
2519 gtk_tree_model_get (model, a,
2520 COL_WHO_TYPE, &type1,
2521 COL_WHO_NAME_SORT_KEY, &key1,
2524 gtk_tree_model_get (model, b,
2525 COL_WHO_TYPE, &type2,
2526 COL_WHO_NAME_SORT_KEY, &key2,
2529 if (type1 == COL_TYPE_ANY)
2531 else if (type2 == COL_TYPE_ANY)
2533 else if (type1 == COL_TYPE_SEPARATOR)
2535 else if (type2 == COL_TYPE_SEPARATOR)
2538 ret = g_strcmp0 (key1, key2);
2547 who_row_is_separator (GtkTreeModel *model,
2553 gtk_tree_model_get (model, iter,
2554 COL_WHO_TYPE, &type,
2557 return (type == COL_TYPE_SEPARATOR);
2561 log_window_find_row (EmpathyLogWindow *self,
2562 GdkEventButton *event)
2564 WebKitHitTestResult *hit = webkit_web_view_get_hit_test_result (
2565 WEBKIT_WEB_VIEW (self->priv->webview), event);
2566 WebKitDOMNode *inner_node;
2568 tp_clear_object (&self->priv->events_contact);
2571 "inner-node", &inner_node,
2574 if (inner_node != NULL)
2576 GtkTreeModel *model = GTK_TREE_MODEL (self->priv->store_events);
2577 WebKitDOMNode *node;
2578 const char *path = NULL;
2581 /* walk back up the DOM tree looking for a node with empathy:path set */
2582 for (node = inner_node; node != NULL;
2583 node = webkit_dom_node_get_parent_node (node))
2585 if (!WEBKIT_DOM_IS_ELEMENT (node))
2588 path = webkit_dom_element_get_attribute_ns (
2589 WEBKIT_DOM_ELEMENT (node), EMPATHY_NS, "path");
2591 if (!tp_str_empty (path))
2595 /* look up the contact for this path */
2596 if (!tp_str_empty (path) &&
2597 gtk_tree_model_get_iter_from_string (model, &iter, path))
2602 gtk_tree_model_get (model, &iter,
2603 COL_EVENTS_ACCOUNT, &account,
2604 COL_EVENTS_TARGET, &target,
2607 self->priv->events_contact = empathy_contact_from_tpl_contact (
2610 g_object_unref (account);
2611 g_object_unref (target);
2614 g_object_unref (inner_node);
2617 g_object_unref (hit);
2619 log_window_update_buttons_sensitivity (self);
2623 log_window_events_button_press_event (GtkWidget *webview,
2624 GdkEventButton *event,
2625 EmpathyLogWindow *self)
2627 switch (event->button)
2630 log_window_find_row (self, event);
2634 empathy_webkit_context_menu_for_event (
2635 WEBKIT_WEB_VIEW (webview), event, 0);
2646 log_window_events_setup (EmpathyLogWindow *self)
2648 GtkTreeSortable *sortable;
2649 GtkTreeStore *store;
2652 self->priv->store_events = store = gtk_tree_store_new (COL_EVENTS_COUNT,
2653 G_TYPE_INT, /* type */
2654 G_TYPE_INT64, /* timestamp */
2655 G_TYPE_STRING, /* stringified date */
2656 G_TYPE_STRING, /* icon */
2657 G_TYPE_STRING, /* name */
2658 TP_TYPE_ACCOUNT, /* account */
2659 TPL_TYPE_ENTITY, /* target */
2660 TPL_TYPE_EVENT); /* event */
2662 sortable = GTK_TREE_SORTABLE (store);
2664 gtk_tree_sortable_set_sort_column_id (sortable,
2666 GTK_SORT_ASCENDING);
2670 log_window_who_setup (EmpathyLogWindow *self)
2673 GtkTreeModel *model;
2674 GtkTreeSelection *selection;
2675 GtkTreeSortable *sortable;
2676 GtkTreeViewColumn *column;
2677 GtkListStore *store;
2678 GtkCellRenderer *cell;
2680 view = GTK_TREE_VIEW (self->priv->treeview_who);
2681 selection = gtk_tree_view_get_selection (view);
2684 store = gtk_list_store_new (COL_WHO_COUNT,
2685 G_TYPE_INT, /* type */
2686 G_TYPE_STRING, /* icon */
2687 G_TYPE_STRING, /* name */
2688 G_TYPE_STRING, /* name sort key */
2689 G_TYPE_STRING, /* id */
2690 TP_TYPE_ACCOUNT, /* account */
2691 TPL_TYPE_ENTITY); /* target */
2693 model = GTK_TREE_MODEL (store);
2694 sortable = GTK_TREE_SORTABLE (store);
2696 gtk_tree_view_set_model (view, model);
2699 column = gtk_tree_view_column_new ();
2700 gtk_tree_view_column_set_title (column, _("Who"));
2702 cell = gtk_cell_renderer_pixbuf_new ();
2703 gtk_tree_view_column_pack_start (column, cell, FALSE);
2704 gtk_tree_view_column_add_attribute (column, cell,
2708 cell = gtk_cell_renderer_text_new ();
2709 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2710 gtk_tree_view_column_pack_start (column, cell, TRUE);
2711 gtk_tree_view_column_add_attribute (column, cell,
2715 gtk_tree_view_append_column (view, column);
2717 /* set up treeview properties */
2718 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
2719 gtk_tree_view_set_row_separator_func (view, who_row_is_separator,
2722 gtk_tree_sortable_set_sort_column_id (sortable,
2723 COL_WHO_NAME_SORT_KEY,
2724 GTK_SORT_ASCENDING);
2725 gtk_tree_sortable_set_sort_func (sortable,
2726 COL_WHO_NAME_SORT_KEY, sort_by_name_key,
2729 gtk_tree_view_set_search_column (view, COL_WHO_NAME);
2730 gtk_tree_view_set_tooltip_column (view, COL_WHO_ID);
2732 /* set up signals */
2733 g_signal_connect (selection, "changed",
2734 G_CALLBACK (log_window_who_changed_cb), self);
2736 g_object_unref (store);
2740 log_window_chats_accounts_changed_cb (GtkWidget *combobox,
2741 EmpathyLogWindow *self)
2743 /* Clear all current messages shown in the textview */
2744 gtk_tree_store_clear (self->priv->store_events);
2746 log_window_who_populate (self);
2750 log_window_chats_set_selected (EmpathyLogWindow *self)
2753 GtkTreeModel *model;
2754 GtkTreeSelection *selection;
2759 view = GTK_TREE_VIEW (self->priv->treeview_who);
2760 model = gtk_tree_view_get_model (view);
2761 selection = gtk_tree_view_get_selection (view);
2763 for (next = gtk_tree_model_get_iter_first (model, &iter);
2765 next = gtk_tree_model_iter_next (model, &iter))
2767 TpAccount *this_account;
2768 TplEntity *this_target;
2769 const gchar *this_chat_id;
2770 gboolean this_is_chatroom;
2773 gtk_tree_model_get (model, &iter,
2774 COL_WHO_TYPE, &this_type,
2775 COL_WHO_ACCOUNT, &this_account,
2776 COL_WHO_TARGET, &this_target,
2779 if (this_type != COL_TYPE_NORMAL)
2782 this_chat_id = tpl_entity_get_identifier (this_target);
2783 this_is_chatroom = tpl_entity_get_entity_type (this_target)
2786 if (this_account == self->priv->selected_account &&
2787 !tp_strdiff (this_chat_id, self->priv->selected_chat_id) &&
2788 this_is_chatroom == self->priv->selected_is_chatroom)
2790 gtk_tree_selection_select_iter (selection, &iter);
2791 path = gtk_tree_model_get_path (model, &iter);
2792 gtk_tree_view_scroll_to_cell (view, path, NULL, TRUE, 0.5, 0.0);
2793 gtk_tree_path_free (path);
2794 g_object_unref (this_account);
2795 g_object_unref (this_target);
2799 g_object_unref (this_account);
2800 g_object_unref (this_target);
2803 tp_clear_object (&self->priv->selected_account);
2804 tp_clear_pointer (&self->priv->selected_chat_id, g_free);
2808 sort_by_date (GtkTreeModel *model,
2813 GDate *date1, *date2;
2816 gtk_tree_model_get (model, a,
2817 COL_WHEN_DATE, &date1,
2820 gtk_tree_model_get (model, b,
2821 COL_WHEN_DATE, &date2,
2824 result = g_date_compare (date1, date2);
2826 g_date_free (date1);
2827 g_date_free (date2);
2832 when_row_is_separator (GtkTreeModel *model,
2839 gtk_tree_model_get (model, iter,
2840 COL_WHEN_TEXT, &when,
2843 ret = !tp_strdiff (when, "separator");
2849 log_window_when_changed_cb (GtkTreeSelection *selection,
2850 EmpathyLogWindow *self)
2853 GtkTreeModel *model;
2856 DEBUG ("log_window_when_changed_cb");
2858 view = gtk_tree_selection_get_tree_view (selection);
2859 model = gtk_tree_view_get_model (view);
2861 /* If 'Anytime' is selected, everything else should be deselected */
2862 if (gtk_tree_model_get_iter_first (model, &iter))
2864 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2866 g_signal_handlers_block_by_func (selection,
2867 log_window_when_changed_cb,
2870 gtk_tree_selection_unselect_all (selection);
2871 gtk_tree_selection_select_iter (selection, &iter);
2873 g_signal_handlers_unblock_by_func (selection,
2874 log_window_when_changed_cb,
2879 log_window_chats_get_messages (self, FALSE);
2883 log_window_when_setup (EmpathyLogWindow *self)
2886 GtkTreeModel *model;
2887 GtkTreeSelection *selection;
2888 GtkTreeSortable *sortable;
2889 GtkTreeViewColumn *column;
2890 GtkListStore *store;
2891 GtkCellRenderer *cell;
2893 view = GTK_TREE_VIEW (self->priv->treeview_when);
2894 selection = gtk_tree_view_get_selection (view);
2897 store = gtk_list_store_new (COL_WHEN_COUNT,
2898 G_TYPE_DATE, /* date */
2899 G_TYPE_STRING, /* stringified date */
2900 G_TYPE_STRING); /* icon */
2902 model = GTK_TREE_MODEL (store);
2903 sortable = GTK_TREE_SORTABLE (store);
2905 gtk_tree_view_set_model (view, model);
2908 column = gtk_tree_view_column_new ();
2909 gtk_tree_view_column_set_title (column, _("When"));
2911 cell = gtk_cell_renderer_pixbuf_new ();
2912 gtk_tree_view_column_pack_start (column, cell, FALSE);
2913 gtk_tree_view_column_add_attribute (column, cell,
2914 "icon-name", COL_WHEN_ICON);
2916 cell = gtk_cell_renderer_text_new ();
2917 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2918 gtk_tree_view_column_pack_start (column, cell, TRUE);
2919 gtk_tree_view_column_add_attribute (column, cell,
2923 gtk_tree_view_append_column (view, column);
2925 /* set up treeview properties */
2926 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
2927 gtk_tree_view_set_row_separator_func (view, when_row_is_separator,
2929 gtk_tree_sortable_set_sort_column_id (sortable,
2931 GTK_SORT_DESCENDING);
2932 gtk_tree_sortable_set_sort_func (sortable,
2933 COL_WHEN_DATE, sort_by_date,
2936 gtk_tree_view_set_search_column (view, COL_WHEN_TEXT);
2938 /* set up signals */
2939 g_signal_connect (selection, "changed",
2940 G_CALLBACK (log_window_when_changed_cb),
2943 g_object_unref (store);
2947 what_row_is_separator (GtkTreeModel *model,
2953 gtk_tree_model_get (model, iter,
2954 COL_WHAT_TYPE, &type,
2957 return (type == WHAT_TYPE_SEPARATOR);
2961 log_window_what_changed_cb (GtkTreeSelection *selection,
2962 EmpathyLogWindow *self)
2965 GtkTreeModel *model;
2968 DEBUG ("log_window_what_changed_cb");
2970 view = gtk_tree_selection_get_tree_view (selection);
2971 model = gtk_tree_view_get_model (view);
2973 /* If 'Anything' is selected, everything else should be deselected */
2974 if (gtk_tree_model_get_iter_first (model, &iter))
2976 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2978 g_signal_handlers_block_by_func (selection,
2979 log_window_what_changed_cb,
2982 gtk_tree_selection_unselect_all (selection);
2983 gtk_tree_selection_select_iter (selection, &iter);
2985 g_signal_handlers_unblock_by_func (selection,
2986 log_window_what_changed_cb,
2991 /* The dates need to be updated if we're not searching */
2992 log_window_chats_get_messages (self, self->priv->hits == NULL);
2996 log_window_what_collapse_row_cb (GtkTreeView *tree_view,
3001 /* Reject collapsing */
3008 EventSubtype subtype;
3014 log_window_what_setup (EmpathyLogWindow *self)
3017 GtkTreeModel *model;
3018 GtkTreeSelection *selection;
3019 GtkTreeViewColumn *column;
3021 GtkTreeStore *store;
3022 GtkCellRenderer *cell;
3026 struct event events [] = {
3027 { TPL_EVENT_MASK_ANY, 0, NULL, _("Anything") },
3028 { WHAT_TYPE_SEPARATOR, 0, NULL, "separator" },
3029 { TPL_EVENT_MASK_TEXT, 0, "format-justify-fill", _("Text chats") },
3030 { TPL_EVENT_MASK_CALL, EVENT_CALL_ALL, EMPATHY_IMAGE_CALL, _("Calls") },
3033 struct event call_events [] = {
3034 { TPL_EVENT_MASK_CALL, EVENT_CALL_INCOMING, EMPATHY_IMAGE_CALL_INCOMING, _("Incoming calls") },
3035 { TPL_EVENT_MASK_CALL, EVENT_CALL_OUTGOING, EMPATHY_IMAGE_CALL_OUTGOING, _("Outgoing calls") },
3036 { TPL_EVENT_MASK_CALL, EVENT_CALL_MISSED, EMPATHY_IMAGE_CALL_MISSED, _("Missed calls") }
3039 view = GTK_TREE_VIEW (self->priv->treeview_what);
3040 selection = gtk_tree_view_get_selection (view);
3043 store = gtk_tree_store_new (COL_WHAT_COUNT,
3044 G_TYPE_INT, /* history type */
3045 G_TYPE_INT, /* history subtype */
3046 G_TYPE_BOOLEAN, /* sensitive */
3047 G_TYPE_STRING, /* stringified history type */
3048 G_TYPE_STRING); /* icon */
3050 model = GTK_TREE_MODEL (store);
3052 gtk_tree_view_set_model (view, model);
3055 column = gtk_tree_view_column_new ();
3056 gtk_tree_view_column_set_title (column, _("What"));
3058 cell = gtk_cell_renderer_pixbuf_new ();
3059 gtk_tree_view_column_pack_start (column, cell, FALSE);
3060 gtk_tree_view_column_add_attribute (column, cell,
3061 "icon-name", COL_WHAT_ICON);
3063 cell = gtk_cell_renderer_text_new ();
3064 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
3065 gtk_tree_view_column_pack_start (column, cell, TRUE);
3066 gtk_tree_view_column_add_attribute (column, cell,
3067 "text", COL_WHAT_TEXT);
3068 gtk_tree_view_column_add_attribute (column, cell,
3069 "sensitive", COL_WHAT_SENSITIVE);
3071 gtk_tree_view_append_column (view, column);
3072 gtk_tree_view_set_search_column (view, COL_WHAT_TEXT);
3074 /* set up treeview properties */
3075 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
3076 gtk_tree_view_set_show_expanders (view, FALSE);
3077 gtk_tree_view_set_level_indentation (view, 12);
3078 gtk_tree_view_expand_all (view);
3079 gtk_tree_view_set_row_separator_func (view, what_row_is_separator,
3083 for (i = 0; i < G_N_ELEMENTS (events); i++)
3085 gtk_tree_store_append (store, &iter, NULL);
3086 gtk_tree_store_set (store, &iter,
3087 COL_WHAT_TYPE, events[i].type,
3088 COL_WHAT_SUBTYPE, events[i].subtype,
3089 COL_WHAT_SENSITIVE, TRUE,
3090 COL_WHAT_TEXT, events[i].text,
3091 COL_WHAT_ICON, events[i].icon,
3095 gtk_tree_model_iter_nth_child (model, &parent, NULL, 3);
3096 for (i = 0; i < G_N_ELEMENTS (call_events); i++)
3098 gtk_tree_store_append (store, &iter, &parent);
3099 gtk_tree_store_set (store, &iter,
3100 COL_WHAT_TYPE, call_events[i].type,
3101 COL_WHAT_SUBTYPE, call_events[i].subtype,
3102 COL_WHAT_SENSITIVE, TRUE,
3103 COL_WHAT_TEXT, call_events[i].text,
3104 COL_WHAT_ICON, call_events[i].icon,
3108 gtk_tree_view_expand_all (view);
3110 /* select 'Anything' */
3111 if (gtk_tree_model_get_iter_first (model, &iter))
3112 gtk_tree_selection_select_iter (selection, &iter);
3114 /* set up signals */
3115 g_signal_connect (view, "test-collapse-row",
3116 G_CALLBACK (log_window_what_collapse_row_cb),
3118 g_signal_connect (selection, "changed",
3119 G_CALLBACK (log_window_what_changed_cb),
3122 g_object_unref (store);
3126 log_window_maybe_expand_events (void)
3128 GtkTreeModel *model = GTK_TREE_MODEL (log_window->priv->store_events);
3130 /* If there's only one result, expand it */
3131 if (gtk_tree_model_iter_n_children (model, NULL) == 1)
3132 webkit_web_view_execute_script (
3133 WEBKIT_WEB_VIEW (log_window->priv->webview),
3134 "javascript:expandAll()");
3138 show_spinner (gpointer data)
3142 if (log_window == NULL)
3145 g_object_get (log_window->priv->spinner, "active", &active, NULL);
3148 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3155 show_events (TplActionChain *chain,
3158 log_window_maybe_expand_events ();
3159 gtk_spinner_stop (GTK_SPINNER (log_window->priv->spinner));
3160 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3163 _tpl_action_chain_continue (chain);
3167 start_spinner (void)
3169 gtk_spinner_start (GTK_SPINNER (log_window->priv->spinner));
3170 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3173 g_timeout_add (1000, show_spinner, NULL);
3174 _tpl_action_chain_append (log_window->priv->chain, show_events, NULL);
3178 log_window_got_messages_for_date_cb (GObject *manager,
3179 GAsyncResult *result,
3182 Ctx *ctx = user_data;
3183 GtkTreeModel *model;
3187 GError *error = NULL;
3190 if (log_window == NULL)
3196 if (log_window->priv->count != ctx->count)
3199 if (!tpl_log_manager_get_events_for_date_finish (TPL_LOG_MANAGER (manager),
3200 result, &events, &error))
3202 DEBUG ("Unable to retrieve messages for the selected date: %s. Aborting",
3204 g_error_free (error);
3208 for (l = events; l; l = l->next)
3210 TplEvent *event = l->data;
3211 gboolean append = TRUE;
3213 if (TPL_IS_CALL_EVENT (l->data)
3214 && ctx->event_mask & TPL_EVENT_MASK_CALL
3215 && ctx->event_mask != TPL_EVENT_MASK_ANY)
3217 TplCallEvent *call = l->data;
3221 if (ctx->subtype & EVENT_CALL_ALL)
3227 TpCallStateChangeReason reason =
3228 tpl_call_event_get_end_reason (call);
3229 TplEntity *sender = tpl_event_get_sender (event);
3230 TplEntity *receiver = tpl_event_get_receiver (event);
3232 if (reason == TP_CALL_STATE_CHANGE_REASON_NO_ANSWER)
3234 if (ctx->subtype & EVENT_CALL_MISSED)
3237 else if (ctx->subtype & EVENT_CALL_OUTGOING
3238 && tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
3242 else if (ctx->subtype & EVENT_CALL_INCOMING
3243 && tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF)
3252 EmpathyMessage *msg = empathy_message_from_tpl_log_event (event);
3253 log_window_append_message (event, msg);
3254 tp_clear_object (&msg);
3257 g_object_unref (event);
3259 g_list_free (events);
3261 model = GTK_TREE_MODEL (log_window->priv->store_events);
3262 n = gtk_tree_model_iter_n_children (model, NULL) - 1;
3264 if (n >= 0 && gtk_tree_model_iter_nth_child (model, &iter, NULL, n))
3269 path = gtk_tree_model_get_path (model, &iter);
3270 str = gtk_tree_path_to_string (path);
3272 script = g_strdup_printf ("javascript:scrollToRow([%s]);",
3273 g_strdelimit (str, ":", ','));
3275 webkit_web_view_execute_script (
3276 WEBKIT_WEB_VIEW (log_window->priv->webview),
3279 gtk_tree_path_free (path);
3287 _tpl_action_chain_continue (log_window->priv->chain);
3291 get_events_for_date (TplActionChain *chain, gpointer user_data)
3293 Ctx *ctx = user_data;
3295 tpl_log_manager_get_events_for_date_async (ctx->self->priv->log_manager,
3296 ctx->account, ctx->entity, ctx->event_mask,
3298 log_window_got_messages_for_date_cb,
3303 log_window_get_messages_for_dates (EmpathyLogWindow *self,
3306 GList *accounts, *targets, *acc, *targ, *l;
3307 TplEventTypeMask event_mask;
3308 EventSubtype subtype;
3309 GDate *date, *anytime, *separator;
3311 if (!log_window_get_selected (self,
3312 &accounts, &targets, NULL, NULL, &event_mask, &subtype))
3315 anytime = g_date_new_dmy (2, 1, -1);
3316 separator = g_date_new_dmy (1, 1, -1);
3318 _tpl_action_chain_clear (self->priv->chain);
3319 self->priv->count++;
3321 for (acc = accounts, targ = targets;
3322 acc != NULL && targ != NULL;
3323 acc = acc->next, targ = targ->next)
3325 TpAccount *account = acc->data;
3326 TplEntity *target = targ->data;
3328 for (l = dates; l != NULL; l = l->next)
3333 if (g_date_compare (date, anytime) != 0)
3337 ctx = ctx_new (self, account, target, date, event_mask, subtype,
3339 _tpl_action_chain_append (self->priv->chain, get_events_for_date, ctx);
3343 GtkTreeView *view = GTK_TREE_VIEW (self->priv->treeview_when);
3344 GtkTreeModel *model = gtk_tree_view_get_model (view);
3349 for (next = gtk_tree_model_get_iter_first (model, &iter);
3351 next = gtk_tree_model_iter_next (model, &iter))
3355 gtk_tree_model_get (model, &iter,
3359 if (g_date_compare (d, anytime) != 0 &&
3360 g_date_compare (d, separator) != 0)
3362 ctx = ctx_new (self, account, target, d,
3363 event_mask, subtype, self->priv->count);
3364 _tpl_action_chain_append (self->priv->chain, get_events_for_date, ctx);
3374 _tpl_action_chain_start (self->priv->chain);
3376 g_list_free_full (accounts, g_object_unref);
3377 g_list_free_full (targets, g_object_unref);
3378 g_date_free (separator);
3379 g_date_free (anytime);
3383 log_manager_got_dates_cb (GObject *manager,
3384 GAsyncResult *result,
3387 Ctx *ctx = user_data;
3389 GtkTreeModel *model;
3390 GtkListStore *store;
3394 GError *error = NULL;
3396 if (log_window == NULL)
3402 if (log_window->priv->count != ctx->count)
3405 if (!tpl_log_manager_get_dates_finish (TPL_LOG_MANAGER (manager),
3406 result, &dates, &error))
3408 DEBUG ("Unable to retrieve messages' dates: %s. Aborting",
3413 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
3414 model = gtk_tree_view_get_model (view);
3415 store = GTK_LIST_STORE (model);
3417 for (l = dates; l != NULL; l = l->next)
3419 add_date_if_needed (log_window, l->data);
3422 if (gtk_tree_model_get_iter_first (model, &iter))
3424 gchar *separator = NULL;
3426 if (gtk_tree_model_iter_next (model, &iter))
3428 gtk_tree_model_get (model, &iter,
3429 COL_WHEN_TEXT, &separator,
3433 if (g_strcmp0 (separator, "separator") != 0)
3437 date = g_date_new_dmy (1, 1, -1);
3439 gtk_list_store_prepend (store, &iter);
3440 gtk_list_store_set (store, &iter,
3441 COL_WHEN_DATE, date,
3442 COL_WHEN_TEXT, "separator",
3447 date = g_date_new_dmy (2, 1, -1);
3449 gtk_list_store_prepend (store, &iter);
3450 gtk_list_store_set (store, &iter,
3451 COL_WHEN_DATE, date,
3452 COL_WHEN_TEXT, _("Anytime"),
3461 g_list_free_full (dates, g_free);
3464 _tpl_action_chain_continue (log_window->priv->chain);
3468 select_date (TplActionChain *chain, gpointer user_data)
3471 GtkTreeModel *model;
3472 GtkTreeSelection *selection;
3475 gboolean selected = FALSE;
3477 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
3478 model = gtk_tree_view_get_model (view);
3479 selection = gtk_tree_view_get_selection (view);
3481 if (log_window->priv->current_dates != NULL)
3483 for (next = gtk_tree_model_get_iter_first (model, &iter);
3485 next = gtk_tree_model_iter_next (model, &iter))
3489 gtk_tree_model_get (model, &iter,
3490 COL_WHEN_DATE, &date,
3493 if (g_list_find_custom (log_window->priv->current_dates, date,
3494 (GCompareFunc) g_date_compare) != NULL)
3498 gtk_tree_selection_select_iter (selection, &iter);
3499 path = gtk_tree_model_get_path (model, &iter);
3500 gtk_tree_view_scroll_to_cell (view, path, NULL, FALSE, 0, 0);
3503 gtk_tree_path_free (path);
3512 /* Show messages of the most recent date */
3513 if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 2))
3514 gtk_tree_selection_select_iter (selection, &iter);
3517 _tpl_action_chain_continue (log_window->priv->chain);
3521 get_dates_for_entity (TplActionChain *chain, gpointer user_data)
3523 Ctx *ctx = user_data;
3525 tpl_log_manager_get_dates_async (ctx->self->priv->log_manager,
3526 ctx->account, ctx->entity, ctx->event_mask,
3527 log_manager_got_dates_cb, ctx);
3531 log_window_chats_get_messages (EmpathyLogWindow *self,
3532 gboolean force_get_dates)
3534 GList *accounts, *targets, *dates;
3535 TplEventTypeMask event_mask;
3537 GtkTreeModel *model;
3538 GtkListStore *store;
3539 GtkTreeSelection *selection;
3541 if (!log_window_get_selected (self, &accounts, &targets, NULL,
3542 &dates, &event_mask, NULL))
3545 view = GTK_TREE_VIEW (self->priv->treeview_when);
3546 selection = gtk_tree_view_get_selection (view);
3547 model = gtk_tree_view_get_model (view);
3548 store = GTK_LIST_STORE (model);
3550 /* Clear all current messages shown in the textview */
3551 gtk_tree_store_clear (self->priv->store_events);
3553 _tpl_action_chain_clear (self->priv->chain);
3554 self->priv->count++;
3556 /* If there's a search use the returned hits */
3557 if (self->priv->hits != NULL)
3559 if (force_get_dates)
3561 g_signal_handlers_block_by_func (selection,
3562 log_window_when_changed_cb,
3565 gtk_list_store_clear (store);
3567 g_signal_handlers_unblock_by_func (selection,
3568 log_window_when_changed_cb,
3571 populate_dates_from_search_hits (accounts, targets);
3575 populate_events_from_search_hits (accounts, targets, dates);
3578 /* Either use the supplied date or get the last */
3579 else if (force_get_dates || dates == NULL)
3583 if (self->priv->current_dates != NULL)
3585 g_list_free_full (self->priv->current_dates,
3586 (GDestroyNotify) g_date_free);
3587 self->priv->current_dates = NULL;
3590 if (gtk_tree_selection_count_selected_rows (selection) > 0)
3595 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
3597 for (l = paths; l != NULL; l = l->next)
3599 GtkTreePath *path = l->data;
3602 gtk_tree_model_get_iter (model, &iter, path);
3603 gtk_tree_model_get (model, &iter,
3604 COL_WHEN_DATE, &date,
3607 /* The list takes ownership of the date. */
3608 self->priv->current_dates =
3609 g_list_prepend (self->priv->current_dates, date);
3612 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
3615 g_signal_handlers_block_by_func (selection,
3616 log_window_when_changed_cb,
3619 gtk_list_store_clear (store);
3621 g_signal_handlers_unblock_by_func (selection,
3622 log_window_when_changed_cb,
3625 /* Get a list of dates and show them on the treeview */
3626 for (targ = targets, acc = accounts;
3627 targ != NULL && acc != NULL;
3628 targ = targ->next, acc = acc->next)
3630 TpAccount *account = acc->data;
3631 TplEntity *target = targ->data;
3632 Ctx *ctx = ctx_new (self, account, target, NULL, event_mask, 0,
3635 _tpl_action_chain_append (self->priv->chain, get_dates_for_entity, ctx);
3637 _tpl_action_chain_append (self->priv->chain, select_date, NULL);
3638 _tpl_action_chain_start (self->priv->chain);
3642 /* Show messages of the selected date */
3643 log_window_get_messages_for_dates (self, dates);
3646 g_list_free_full (accounts, g_object_unref);
3647 g_list_free_full (targets, g_object_unref);
3648 g_list_free_full (dates, (GFreeFunc) g_date_free);
3652 EmpathyAccountChooserFilterResultCallback callback;
3654 } FilterCallbackData;
3657 got_entities (GObject *manager,
3658 GAsyncResult *result,
3661 FilterCallbackData *data = user_data;
3663 GError *error = NULL;
3665 if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager),
3666 result, &entities, &error))
3668 DEBUG ("Could not get entities: %s", error->message);
3669 g_error_free (error);
3670 data->callback (FALSE, data->user_data);
3674 data->callback (entities != NULL, data->user_data);
3676 g_list_free_full (entities, g_object_unref);
3679 g_slice_free (FilterCallbackData, data);
3683 empathy_account_chooser_filter_has_logs (TpAccount *account,
3684 EmpathyAccountChooserFilterResultCallback callback,
3685 gpointer callback_data,
3688 TplLogManager *manager = tpl_log_manager_dup_singleton ();
3689 FilterCallbackData *cb_data = g_slice_new0 (FilterCallbackData);
3691 cb_data->callback = callback;
3692 cb_data->user_data = callback_data;
3694 tpl_log_manager_get_entities_async (manager, account, got_entities, cb_data);
3696 g_object_unref (manager);
3700 log_window_logger_clear_account_cb (TpProxy *proxy,
3701 const GError *error,
3703 GObject *weak_object)
3705 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (user_data);
3708 g_warning ("Error when clearing logs: %s", error->message);
3710 /* Refresh the log viewer so the logs are cleared if the account
3711 * has been deleted */
3712 gtk_tree_store_clear (self->priv->store_events);
3713 log_window_who_populate (self);
3715 /* Re-filter the account chooser so the accounts without logs get
3717 empathy_account_chooser_refilter (
3718 EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser));
3722 log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem,
3723 EmpathyLogWindow *self)
3725 GtkWidget *dialog, *content_area, *hbox, *label;
3726 EmpathyAccountChooser *account_chooser;
3730 GError *error = NULL;
3732 account_chooser = (EmpathyAccountChooser *) empathy_account_chooser_new ();
3733 empathy_account_chooser_set_has_all_option (account_chooser, TRUE);
3735 empathy_account_chooser_refilter (account_chooser);
3737 /* Select the same account as in the history window */
3738 empathy_account_chooser_set_account (account_chooser,
3739 empathy_account_chooser_get_account (
3740 EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser)));
3742 dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (self),
3743 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING,
3745 _("Are you sure you want to delete all logs of previous conversations?"));
3747 gtk_dialog_add_buttons (GTK_DIALOG (dialog),
3748 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
3749 _("Clear All"), GTK_RESPONSE_APPLY,
3752 content_area = gtk_message_dialog_get_message_area (
3753 GTK_MESSAGE_DIALOG (dialog));
3755 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
3756 label = gtk_label_new (_("Delete from:"));
3757 gtk_box_pack_start (GTK_BOX (hbox), label,
3759 gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (account_chooser),
3761 gtk_box_pack_start (GTK_BOX (content_area), hbox,
3764 gtk_widget_show_all (hbox);
3766 response_id = gtk_dialog_run (GTK_DIALOG (dialog));
3768 if (response_id != GTK_RESPONSE_APPLY)
3771 bus = tp_dbus_daemon_dup (&error);
3774 g_warning ("Could not delete logs: %s", error->message);
3775 g_error_free (error);
3779 logger = g_object_new (TP_TYPE_PROXY,
3780 "bus-name", "org.freedesktop.Telepathy.Logger",
3781 "object-path", "/org/freedesktop/Telepathy/Logger",
3784 g_object_unref (bus);
3786 tp_proxy_add_interface_by_id (logger, EMP_IFACE_QUARK_LOGGER);
3788 if (empathy_account_chooser_has_all_selected (account_chooser))
3790 DEBUG ("Deleting logs for all the accounts");
3792 emp_cli_logger_call_clear (logger, -1,
3793 log_window_logger_clear_account_cb,
3794 self, NULL, G_OBJECT (self));
3800 account = empathy_account_chooser_get_account (account_chooser);
3802 DEBUG ("Deleting logs for %s", tp_proxy_get_object_path (account));
3804 emp_cli_logger_call_clear_account (logger, -1,
3805 tp_proxy_get_object_path (account),
3806 log_window_logger_clear_account_cb,
3807 self, NULL, G_OBJECT (self));
3810 g_object_unref (logger);
3812 gtk_widget_destroy (dialog);