2 * Copyright (C) 2006-2007 Imendio AB
3 * Copyright (C) 2007-2011 Collabora Ltd.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation; either version 2 of the
8 * License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public
16 * License along with this program; if not, write to the
17 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
18 * Boston, MA 02110-1301 USA
20 * Authors: Martyn Russell <martyn@imendio.com>
21 * Xavier Claessens <xclaesse@gmail.com>
22 * Emilio Pozuelo Monfort <emilio.pozuelo@collabora.co.uk>
30 #include <glib/gi18n-lib.h>
32 #include <webkit/webkit.h>
34 #include <telepathy-glib/telepathy-glib.h>
35 #include <telepathy-glib/proxy-subclass.h>
37 #include <telepathy-yell/telepathy-yell.h>
39 #include <telepathy-logger/telepathy-logger.h>
41 # include <telepathy-logger/call-event.h>
44 #include <extensions/extensions.h>
46 #include <libempathy/action-chain-internal.h>
47 #include <libempathy/empathy-camera-monitor.h>
48 #include <libempathy/empathy-chatroom-manager.h>
49 #include <libempathy/empathy-chatroom.h>
50 #include <libempathy/empathy-gsettings.h>
51 #include <libempathy/empathy-message.h>
52 #include <libempathy/empathy-request-util.h>
53 #include <libempathy/empathy-utils.h>
54 #include <libempathy/empathy-time.h>
56 #include "empathy-log-window.h"
57 #include "empathy-account-chooser.h"
58 #include "empathy-call-utils.h"
59 #include "empathy-chat-view.h"
60 #include "empathy-contact-dialogs.h"
61 #include "empathy-images.h"
62 #include "empathy-theme-manager.h"
63 #include "empathy-ui-utils.h"
64 #include "empathy-webkit-utils.h"
66 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
67 #include <libempathy/empathy-debug.h>
69 #define EMPATHY_NS "http://live.gnome.org/Empathy"
71 G_DEFINE_TYPE (EmpathyLogWindow, empathy_log_window, GTK_TYPE_WINDOW);
73 struct _EmpathyLogWindowPriv
77 GtkWidget *button_profile;
78 GtkWidget *button_chat;
79 GtkWidget *button_call;
80 GtkWidget *button_video;
82 GtkWidget *search_entry;
87 GtkWidget *treeview_who;
88 GtkWidget *treeview_what;
89 GtkWidget *treeview_when;
92 GtkTreeStore *store_events;
94 GtkWidget *account_chooser;
98 /* List of selected GDates, free with g_list_free_full (l, g_date_free) */
101 TplActionChain *chain;
102 TplLogManager *log_manager;
104 /* Hash of TpChannel<->TpAccount for use by the observer until we can
105 * get a TpAccount from a TpConnection or wherever */
106 GHashTable *channels;
107 TpBaseClient *observer;
109 EmpathyContact *selected_contact;
110 EmpathyContact *events_contact;
112 EmpathyCameraMonitor *camera_monitor;
113 GBinding *button_video_binding;
115 /* Used to cancel logger calls when no longer needed */
118 /* List of owned TplLogSearchHits, free with tpl_log_search_hit_free */
122 /* Only used while waiting for the account chooser to be ready */
123 TpAccount *selected_account;
124 gchar *selected_chat_id;
125 gboolean selected_is_chatroom;
127 GSettings *gsettings_chat;
128 GSettings *gsettings_desktop;
131 static void log_window_search_entry_changed_cb (GtkWidget *entry,
132 EmpathyLogWindow *self);
133 static void log_window_search_entry_activate_cb (GtkWidget *widget,
134 EmpathyLogWindow *self);
135 static void log_window_search_entry_icon_pressed_cb (GtkEntry *entry,
136 GtkEntryIconPosition icon_pos,
139 static void log_window_who_populate (EmpathyLogWindow *self);
140 static void log_window_who_setup (EmpathyLogWindow *self);
141 static void log_window_when_setup (EmpathyLogWindow *self);
142 static void log_window_what_setup (EmpathyLogWindow *self);
143 static void log_window_events_setup (EmpathyLogWindow *self);
144 static void log_window_chats_accounts_changed_cb (GtkWidget *combobox,
145 EmpathyLogWindow *self);
146 static void log_window_chats_set_selected (EmpathyLogWindow *self);
147 static void log_window_chats_get_messages (EmpathyLogWindow *self,
148 gboolean force_get_dates);
149 static void log_window_when_changed_cb (GtkTreeSelection *selection,
150 EmpathyLogWindow *self);
151 static void log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem,
152 EmpathyLogWindow *self);
153 static void start_spinner (void);
155 static void log_window_create_observer (EmpathyLogWindow *window);
156 static gboolean log_window_events_button_press_event (GtkWidget *webview,
157 GdkEventButton *event, EmpathyLogWindow *self);
158 static void log_window_update_buttons_sensitivity (EmpathyLogWindow *self);
161 empathy_account_chooser_filter_has_logs (TpAccount *account,
162 EmpathyAccountChooserFilterResultCallback callback,
163 gpointer callback_data,
185 COL_WHO_NAME_SORT_KEY,
214 COL_EVENTS_PRETTY_DATE,
223 #define CALENDAR_ICON "stock_calendar"
225 /* Seconds between two messages to be considered one conversation */
226 #define MAX_GAP 30*60
228 #define WHAT_TYPE_SEPARATOR -1
232 EVENT_CALL_INCOMING = 1 << 0,
233 EVENT_CALL_OUTGOING = 1 << 1,
234 EVENT_CALL_MISSED = 1 << 2,
235 EVENT_CALL_ALL = 1 << 3,
239 log_window_get_selected (EmpathyLogWindow *window,
244 TplEventTypeMask *event_mask,
245 EventSubtype *subtype);
247 static EmpathyLogWindow *log_window = NULL;
249 static gboolean has_element;
252 #define _date_copy(d) g_date_new_julian (g_date_get_julian (d))
257 EmpathyLogWindow *self;
261 TplEventTypeMask event_mask;
262 EventSubtype subtype;
267 ctx_new (EmpathyLogWindow *self,
271 TplEventTypeMask event_mask,
272 EventSubtype subtype,
275 Ctx *ctx = g_slice_new0 (Ctx);
279 ctx->account = g_object_ref (account);
281 ctx->entity = g_object_ref (entity);
283 ctx->date = _date_copy (date);
284 ctx->event_mask = event_mask;
285 ctx->subtype = subtype;
294 tp_clear_object (&ctx->account);
295 tp_clear_object (&ctx->entity);
296 tp_clear_pointer (&ctx->date, g_date_free);
298 g_slice_free (Ctx, ctx);
302 account_chooser_ready_cb (EmpathyAccountChooser *chooser,
303 EmpathyLogWindow *self)
305 /* We'll display the account once the model has been populate with the chats
306 * of this account. */
307 empathy_account_chooser_set_account (EMPATHY_ACCOUNT_CHOOSER (
308 self->priv->account_chooser), self->priv->selected_account);
312 select_account_once_ready (EmpathyLogWindow *self,
314 const gchar *chat_id,
315 gboolean is_chatroom)
317 EmpathyAccountChooser *account_chooser;
319 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
321 tp_clear_object (&self->priv->selected_account);
322 self->priv->selected_account = g_object_ref (account);
324 g_free (self->priv->selected_chat_id);
325 self->priv->selected_chat_id = g_strdup (chat_id);
327 self->priv->selected_is_chatroom = is_chatroom;
329 if (empathy_account_chooser_is_ready (account_chooser))
330 account_chooser_ready_cb (account_chooser, self);
332 /* Chat will be selected once the account chooser is ready */
333 g_signal_connect (account_chooser, "ready",
334 G_CALLBACK (account_chooser_ready_cb), self);
338 toolbutton_profile_clicked (GtkToolButton *toolbutton,
339 EmpathyLogWindow *self)
341 g_return_if_fail (self != NULL);
342 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
344 empathy_contact_information_dialog_show (self->priv->selected_contact,
349 toolbutton_chat_clicked (GtkToolButton *toolbutton,
350 EmpathyLogWindow *self)
352 g_return_if_fail (self != NULL);
353 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
355 empathy_chat_with_contact (self->priv->selected_contact,
356 gtk_get_current_event_time ());
360 toolbutton_av_clicked (GtkToolButton *toolbutton,
361 EmpathyLogWindow *self)
365 g_return_if_fail (self != NULL);
366 g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
368 video = (GTK_WIDGET (toolbutton) == self->priv->button_video);
370 empathy_call_new_with_streams (
371 empathy_contact_get_id (self->priv->selected_contact),
372 empathy_contact_get_account (self->priv->selected_contact),
373 TRUE, video, gtk_get_current_event_time ());
377 insert_or_change_row (EmpathyLogWindow *self,
383 char *str = gtk_tree_path_to_string (path);
384 char *script, *text, *date, *stock_icon;
387 gtk_tree_model_get (model, iter,
388 COL_EVENTS_TEXT, &text,
389 COL_EVENTS_PRETTY_DATE, &date,
390 COL_EVENTS_ICON, &stock_icon,
393 if (!tp_str_empty (stock_icon))
395 GtkIconInfo *icon_info = gtk_icon_theme_lookup_icon (
396 gtk_icon_theme_get_default (),
398 GTK_ICON_SIZE_MENU, 0);
400 if (icon_info != NULL)
401 icon = g_strdup (gtk_icon_info_get_filename (icon_info));
403 gtk_icon_info_free (icon_info);
406 script = g_strdup_printf ("javascript:%s([%s], '%s', '%s', '%s');",
408 g_strdelimit (str, ":", ','),
410 icon != NULL ? icon : "",
413 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
425 store_events_row_inserted (GtkTreeModel *model,
428 EmpathyLogWindow *self)
430 insert_or_change_row (self, "insertRow", model, path, iter);
434 store_events_row_changed (GtkTreeModel *model,
437 EmpathyLogWindow *self)
439 insert_or_change_row (self, "changeRow", model, path, iter);
443 store_events_row_deleted (GtkTreeModel *model,
445 EmpathyLogWindow *self)
447 char *str = gtk_tree_path_to_string (path);
450 script = g_strdup_printf ("javascript:deleteRow([%s]);",
451 g_strdelimit (str, ":", ','));
453 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
461 store_events_has_child_rows (GtkTreeModel *model,
464 EmpathyLogWindow *self)
466 char *str = gtk_tree_path_to_string (path);
469 script = g_strdup_printf ("javascript:hasChildRows([%s], %u);",
470 g_strdelimit (str, ":", ','),
471 gtk_tree_model_iter_has_child (model, iter));
473 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
481 store_events_rows_reordered (GtkTreeModel *model,
485 EmpathyLogWindow *self)
487 char *str = gtk_tree_path_to_string (path);
488 int i, children = gtk_tree_model_iter_n_children (model, iter);
489 char **new_order_strv, *new_order_s;
492 new_order_strv = g_new0 (char *, children + 1);
494 for (i = 0; i < children; i++)
495 new_order_strv[i] = g_strdup_printf ("%i", new_order[i]);
497 new_order_s = g_strjoinv (",", new_order_strv);
499 script = g_strdup_printf ("javascript:reorderRows([%s], [%s]);",
500 str == NULL ? "" : g_strdelimit (str, ":", ','),
503 webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
508 g_free (new_order_s);
509 g_strfreev (new_order_strv);
513 events_webview_handle_navigation (WebKitWebView *webview,
514 WebKitWebFrame *frame,
515 WebKitNetworkRequest *request,
516 WebKitWebNavigationAction *navigation_action,
517 WebKitWebPolicyDecision *policy_decision,
518 EmpathyLogWindow *window)
520 empathy_url_show (GTK_WIDGET (webview),
521 webkit_network_request_get_uri (request));
523 webkit_web_policy_decision_ignore (policy_decision);
528 empathy_log_window_constructor (GType type,
530 GObjectConstructParam *props)
534 if (log_window != NULL)
536 retval = (GObject *) log_window;
540 retval = G_OBJECT_CLASS (empathy_log_window_parent_class)
541 ->constructor (type, n_props, props);
543 log_window = EMPATHY_LOG_WINDOW (retval);
544 g_object_add_weak_pointer (retval, (gpointer) &log_window);
551 empathy_log_window_dispose (GObject *object)
553 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (object);
555 if (self->priv->source != 0)
557 g_source_remove (self->priv->source);
558 self->priv->source = 0;
561 if (self->priv->current_dates != NULL)
563 g_list_free_full (self->priv->current_dates,
564 (GDestroyNotify) g_date_free);
565 self->priv->current_dates = NULL;
568 tp_clear_pointer (&self->priv->chain, _tpl_action_chain_free);
569 tp_clear_pointer (&self->priv->channels, g_hash_table_unref);
571 tp_clear_object (&self->priv->observer);
572 tp_clear_object (&self->priv->log_manager);
573 tp_clear_object (&self->priv->selected_account);
574 tp_clear_object (&self->priv->selected_contact);
575 tp_clear_object (&self->priv->events_contact);
576 tp_clear_object (&self->priv->camera_monitor);
578 tp_clear_object (&self->priv->gsettings_chat);
579 tp_clear_object (&self->priv->gsettings_desktop);
581 tp_clear_object (&self->priv->store_events);
583 G_OBJECT_CLASS (empathy_log_window_parent_class)->dispose (object);
587 empathy_log_window_finalize (GObject *object)
589 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (object);
591 g_free (self->priv->last_find);
592 g_free (self->priv->selected_chat_id);
594 G_OBJECT_CLASS (empathy_log_window_parent_class)->finalize (object);
598 empathy_log_window_class_init (
599 EmpathyLogWindowClass *empathy_log_window_class)
601 GObjectClass *object_class = G_OBJECT_CLASS (empathy_log_window_class);
603 g_type_class_add_private (empathy_log_window_class,
604 sizeof (EmpathyLogWindowPriv));
606 object_class->constructor = empathy_log_window_constructor;
607 object_class->dispose = empathy_log_window_dispose;
608 object_class->finalize = empathy_log_window_finalize;
612 empathy_log_window_init (EmpathyLogWindow *self)
614 EmpathyAccountChooser *account_chooser;
618 GtkWidget *vbox, *accounts, *search, *label, *closeitem;
619 GtkWidget *scrolledwindow_events;
621 self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
622 EMPATHY_TYPE_LOG_WINDOW, EmpathyLogWindowPriv);
624 self->priv->chain = _tpl_action_chain_new_async (NULL, NULL, NULL);
626 self->priv->camera_monitor = empathy_camera_monitor_dup_singleton ();
628 self->priv->log_manager = tpl_log_manager_dup_singleton ();
630 self->priv->gsettings_chat = g_settings_new (EMPATHY_PREFS_CHAT_SCHEMA);
631 self->priv->gsettings_desktop = g_settings_new (
632 EMPATHY_PREFS_DESKTOP_INTERFACE_SCHEMA);
634 gtk_window_set_title (GTK_WINDOW (self), _("History"));
635 gtk_widget_set_can_focus (GTK_WIDGET (self), FALSE);
636 gtk_window_set_default_size (GTK_WINDOW (self), 800, 600);
638 filename = empathy_file_lookup ("empathy-log-window.ui", "libempathy-gtk");
639 gui = empathy_builder_get_file (filename,
640 "vbox1", &self->priv->vbox,
641 "toolbutton_profile", &self->priv->button_profile,
642 "toolbutton_chat", &self->priv->button_chat,
643 "toolbutton_call", &self->priv->button_call,
644 "toolbutton_video", &self->priv->button_video,
645 "toolbutton_accounts", &accounts,
646 "toolbutton_search", &search,
647 "imagemenuitem_close", &closeitem,
648 "treeview_who", &self->priv->treeview_who,
649 "treeview_what", &self->priv->treeview_what,
650 "treeview_when", &self->priv->treeview_when,
651 "scrolledwindow_events", &scrolledwindow_events,
652 "notebook", &self->priv->notebook,
653 "spinner", &self->priv->spinner,
657 empathy_builder_connect (gui, self,
658 "toolbutton_profile", "clicked", toolbutton_profile_clicked,
659 "toolbutton_chat", "clicked", toolbutton_chat_clicked,
660 "toolbutton_call", "clicked", toolbutton_av_clicked,
661 "toolbutton_video", "clicked", toolbutton_av_clicked,
662 "imagemenuitem_delete", "activate", log_window_delete_menu_clicked_cb,
665 gtk_container_add (GTK_CONTAINER (self), self->priv->vbox);
667 g_object_unref (gui);
669 g_signal_connect_swapped (closeitem, "activate",
670 G_CALLBACK (gtk_widget_destroy), self);
672 /* Account chooser for chats */
673 vbox = gtk_vbox_new (FALSE, 3);
675 self->priv->account_chooser = empathy_account_chooser_new ();
676 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
677 empathy_account_chooser_set_has_all_option (account_chooser, TRUE);
678 empathy_account_chooser_set_filter (account_chooser,
679 empathy_account_chooser_filter_has_logs, NULL);
680 empathy_account_chooser_set_all (account_chooser);
682 gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->account_chooser),
683 GTK_STYLE_CLASS_RAISED);
685 g_signal_connect (self->priv->account_chooser, "changed",
686 G_CALLBACK (log_window_chats_accounts_changed_cb),
689 label = gtk_label_new (_("Show"));
691 gtk_box_pack_start (GTK_BOX (vbox),
692 self->priv->account_chooser,
695 gtk_box_pack_start (GTK_BOX (vbox),
699 gtk_widget_show_all (vbox);
700 gtk_container_add (GTK_CONTAINER (accounts), vbox);
703 vbox = gtk_vbox_new (FALSE, 3);
705 self->priv->search_entry = gtk_entry_new ();
706 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
707 GTK_ENTRY_ICON_SECONDARY, "edit-find-symbolic");
708 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
709 GTK_ENTRY_ICON_SECONDARY, FALSE);
711 label = gtk_label_new (_("Search"));
713 gtk_box_pack_start (GTK_BOX (vbox),
714 self->priv->search_entry,
717 gtk_box_pack_start (GTK_BOX (vbox),
721 gtk_widget_show_all (vbox);
722 gtk_container_add (GTK_CONTAINER (search), vbox);
724 g_signal_connect (self->priv->search_entry, "changed",
725 G_CALLBACK (log_window_search_entry_changed_cb),
728 g_signal_connect (self->priv->search_entry, "activate",
729 G_CALLBACK (log_window_search_entry_activate_cb),
732 g_signal_connect (self->priv->search_entry, "icon-press",
733 G_CALLBACK (log_window_search_entry_icon_pressed_cb),
737 log_window_events_setup (self);
738 log_window_who_setup (self);
739 log_window_what_setup (self);
740 log_window_when_setup (self);
742 log_window_create_observer (self);
744 log_window_who_populate (self);
747 self->priv->webview = webkit_web_view_new ();
748 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow_events),
749 GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
750 gtk_container_add (GTK_CONTAINER (scrolledwindow_events),
751 self->priv->webview);
752 gtk_widget_show (self->priv->webview);
754 empathy_webkit_bind_font_setting (WEBKIT_WEB_VIEW (self->priv->webview),
755 self->priv->gsettings_desktop,
756 EMPATHY_PREFS_DESKTOP_INTERFACE_FONT_NAME);
758 filename = empathy_file_lookup ("empathy-log-window.html", "data");
759 gfile = g_file_new_for_path (filename);
762 webkit_web_view_load_uri (WEBKIT_WEB_VIEW (self->priv->webview),
763 g_file_get_uri (gfile));
764 g_object_unref (gfile);
766 /* handle all navigation externally */
767 g_signal_connect (self->priv->webview, "navigation-policy-decision-requested",
768 G_CALLBACK (events_webview_handle_navigation), self);
770 /* listen to changes to the treemodel */
771 g_signal_connect (self->priv->store_events, "row-inserted",
772 G_CALLBACK (store_events_row_inserted), self);
773 g_signal_connect (self->priv->store_events, "row-changed",
774 G_CALLBACK (store_events_row_changed), self);
775 g_signal_connect (self->priv->store_events, "row-deleted",
776 G_CALLBACK (store_events_row_deleted), self);
777 g_signal_connect (self->priv->store_events, "rows-reordered",
778 G_CALLBACK (store_events_rows_reordered), self);
779 g_signal_connect (self->priv->store_events, "row-has-child-toggled",
780 G_CALLBACK (store_events_has_child_rows), self);
782 /* track clicked row */
783 g_signal_connect (self->priv->webview, "button-press-event",
784 G_CALLBACK (log_window_events_button_press_event), self);
786 log_window_update_buttons_sensitivity (self);
787 gtk_widget_show (GTK_WIDGET (self));
791 empathy_log_window_show (TpAccount *account,
792 const gchar *chat_id,
793 gboolean is_chatroom,
796 log_window = g_object_new (EMPATHY_TYPE_LOG_WINDOW, NULL);
798 gtk_window_present (GTK_WINDOW (log_window));
800 if (account != NULL && chat_id != NULL)
801 select_account_once_ready (log_window, account, chat_id, is_chatroom);
804 gtk_window_set_transient_for (GTK_WINDOW (log_window),
805 GTK_WINDOW (parent));
807 return GTK_WIDGET (log_window);
811 account_equal (TpAccount *a,
814 return g_str_equal (tp_proxy_get_object_path (a),
815 tp_proxy_get_object_path (b));
819 entity_equal (TplEntity *a,
822 return g_str_equal (tpl_entity_get_identifier (a),
823 tpl_entity_get_identifier (b));
827 is_same_confroom (TplEvent *e1,
830 TplEntity *sender1 = tpl_event_get_sender (e1);
831 TplEntity *receiver1 = tpl_event_get_receiver (e1);
832 TplEntity *sender2 = tpl_event_get_sender (e2);
833 TplEntity *receiver2 = tpl_event_get_receiver (e2);
834 TplEntity *room1, *room2;
836 if (receiver1 == NULL || receiver2 == NULL)
839 if (tpl_entity_get_entity_type (sender1) == TPL_ENTITY_ROOM)
841 else if (tpl_entity_get_entity_type (receiver1) == TPL_ENTITY_ROOM)
846 if (tpl_entity_get_entity_type (sender2) == TPL_ENTITY_ROOM)
848 else if (tpl_entity_get_entity_type (receiver2) == TPL_ENTITY_ROOM)
853 return g_str_equal (tpl_entity_get_identifier (room1),
854 tpl_entity_get_identifier (room2));
858 maybe_refresh_logs (TpChannel *channel,
861 GList *accounts = NULL, *entities = NULL, *dates = NULL;
863 TplEventTypeMask event_mask;
864 GDate *anytime = NULL, *today = NULL;
865 GDateTime *now = NULL;
866 gboolean refresh = FALSE;
870 if (!log_window_get_selected (log_window,
871 &accounts, &entities, &anyone, &dates, &event_mask, NULL))
873 DEBUG ("Could not get selected rows");
877 type = tp_channel_get_channel_type (channel);
879 /* If the channel type is not in the What pane, whatever has happened
880 * won't be displayed in the events pane. */
881 if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_TEXT) &&
882 !(event_mask & TPL_EVENT_MASK_TEXT))
884 if ((!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA) ||
885 !tp_strdiff (type, TPY_IFACE_CHANNEL_TYPE_CALL)) &&
886 !(event_mask & TPL_EVENT_MASK_CALL))
889 anytime = g_date_new_dmy (2, 1, -1);
890 now = g_date_time_new_now_local ();
891 today = g_date_new_dmy (g_date_time_get_day_of_month (now),
892 g_date_time_get_month (now),
893 g_date_time_get_year (now));
895 /* If Today (or anytime) isn't selected, anything that has happened now
896 * won't be displayed. */
897 if (!g_list_find_custom (dates, anytime, (GCompareFunc) g_date_compare) &&
898 !g_list_find_custom (dates, today, (GCompareFunc) g_date_compare))
907 for (acc = accounts, ent = entities;
908 acc != NULL && ent != NULL;
909 acc = g_list_next (acc), ent = g_list_next (ent))
911 if (!account_equal (account, acc->data))
914 if (!tp_strdiff (tp_channel_get_identifier (channel),
915 tpl_entity_get_identifier (ent->data)))
923 tp_clear_pointer (&anytime, g_date_free);
924 tp_clear_pointer (&today, g_date_free);
925 tp_clear_pointer (&now, g_date_time_unref);
926 g_list_free_full (accounts, g_object_unref);
927 g_list_free_full (entities, g_object_unref);
928 g_list_free_full (dates, (GFreeFunc) g_date_free);
932 DEBUG ("Refreshing logs after received event");
934 /* FIXME: We need to populate the entities in case we
935 * didn't have any previous logs with this contact. */
936 log_window_chats_get_messages (log_window, FALSE);
941 on_msg_sent (TpTextChannel *channel,
942 TpSignalledMessage *message,
945 EmpathyLogWindow *self)
947 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
949 maybe_refresh_logs (TP_CHANNEL (channel), account);
953 on_msg_received (TpTextChannel *channel,
954 TpSignalledMessage *message,
955 EmpathyLogWindow *self)
957 TpMessage *msg = TP_MESSAGE (message);
958 TpChannelTextMessageType type = tp_message_get_message_type (msg);
959 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
961 if (type != TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL &&
962 type != TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION)
965 maybe_refresh_logs (TP_CHANNEL (channel), account);
969 on_channel_ended (TpChannel *channel,
973 EmpathyLogWindow *self)
975 if (self->priv->channels != NULL)
976 g_hash_table_remove (self->priv->channels, channel);
980 on_call_ended (TpChannel *channel,
984 EmpathyLogWindow *self)
986 TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
988 maybe_refresh_logs (channel, account);
990 if (self->priv->channels != NULL)
991 g_hash_table_remove (self->priv->channels, channel);
995 observe_channels (TpSimpleObserver *observer,
997 TpConnection *connection,
999 TpChannelDispatchOperation *dispatch_operation,
1001 TpObserveChannelsContext *context,
1004 EmpathyLogWindow *self = user_data;
1008 for (l = channels; l != NULL; l = g_list_next (l))
1010 TpChannel *channel = l->data;
1011 const gchar *type = tp_channel_get_channel_type (channel);
1013 if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_TEXT))
1015 TpTextChannel *text_channel = TP_TEXT_CHANNEL (channel);
1017 g_hash_table_insert (self->priv->channels,
1018 g_object_ref (channel), g_object_ref (account));
1020 tp_g_signal_connect_object (text_channel, "message-sent",
1021 G_CALLBACK (on_msg_sent), self, 0);
1022 tp_g_signal_connect_object (text_channel, "message-received",
1023 G_CALLBACK (on_msg_received), self, 0);
1024 tp_g_signal_connect_object (channel, "invalidated",
1025 G_CALLBACK (on_channel_ended), self, 0);
1027 else if (!tp_strdiff (type, TPY_IFACE_CHANNEL_TYPE_CALL) ||
1028 !tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA))
1030 g_hash_table_insert (self->priv->channels,
1031 g_object_ref (channel), g_object_ref (account));
1033 tp_g_signal_connect_object (channel, "invalidated",
1034 G_CALLBACK (on_call_ended), self, 0);
1038 g_warning ("Unknown channel type: %s", type);
1042 tp_observe_channels_context_accept (context);
1046 log_window_create_observer (EmpathyLogWindow *self)
1048 TpAccountManager *am;
1050 am = tp_account_manager_dup ();
1052 self->priv->observer = tp_simple_observer_new_with_am (am, TRUE, "LogWindow",
1053 TRUE, observe_channels,
1054 g_object_ref (self), g_object_unref);
1056 self->priv->channels = g_hash_table_new_full (g_direct_hash, g_direct_equal,
1057 g_object_unref, g_object_unref);
1059 tp_base_client_take_observer_filter (self->priv->observer,
1061 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1062 TP_IFACE_CHANNEL_TYPE_TEXT,
1064 tp_base_client_take_observer_filter (self->priv->observer,
1066 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1067 TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA,
1069 tp_base_client_take_observer_filter (self->priv->observer,
1071 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1072 TPY_IFACE_CHANNEL_TYPE_CALL,
1075 tp_base_client_register (self->priv->observer, NULL);
1077 g_object_unref (am);
1081 event_get_target (TplEvent *event)
1083 TplEntity *sender = tpl_event_get_sender (event);
1084 TplEntity *receiver = tpl_event_get_receiver (event);
1086 if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
1093 model_is_parent (GtkTreeModel *model,
1097 TplEvent *stored_event;
1100 gboolean found = FALSE;
1103 if (gtk_tree_model_iter_parent (model, &parent, iter))
1106 gtk_tree_model_get (model, iter,
1107 COL_EVENTS_ACCOUNT, &account,
1108 COL_EVENTS_TARGET, &target,
1109 COL_EVENTS_EVENT, &stored_event,
1112 if (G_OBJECT_TYPE (event) == G_OBJECT_TYPE (stored_event) &&
1113 account_equal (account, tpl_event_get_account (event)) &&
1114 (entity_equal (target, event_get_target (event)) ||
1115 is_same_confroom (event, stored_event)))
1120 gtk_tree_model_iter_nth_child (model, &child, iter,
1121 gtk_tree_model_iter_n_children (model, iter) - 1);
1123 gtk_tree_model_get (model, &child,
1124 COL_EVENTS_TS, ×tamp,
1127 if (ABS (tpl_event_get_timestamp (event) - timestamp) < MAX_GAP)
1129 /* The gap is smaller than 30 min */
1134 g_object_unref (stored_event);
1135 g_object_unref (account);
1136 g_object_unref (target);
1142 get_display_string_for_chat_message (EmpathyMessage *message,
1145 EmpathyContact *sender, *receiver, *target;
1146 TplEntity *ent_sender, *ent_receiver;
1147 const gchar *format;
1149 sender = empathy_message_get_sender (message);
1150 receiver = empathy_message_get_receiver (message);
1152 ent_sender = tpl_event_get_sender (event);
1153 ent_receiver = tpl_event_get_receiver (event);
1155 /* If this is a MUC, we want to show "Chat in <room>". */
1156 if (tpl_entity_get_entity_type (ent_sender) == TPL_ENTITY_ROOM ||
1157 (ent_receiver != NULL &&
1158 tpl_entity_get_entity_type (ent_receiver) == TPL_ENTITY_ROOM))
1159 format = _("Chat in %s");
1161 format = _("Chat with %s");
1163 if (tpl_entity_get_entity_type (ent_sender) == TPL_ENTITY_ROOM)
1165 else if (ent_receiver != NULL &&
1166 tpl_entity_get_entity_type (ent_receiver) == TPL_ENTITY_ROOM)
1168 else if (empathy_contact_is_user (sender))
1173 return g_markup_printf_escaped (format, empathy_contact_get_alias (target));
1177 get_parent_iter_for_message (TplEvent *event,
1178 EmpathyMessage *message,
1179 GtkTreeIter *parent)
1181 GtkTreeStore *store;
1182 GtkTreeModel *model;
1184 gboolean parent_found = FALSE;
1187 store = log_window->priv->store_events;
1188 model = GTK_TREE_MODEL (store);
1190 for (next = gtk_tree_model_get_iter_first (model, &iter);
1192 next = gtk_tree_model_iter_next (model, &iter))
1194 if ((parent_found = model_is_parent (model, &iter, event)))
1205 gchar *body, *pretty_date;
1207 date = g_date_time_new_from_unix_local (
1208 tpl_event_get_timestamp (event));
1210 pretty_date = g_date_time_format (date,
1211 C_("A date with the time", "%A, %e %B %Y %X"));
1213 body = get_display_string_for_chat_message (message, event);
1215 gtk_tree_store_append (store, &iter, NULL);
1216 gtk_tree_store_set (store, &iter,
1217 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1218 COL_EVENTS_PRETTY_DATE, pretty_date,
1219 COL_EVENTS_TEXT, body,
1220 COL_EVENTS_ICON, "format-justify-fill",
1221 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1222 COL_EVENTS_TARGET, event_get_target (event),
1223 COL_EVENTS_EVENT, event,
1229 g_free (pretty_date);
1230 g_date_time_unref (date);
1234 static const gchar *
1235 get_icon_for_event (TplEvent *event)
1237 const gchar *icon = NULL;
1239 if (TPL_IS_TEXT_EVENT (event))
1241 TplTextEvent *text = TPL_TEXT_EVENT (event);
1243 if (!tp_str_empty (tpl_text_event_get_supersedes_token (text)))
1244 icon = EMPATHY_IMAGE_EDIT_MESSAGE;
1246 #ifdef HAVE_CALL_LOGS
1247 else if (TPL_IS_CALL_EVENT (event))
1249 TplCallEvent *call = TPL_CALL_EVENT (event);
1250 TplCallEndReason reason = tpl_call_event_get_end_reason (call);
1251 TplEntity *sender = tpl_event_get_sender (event);
1252 TplEntity *receiver = tpl_event_get_receiver (event);
1254 if (reason == TPL_CALL_END_REASON_NO_ANSWER)
1255 icon = EMPATHY_IMAGE_CALL_MISSED;
1256 else if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
1257 icon = EMPATHY_IMAGE_CALL_OUTGOING;
1258 else if (tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF)
1259 icon = EMPATHY_IMAGE_CALL_INCOMING;
1267 log_window_append_chat_message (TplEvent *event,
1268 EmpathyMessage *message)
1270 GtkTreeStore *store = log_window->priv->store_events;
1271 GtkTreeIter iter, parent;
1272 gchar *pretty_date, *alias, *body;
1274 EmpathyStringParser *parsers;
1277 date = g_date_time_new_from_unix_local (
1278 tpl_event_get_timestamp (event));
1280 pretty_date = g_date_time_format (date, "%X");
1282 get_parent_iter_for_message (event, message, &parent);
1284 alias = g_markup_escape_text (
1285 tpl_entity_get_alias (tpl_event_get_sender (event)), -1);
1287 /* escape the text */
1288 parsers = empathy_webkit_get_string_parser (
1289 g_settings_get_boolean (log_window->priv->gsettings_chat,
1290 EMPATHY_PREFS_CHAT_SHOW_SMILEYS));
1291 msg = g_string_new ("");
1293 empathy_string_parser_substr (empathy_message_get_body (message), -1,
1296 if (tpl_text_event_get_message_type (TPL_TEXT_EVENT (event))
1297 == TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION)
1299 /* Translators: this is an emote: '* Danielle waves' */
1300 body = g_strdup_printf (_("<i>* %s %s</i>"), alias, msg->str);
1304 /* Translators: this is a message: 'Danielle: hello'
1305 * The string in bold is the sender's name */
1306 body = g_strdup_printf (_("<b>%s:</b> %s"), alias, msg->str);
1309 gtk_tree_store_append (store, &iter, &parent);
1310 gtk_tree_store_set (store, &iter,
1311 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1312 COL_EVENTS_PRETTY_DATE, pretty_date,
1313 COL_EVENTS_TEXT, body,
1314 COL_EVENTS_ICON, get_icon_for_event (event),
1315 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1316 COL_EVENTS_TARGET, event_get_target (event),
1317 COL_EVENTS_EVENT, event,
1320 g_string_free (msg, TRUE);
1323 g_free (pretty_date);
1324 g_date_time_unref (date);
1327 #ifdef HAVE_CALL_LOGS
1329 log_window_append_call (TplEvent *event,
1330 EmpathyMessage *message)
1332 TplCallEvent *call = TPL_CALL_EVENT (event);
1333 GtkTreeStore *store = log_window->priv->store_events;
1334 GtkTreeIter iter, child;
1335 gchar *pretty_date, *duration, *finished;
1336 GDateTime *started_date, *finished_date;
1339 /* If searching, only add the call if the search string appears anywhere */
1340 if (!EMP_STR_EMPTY (log_window->priv->last_find))
1342 if (strstr (tpl_entity_get_identifier (tpl_event_get_sender (event)),
1343 log_window->priv->last_find) == NULL &&
1344 strstr (tpl_entity_get_identifier (tpl_event_get_receiver (event)),
1345 log_window->priv->last_find) == NULL &&
1346 strstr (tpl_call_event_get_detailed_end_reason (call),
1347 log_window->priv->last_find) == NULL)
1349 DEBUG ("TplCallEvent doesn't match search string, ignoring");
1354 started_date = g_date_time_new_from_unix_local (
1355 tpl_event_get_timestamp (event));
1357 pretty_date = g_date_time_format (started_date,
1358 C_("A date with the time", "%A, %e %B %Y %X"));
1360 gtk_tree_store_append (store, &iter, NULL);
1361 gtk_tree_store_set (store, &iter,
1362 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1363 COL_EVENTS_PRETTY_DATE, pretty_date,
1364 COL_EVENTS_TEXT, empathy_message_get_body (message),
1365 COL_EVENTS_ICON, get_icon_for_event (event),
1366 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1367 COL_EVENTS_TARGET, event_get_target (event),
1368 COL_EVENTS_EVENT, event,
1371 if (tpl_call_event_get_end_reason (call) != TPL_CALL_END_REASON_NO_ANSWER)
1376 span = tpl_call_event_get_duration (TPL_CALL_EVENT (event));
1380 tmp = g_strdup_printf ("%" G_GINT64_FORMAT, span);
1381 duration = g_strdup_printf (
1382 ngettext ("%s second", "%s seconds", span), tmp);
1387 tmp = g_strdup_printf ("%" G_GINT64_FORMAT, span / 60);
1388 duration = g_strdup_printf (
1389 ngettext ("%s minute", "%s minutes", span / 60), tmp);
1393 finished_date = g_date_time_add (started_date, -span);
1394 finished = g_date_time_format (finished_date, "%X");
1395 g_date_time_unref (finished_date);
1397 body = g_strdup_printf (_("Call took %s, ended at %s"),
1398 duration, finished);
1403 gtk_tree_store_append (store, &child, &iter);
1404 gtk_tree_store_set (store, &child,
1405 COL_EVENTS_TS, tpl_event_get_timestamp (event),
1406 COL_EVENTS_TEXT, body,
1407 COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1408 COL_EVENTS_TARGET, event_get_target (event),
1409 COL_EVENTS_EVENT, event,
1415 g_free (pretty_date);
1416 g_date_time_unref (started_date);
1421 log_window_append_message (TplEvent *event,
1422 EmpathyMessage *message)
1424 if (TPL_IS_TEXT_EVENT (event))
1425 log_window_append_chat_message (event, message);
1426 #ifdef HAVE_CALL_LOGS
1427 else if (TPL_IS_CALL_EVENT (event))
1428 log_window_append_call (event, message);
1431 DEBUG ("Message type not handled");
1435 add_all_accounts_and_entities (GList **accounts,
1439 GtkTreeModel *model;
1442 view = GTK_TREE_VIEW (log_window->priv->treeview_who);
1443 model = gtk_tree_view_get_model (view);
1445 if (!gtk_tree_model_get_iter_first (model, &iter))
1454 gtk_tree_model_get (model, &iter,
1455 COL_WHO_ACCOUNT, &account,
1456 COL_WHO_TARGET, &entity,
1457 COL_WHO_TYPE, &type,
1460 if (type != COL_TYPE_NORMAL)
1463 if (accounts != NULL)
1464 *accounts = g_list_append (*accounts, account);
1466 if (entities != NULL)
1467 *entities = g_list_append (*entities, entity);
1469 while (gtk_tree_model_iter_next (model, &iter));
1473 log_window_get_selected (EmpathyLogWindow *self,
1478 TplEventTypeMask *event_mask,
1479 EventSubtype *subtype)
1482 GtkTreeModel *model;
1483 GtkTreeSelection *selection;
1485 TplEventTypeMask ev = 0;
1486 EventSubtype st = 0;
1490 view = GTK_TREE_VIEW (self->priv->treeview_who);
1491 model = gtk_tree_view_get_model (view);
1492 selection = gtk_tree_view_get_selection (view);
1494 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1498 if (accounts != NULL)
1500 if (entities != NULL)
1505 for (l = paths; l != NULL; l = l->next)
1507 GtkTreePath *path = l->data;
1511 gtk_tree_model_get_iter (model, &iter, path);
1512 gtk_tree_model_get (model, &iter,
1513 COL_WHO_ACCOUNT, &account,
1514 COL_WHO_TARGET, &entity,
1515 COL_WHO_TYPE, &type,
1518 if (type == COL_TYPE_ANY)
1520 if (accounts != NULL || entities != NULL)
1521 add_all_accounts_and_entities (accounts, entities);
1527 if (accounts != NULL)
1528 *accounts = g_list_append (*accounts, g_object_ref (account));
1530 if (entities != NULL)
1531 *entities = g_list_append (*entities, g_object_ref (entity));
1533 g_object_unref (account);
1534 g_object_unref (entity);
1536 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1538 view = GTK_TREE_VIEW (self->priv->treeview_what);
1539 model = gtk_tree_view_get_model (view);
1540 selection = gtk_tree_view_get_selection (view);
1542 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1543 for (l = paths; l != NULL; l = l->next)
1545 GtkTreePath *path = l->data;
1546 TplEventTypeMask mask;
1547 EventSubtype submask;
1549 gtk_tree_model_get_iter (model, &iter, path);
1550 gtk_tree_model_get (model, &iter,
1551 COL_WHAT_TYPE, &mask,
1552 COL_WHAT_SUBTYPE, &submask,
1558 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1560 view = GTK_TREE_VIEW (self->priv->treeview_when);
1561 model = gtk_tree_view_get_model (view);
1562 selection = gtk_tree_view_get_selection (view);
1568 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1569 for (l = paths; l != NULL; l = l->next)
1571 GtkTreePath *path = l->data;
1574 gtk_tree_model_get_iter (model, &iter, path);
1575 gtk_tree_model_get (model, &iter,
1576 COL_WHEN_DATE, &date,
1579 *dates = g_list_append (*dates, date);
1581 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1584 if (event_mask != NULL)
1587 if (subtype != NULL)
1594 model_has_entity (GtkTreeModel *model,
1599 TplLogSearchHit *hit = data;
1602 gboolean ret = FALSE;
1604 gtk_tree_model_get (model, iter,
1606 COL_WHO_ACCOUNT, &a,
1609 if (e != NULL && entity_equal (hit->target, e) &&
1610 a != NULL && account_equal (hit->account, a))
1612 ret = has_element = TRUE;
1615 tp_clear_object (&e);
1616 tp_clear_object (&a);
1622 model_has_date (GtkTreeModel *model,
1630 gtk_tree_model_get (model, iter,
1634 if (!g_date_compare (date, d))
1644 get_events_for_date (TplActionChain *chain, gpointer user_data);
1647 populate_events_from_search_hits (GList *accounts,
1651 TplEventTypeMask event_mask;
1652 EventSubtype subtype;
1655 gboolean is_anytime = FALSE;
1657 if (!log_window_get_selected (log_window,
1658 NULL, NULL, NULL, NULL, &event_mask, &subtype))
1661 anytime = g_date_new_dmy (2, 1, -1);
1662 if (g_list_find_custom (dates, anytime, (GCompareFunc) g_date_compare))
1665 for (l = log_window->priv->hits; l != NULL; l = l->next)
1667 TplLogSearchHit *hit = l->data;
1669 gboolean found = FALSE;
1671 /* Protect against invalid data (corrupt or old log files). */
1672 if (hit->account == NULL || hit->target == NULL)
1675 for (acc = accounts, targ = targets;
1676 acc != NULL && targ != NULL && !found;
1677 acc = acc->next, targ = targ->next)
1679 TpAccount *account = acc->data;
1680 TplEntity *target = targ->data;
1682 if (account_equal (hit->account, account) &&
1683 entity_equal (hit->target, target))
1691 g_list_find_custom (dates, hit->date, (GCompareFunc) g_date_compare)
1696 ctx = ctx_new (log_window, hit->account, hit->target, hit->date,
1697 event_mask, subtype, log_window->priv->count);
1698 _tpl_action_chain_append (log_window->priv->chain,
1699 get_events_for_date, ctx);
1704 _tpl_action_chain_start (log_window->priv->chain);
1706 g_date_free (anytime);
1710 format_date_for_display (GDate *date)
1716 /* g_date_strftime sucks */
1718 now = g_date_new ();
1719 g_date_set_time_t (now, time (NULL));
1721 days_elapsed = g_date_days_between (date, now);
1723 if (days_elapsed < 0)
1727 else if (days_elapsed == 0)
1729 text = g_strdup (_("Today"));
1731 else if (days_elapsed == 1)
1733 text = g_strdup (_("Yesterday"));
1739 dt = g_date_time_new_utc (g_date_get_year (date),
1740 g_date_get_month (date), g_date_get_day (date),
1743 if (days_elapsed <= 7)
1744 text = g_date_time_format (dt, "%A");
1746 text = g_date_time_format (dt,
1747 /* Translators: A date such as '23 May 2010' (strftime format) */
1750 g_date_time_unref (dt);
1759 populate_dates_from_search_hits (GList *accounts,
1764 GtkTreeModel *model;
1765 GtkListStore *store;
1766 GtkTreeSelection *selection;
1769 if (log_window == NULL)
1772 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
1773 model = gtk_tree_view_get_model (view);
1774 store = GTK_LIST_STORE (model);
1775 selection = gtk_tree_view_get_selection (view);
1777 for (l = log_window->priv->hits; l != NULL; l = l->next)
1779 TplLogSearchHit *hit = l->data;
1781 gboolean found = FALSE;
1783 /* Protect against invalid data (corrupt or old log files). */
1784 if (hit->account == NULL || hit->target == NULL)
1787 for (acc = accounts, targ = targets;
1788 acc != NULL && targ != NULL && !found;
1789 acc = acc->next, targ = targ->next)
1791 TpAccount *account = acc->data;
1792 TplEntity *target = targ->data;
1794 if (account_equal (hit->account, account) &&
1795 entity_equal (hit->target, target))
1802 /* Add the date if it's not already there */
1803 has_element = FALSE;
1804 gtk_tree_model_foreach (model, model_has_date, hit->date);
1807 gchar *text = format_date_for_display (hit->date);
1809 gtk_list_store_append (store, &iter);
1810 gtk_list_store_set (store, &iter,
1811 COL_WHEN_DATE, hit->date,
1812 COL_WHEN_TEXT, text,
1813 COL_WHEN_ICON, CALENDAR_ICON,
1818 if (gtk_tree_model_get_iter_first (model, &iter))
1820 gtk_list_store_prepend (store, &iter);
1821 gtk_list_store_set (store, &iter,
1822 COL_WHEN_DATE, g_date_new_dmy (1, 1, -1),
1823 COL_WHEN_TEXT, "separator",
1826 gtk_list_store_prepend (store, &iter);
1827 gtk_list_store_set (store, &iter,
1828 COL_WHEN_DATE, g_date_new_dmy (2, 1, -1),
1829 COL_WHEN_TEXT, _("Anytime"),
1832 if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 2))
1833 gtk_tree_selection_select_iter (selection, &iter);
1838 populate_entities_from_search_hits (void)
1840 EmpathyAccountChooser *account_chooser;
1843 GtkTreeModel *model;
1844 GtkTreeSelection *selection;
1846 GtkListStore *store;
1849 view = GTK_TREE_VIEW (log_window->priv->treeview_who);
1850 model = gtk_tree_view_get_model (view);
1851 store = GTK_LIST_STORE (model);
1852 selection = gtk_tree_view_get_selection (view);
1854 gtk_list_store_clear (store);
1856 account_chooser = EMPATHY_ACCOUNT_CHOOSER (log_window->priv->account_chooser);
1857 account = empathy_account_chooser_get_account (account_chooser);
1859 for (l = log_window->priv->hits; l; l = l->next)
1861 TplLogSearchHit *hit = l->data;
1863 /* Protect against invalid data (corrupt or old log files). */
1864 if (hit->account == NULL || hit->target == NULL)
1867 /* Filter based on the selected account */
1868 if (account != NULL && !account_equal (account, hit->account))
1871 /* Add the entity if it's not already there */
1872 has_element = FALSE;
1873 gtk_tree_model_foreach (model, model_has_entity, hit);
1876 TplEntityType type = tpl_entity_get_entity_type (hit->target);
1877 EmpathyContact *contact;
1880 gboolean room = type == TPL_ENTITY_ROOM;
1882 contact = empathy_contact_from_tpl_contact (hit->account,
1885 name = empathy_contact_get_alias (contact);
1886 sort_key = g_utf8_collate_key (name, -1);
1888 gtk_list_store_append (store, &iter);
1889 gtk_list_store_set (store, &iter,
1890 COL_WHO_TYPE, COL_TYPE_NORMAL,
1891 COL_WHO_ICON, room ? EMPATHY_IMAGE_GROUP_MESSAGE
1892 : EMPATHY_IMAGE_AVATAR_DEFAULT,
1894 COL_WHO_NAME_SORT_KEY, sort_key,
1895 COL_WHO_ID, tpl_entity_get_identifier (hit->target),
1896 COL_WHO_ACCOUNT, hit->account,
1897 COL_WHO_TARGET, hit->target,
1901 g_object_unref (contact);
1905 if (gtk_tree_model_get_iter_first (model, &iter))
1907 gtk_list_store_prepend (store, &iter);
1908 gtk_list_store_set (store, &iter,
1909 COL_WHO_TYPE, COL_TYPE_SEPARATOR,
1910 COL_WHO_NAME, "separator",
1913 gtk_list_store_prepend (store, &iter);
1914 gtk_list_store_set (store, &iter,
1915 COL_WHO_TYPE, COL_TYPE_ANY,
1916 COL_WHO_NAME, _("Anyone"),
1920 /* Select 'Anyone' */
1921 if (gtk_tree_model_get_iter_first (model, &iter))
1922 gtk_tree_selection_select_iter (selection, &iter);
1926 log_manager_searched_new_cb (GObject *manager,
1927 GAsyncResult *result,
1932 GtkTreeSelection *selection;
1933 GError *error = NULL;
1935 if (log_window == NULL)
1938 if (!tpl_log_manager_search_finish (TPL_LOG_MANAGER (manager),
1939 result, &hits, &error))
1941 DEBUG ("%s. Aborting", error->message);
1942 g_error_free (error);
1946 tp_clear_pointer (&log_window->priv->hits, tpl_log_manager_search_free);
1947 log_window->priv->hits = hits;
1949 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
1950 selection = gtk_tree_view_get_selection (view);
1952 g_signal_handlers_unblock_by_func (selection,
1953 log_window_when_changed_cb,
1956 populate_entities_from_search_hits ();
1960 log_window_find_populate (EmpathyLogWindow *self,
1961 const gchar *search_criteria)
1964 GtkTreeModel *model;
1965 GtkTreeSelection *selection;
1966 GtkListStore *store;
1968 gtk_tree_store_clear (self->priv->store_events);
1970 view = GTK_TREE_VIEW (self->priv->treeview_who);
1971 model = gtk_tree_view_get_model (view);
1972 store = GTK_LIST_STORE (model);
1974 gtk_list_store_clear (store);
1976 view = GTK_TREE_VIEW (self->priv->treeview_when);
1977 model = gtk_tree_view_get_model (view);
1978 store = GTK_LIST_STORE (model);
1979 selection = gtk_tree_view_get_selection (view);
1981 gtk_list_store_clear (store);
1983 if (EMP_STR_EMPTY (search_criteria))
1985 tp_clear_pointer (&self->priv->hits, tpl_log_manager_search_free);
1986 webkit_web_view_set_highlight_text_matches (
1987 WEBKIT_WEB_VIEW (self->priv->webview), FALSE);
1988 log_window_who_populate (self);
1992 g_signal_handlers_block_by_func (selection,
1993 log_window_when_changed_cb,
1996 /* highlight the search text */
1997 webkit_web_view_mark_text_matches (WEBKIT_WEB_VIEW (self->priv->webview),
1998 search_criteria, FALSE, 0);
2000 tpl_log_manager_search_async (self->priv->log_manager,
2001 search_criteria, TPL_EVENT_MASK_ANY,
2002 log_manager_searched_new_cb, NULL);
2006 start_find_search (EmpathyLogWindow *self)
2010 str = gtk_entry_get_text (GTK_ENTRY (self->priv->search_entry));
2012 /* Don't find the same crap again */
2013 if (self->priv->last_find && !tp_strdiff (self->priv->last_find, str))
2016 g_free (self->priv->last_find);
2017 self->priv->last_find = g_strdup (str);
2019 log_window_find_populate (self, str);
2025 log_window_search_entry_changed_cb (GtkWidget *entry,
2026 EmpathyLogWindow *self)
2030 str = gtk_entry_get_text (GTK_ENTRY (self->priv->search_entry));
2032 if (!tp_str_empty (str))
2034 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
2035 GTK_ENTRY_ICON_SECONDARY, "edit-clear-symbolic");
2036 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
2037 GTK_ENTRY_ICON_SECONDARY, TRUE);
2041 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
2042 GTK_ENTRY_ICON_SECONDARY, "edit-find-symbolic");
2043 gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
2044 GTK_ENTRY_ICON_SECONDARY, FALSE);
2047 if (self->priv->source != 0)
2048 g_source_remove (self->priv->source);
2049 self->priv->source = g_timeout_add (500, (GSourceFunc) start_find_search,
2054 log_window_search_entry_activate_cb (GtkWidget *entry,
2055 EmpathyLogWindow *self)
2057 start_find_search (self);
2061 log_window_search_entry_icon_pressed_cb (GtkEntry *entry,
2062 GtkEntryIconPosition icon_pos,
2066 if (icon_pos != GTK_ENTRY_ICON_SECONDARY)
2069 gtk_entry_buffer_set_text (gtk_entry_get_buffer (entry),
2074 log_window_update_buttons_sensitivity (EmpathyLogWindow *self)
2077 GtkTreeModel *model;
2078 GtkTreeSelection *selection;
2079 EmpathyCapabilities capabilities;
2085 gboolean profile, chat, call, video;
2087 profile = chat = call = video = FALSE;
2089 tp_clear_object (&self->priv->button_video_binding);
2090 tp_clear_object (&self->priv->selected_contact);
2092 view = GTK_TREE_VIEW (self->priv->treeview_who);
2093 model = gtk_tree_view_get_model (view);
2094 selection = gtk_tree_view_get_selection (view);
2096 profile = chat = call = video = FALSE;
2098 if (!gtk_tree_model_get_iter_first (model, &iter))
2101 if (gtk_tree_selection_count_selected_rows (selection) != 1)
2104 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2107 paths = gtk_tree_selection_get_selected_rows (selection, &model);
2108 g_return_if_fail (paths != NULL);
2111 gtk_tree_model_get_iter (model, &iter, path);
2112 gtk_tree_model_get (model, &iter,
2113 COL_WHO_ACCOUNT, &account,
2114 COL_WHO_TARGET, &target,
2117 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
2119 self->priv->selected_contact = empathy_contact_from_tpl_contact (account,
2122 g_object_unref (account);
2123 g_object_unref (target);
2125 capabilities = empathy_contact_get_capabilities (self->priv->selected_contact);
2127 profile = chat = TRUE;
2128 call = capabilities & EMPATHY_CAPABILITIES_AUDIO;
2129 video = capabilities & EMPATHY_CAPABILITIES_VIDEO;
2134 /* If the Who pane doesn't contain a contact (e.g. it has many
2135 * selected, or has 'Anyone', let's try to get the contact from
2136 * the selected event. */
2138 if (self->priv->events_contact != NULL)
2139 self->priv->selected_contact = g_object_ref (self->priv->events_contact);
2143 capabilities = empathy_contact_get_capabilities (self->priv->selected_contact);
2145 profile = chat = TRUE;
2146 call = capabilities & EMPATHY_CAPABILITIES_AUDIO;
2147 video = capabilities & EMPATHY_CAPABILITIES_VIDEO;
2150 self->priv->button_video_binding = g_object_bind_property (
2151 self->priv->camera_monitor, "available",
2152 self->priv->button_video, "sensitive",
2153 G_BINDING_SYNC_CREATE);
2156 gtk_widget_set_sensitive (self->priv->button_profile, profile);
2157 gtk_widget_set_sensitive (self->priv->button_chat, chat);
2158 gtk_widget_set_sensitive (self->priv->button_call, call);
2160 /* Don't override the binding */
2162 gtk_widget_set_sensitive (self->priv->button_video, video);
2166 log_window_update_what_iter_sensitivity (GtkTreeModel *model,
2170 GtkTreeStore *store = GTK_TREE_STORE (model);
2174 gtk_tree_store_set (store, iter,
2175 COL_WHAT_SENSITIVE, sensitive,
2178 for (next = gtk_tree_model_iter_children (model, &child, iter);
2180 next = gtk_tree_model_iter_next (model, &child))
2182 gtk_tree_store_set (store, &child,
2183 COL_WHAT_SENSITIVE, sensitive,
2189 log_window_update_what_sensitivity (EmpathyLogWindow *self)
2192 GtkTreeModel *model;
2194 GList *accounts, *targets, *acc, *targ;
2197 if (!log_window_get_selected (self, &accounts, &targets, NULL, NULL,
2201 view = GTK_TREE_VIEW (self->priv->treeview_what);
2202 model = gtk_tree_view_get_model (view);
2204 /* For each event type... */
2205 for (next = gtk_tree_model_get_iter_first (model, &iter);
2207 next = gtk_tree_model_iter_next (model, &iter))
2209 TplEventTypeMask type;
2211 gtk_tree_model_get (model, &iter,
2212 COL_WHAT_TYPE, &type,
2215 /* ...we set the type and its subtypes (if any) unsensitive... */
2216 log_window_update_what_iter_sensitivity (model, &iter, FALSE);
2218 for (acc = accounts, targ = targets;
2219 acc != NULL && targ != NULL;
2220 acc = acc->next, targ = targ->next)
2222 TpAccount *account = acc->data;
2223 TplEntity *target = targ->data;
2225 if (tpl_log_manager_exists (self->priv->log_manager,
2226 account, target, type))
2228 /* And then we set it (and its subtypes, again, if any)
2229 * as sensitive if there are logs of that type. */
2230 log_window_update_what_iter_sensitivity (model, &iter, TRUE);
2236 g_list_free_full (accounts, g_object_unref);
2237 g_list_free_full (targets, g_object_unref);
2241 log_window_who_changed_cb (GtkTreeSelection *selection,
2242 EmpathyLogWindow *self)
2245 GtkTreeModel *model;
2248 DEBUG ("log_window_who_changed_cb");
2250 view = gtk_tree_selection_get_tree_view (selection);
2251 model = gtk_tree_view_get_model (view);
2253 if (gtk_tree_model_get_iter_first (model, &iter))
2255 /* If 'Anyone' is selected, everything else should be deselected */
2256 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2258 g_signal_handlers_block_by_func (selection,
2259 log_window_who_changed_cb,
2262 gtk_tree_selection_unselect_all (selection);
2263 gtk_tree_selection_select_iter (selection, &iter);
2265 g_signal_handlers_unblock_by_func (selection,
2266 log_window_who_changed_cb,
2271 log_window_update_what_sensitivity (self);
2272 log_window_update_buttons_sensitivity (self);
2274 /* The contact changed, so the dates need to be updated */
2275 log_window_chats_get_messages (self, TRUE);
2279 log_manager_got_entities_cb (GObject *manager,
2280 GAsyncResult *result,
2283 Ctx *ctx = user_data;
2287 GtkTreeModel *model;
2288 GtkTreeSelection *selection;
2289 GtkListStore *store;
2291 GError *error = NULL;
2292 gboolean select_account = FALSE;
2294 if (log_window == NULL)
2297 if (log_window->priv->count != ctx->count)
2300 if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager),
2301 result, &entities, &error))
2303 DEBUG ("%s. Aborting", error->message);
2304 g_error_free (error);
2308 view = GTK_TREE_VIEW (ctx->self->priv->treeview_who);
2309 model = gtk_tree_view_get_model (view);
2310 selection = gtk_tree_view_get_selection (view);
2311 store = GTK_LIST_STORE (model);
2313 /* Block signals to stop the logs being retrieved prematurely */
2314 g_signal_handlers_block_by_func (selection,
2315 log_window_who_changed_cb, ctx->self);
2317 for (l = entities; l; l = l->next)
2319 TplEntity *entity = TPL_ENTITY (l->data);
2320 TplEntityType type = tpl_entity_get_entity_type (entity);
2321 EmpathyContact *contact;
2324 gboolean room = type == TPL_ENTITY_ROOM;
2326 contact = empathy_contact_from_tpl_contact (ctx->account, entity);
2328 name = empathy_contact_get_alias (contact);
2329 sort_key = g_utf8_collate_key (name, -1);
2331 gtk_list_store_append (store, &iter);
2332 gtk_list_store_set (store, &iter,
2333 COL_WHO_TYPE, COL_TYPE_NORMAL,
2334 COL_WHO_ICON, room ? EMPATHY_IMAGE_GROUP_MESSAGE
2335 : EMPATHY_IMAGE_AVATAR_DEFAULT,
2337 COL_WHO_NAME_SORT_KEY, sort_key,
2338 COL_WHO_ID, tpl_entity_get_identifier (entity),
2339 COL_WHO_ACCOUNT, ctx->account,
2340 COL_WHO_TARGET, entity,
2344 g_object_unref (contact);
2346 if (ctx->self->priv->selected_account != NULL &&
2347 !tp_strdiff (tp_proxy_get_object_path (ctx->account),
2348 tp_proxy_get_object_path (ctx->self->priv->selected_account)))
2349 select_account = TRUE;
2351 g_list_free_full (entities, g_object_unref);
2353 if (gtk_tree_model_get_iter_first (model, &iter))
2357 gtk_tree_model_get (model, &iter,
2358 COL_WHO_TYPE, &type,
2361 if (type != COL_TYPE_ANY)
2363 gtk_list_store_prepend (store, &iter);
2364 gtk_list_store_set (store, &iter,
2365 COL_WHO_TYPE, COL_TYPE_SEPARATOR,
2366 COL_WHO_NAME, "separator",
2369 gtk_list_store_prepend (store, &iter);
2370 gtk_list_store_set (store, &iter,
2371 COL_WHO_TYPE, COL_TYPE_ANY,
2372 COL_WHO_NAME, _("Anyone"),
2377 /* Unblock signals */
2378 g_signal_handlers_unblock_by_func (selection,
2379 log_window_who_changed_cb,
2382 /* We display the selected account if we populate the model with chats from
2385 log_window_chats_set_selected (ctx->self);
2388 _tpl_action_chain_continue (log_window->priv->chain);
2393 get_entities_for_account (TplActionChain *chain, gpointer user_data)
2395 Ctx *ctx = user_data;
2397 tpl_log_manager_get_entities_async (ctx->self->priv->log_manager, ctx->account,
2398 log_manager_got_entities_cb, ctx);
2402 select_first_entity (TplActionChain *chain, gpointer user_data)
2404 EmpathyLogWindow *self = user_data;
2406 GtkTreeModel *model;
2407 GtkTreeSelection *selection;
2410 view = GTK_TREE_VIEW (self->priv->treeview_who);
2411 model = gtk_tree_view_get_model (view);
2412 selection = gtk_tree_view_get_selection (view);
2414 if (gtk_tree_model_get_iter_first (model, &iter))
2415 gtk_tree_selection_select_iter (selection, &iter);
2417 _tpl_action_chain_continue (self->priv->chain);
2421 log_window_who_populate (EmpathyLogWindow *self)
2423 EmpathyAccountChooser *account_chooser;
2425 gboolean all_accounts;
2427 GtkTreeModel *model;
2428 GtkTreeSelection *selection;
2429 GtkListStore *store;
2432 if (self->priv->hits != NULL)
2434 populate_entities_from_search_hits ();
2438 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
2439 account = empathy_account_chooser_dup_account (account_chooser);
2440 all_accounts = empathy_account_chooser_has_all_selected (account_chooser);
2442 view = GTK_TREE_VIEW (self->priv->treeview_who);
2443 model = gtk_tree_view_get_model (view);
2444 selection = gtk_tree_view_get_selection (view);
2445 store = GTK_LIST_STORE (model);
2447 /* Block signals to stop the logs being retrieved prematurely */
2448 g_signal_handlers_block_by_func (selection,
2449 log_window_who_changed_cb,
2452 gtk_list_store_clear (store);
2454 /* Unblock signals */
2455 g_signal_handlers_unblock_by_func (selection,
2456 log_window_who_changed_cb,
2459 _tpl_action_chain_clear (self->priv->chain);
2460 self->priv->count++;
2462 if (!all_accounts && account == NULL)
2466 else if (!all_accounts)
2468 ctx = ctx_new (self, account, NULL, NULL, 0, 0, self->priv->count);
2469 _tpl_action_chain_append (self->priv->chain, get_entities_for_account, ctx);
2473 TpAccountManager *manager;
2474 GList *accounts, *l;
2476 manager = empathy_account_chooser_get_account_manager (account_chooser);
2477 accounts = tp_account_manager_get_valid_accounts (manager);
2479 for (l = accounts; l != NULL; l = l->next)
2483 ctx = ctx_new (self, account, NULL, NULL, 0, 0, self->priv->count);
2484 _tpl_action_chain_append (self->priv->chain,
2485 get_entities_for_account, ctx);
2488 g_list_free (accounts);
2490 _tpl_action_chain_append (self->priv->chain, select_first_entity, self);
2491 _tpl_action_chain_start (self->priv->chain);
2495 sort_by_name_key (GtkTreeModel *model,
2504 gtk_tree_model_get (model, a,
2505 COL_WHO_TYPE, &type1,
2506 COL_WHO_NAME_SORT_KEY, &key1,
2509 gtk_tree_model_get (model, b,
2510 COL_WHO_TYPE, &type2,
2511 COL_WHO_NAME_SORT_KEY, &key2,
2514 if (type1 == COL_TYPE_ANY)
2516 else if (type2 == COL_TYPE_ANY)
2518 else if (type1 == COL_TYPE_SEPARATOR)
2520 else if (type2 == COL_TYPE_SEPARATOR)
2523 ret = g_strcmp0 (key1, key2);
2532 who_row_is_separator (GtkTreeModel *model,
2538 gtk_tree_model_get (model, iter,
2539 COL_WHO_TYPE, &type,
2542 return (type == COL_TYPE_SEPARATOR);
2546 log_window_find_row (EmpathyLogWindow *self,
2547 GdkEventButton *event)
2549 WebKitHitTestResult *hit = webkit_web_view_get_hit_test_result (
2550 WEBKIT_WEB_VIEW (self->priv->webview), event);
2551 WebKitDOMNode *inner_node;
2553 tp_clear_object (&self->priv->events_contact);
2556 "inner-node", &inner_node,
2559 if (inner_node != NULL)
2561 GtkTreeModel *model = GTK_TREE_MODEL (self->priv->store_events);
2562 WebKitDOMNode *node;
2563 const char *path = NULL;
2566 /* walk back up the DOM tree looking for a node with empathy:path set */
2567 for (node = inner_node; node != NULL;
2568 node = webkit_dom_node_get_parent_node (node))
2570 if (!WEBKIT_DOM_IS_ELEMENT (node))
2573 path = webkit_dom_element_get_attribute_ns (
2574 WEBKIT_DOM_ELEMENT (node), EMPATHY_NS, "path");
2576 if (!tp_str_empty (path))
2580 /* look up the contact for this path */
2581 if (!tp_str_empty (path) &&
2582 gtk_tree_model_get_iter_from_string (model, &iter, path))
2587 gtk_tree_model_get (model, &iter,
2588 COL_EVENTS_ACCOUNT, &account,
2589 COL_EVENTS_TARGET, &target,
2592 self->priv->events_contact = empathy_contact_from_tpl_contact (
2595 g_object_unref (account);
2596 g_object_unref (target);
2599 g_object_unref (inner_node);
2602 g_object_unref (hit);
2604 log_window_update_buttons_sensitivity (self);
2608 log_window_events_button_press_event (GtkWidget *webview,
2609 GdkEventButton *event,
2610 EmpathyLogWindow *self)
2612 switch (event->button)
2615 log_window_find_row (self, event);
2619 empathy_webkit_context_menu_for_event (
2620 WEBKIT_WEB_VIEW (webview), event, 0);
2631 log_window_events_setup (EmpathyLogWindow *self)
2633 GtkTreeSortable *sortable;
2634 GtkTreeStore *store;
2637 self->priv->store_events = store = gtk_tree_store_new (COL_EVENTS_COUNT,
2638 G_TYPE_INT, /* type */
2639 G_TYPE_INT64, /* timestamp */
2640 G_TYPE_STRING, /* stringified date */
2641 G_TYPE_STRING, /* icon */
2642 G_TYPE_STRING, /* name */
2643 TP_TYPE_ACCOUNT, /* account */
2644 TPL_TYPE_ENTITY, /* target */
2645 TPL_TYPE_EVENT); /* event */
2647 sortable = GTK_TREE_SORTABLE (store);
2649 gtk_tree_sortable_set_sort_column_id (sortable,
2651 GTK_SORT_ASCENDING);
2655 log_window_who_setup (EmpathyLogWindow *self)
2658 GtkTreeModel *model;
2659 GtkTreeSelection *selection;
2660 GtkTreeSortable *sortable;
2661 GtkTreeViewColumn *column;
2662 GtkListStore *store;
2663 GtkCellRenderer *cell;
2665 view = GTK_TREE_VIEW (self->priv->treeview_who);
2666 selection = gtk_tree_view_get_selection (view);
2669 store = gtk_list_store_new (COL_WHO_COUNT,
2670 G_TYPE_INT, /* type */
2671 G_TYPE_STRING, /* icon */
2672 G_TYPE_STRING, /* name */
2673 G_TYPE_STRING, /* name sort key */
2674 G_TYPE_STRING, /* id */
2675 TP_TYPE_ACCOUNT, /* account */
2676 TPL_TYPE_ENTITY); /* target */
2678 model = GTK_TREE_MODEL (store);
2679 sortable = GTK_TREE_SORTABLE (store);
2681 gtk_tree_view_set_model (view, model);
2684 column = gtk_tree_view_column_new ();
2685 gtk_tree_view_column_set_title (column, _("Who"));
2687 cell = gtk_cell_renderer_pixbuf_new ();
2688 gtk_tree_view_column_pack_start (column, cell, FALSE);
2689 gtk_tree_view_column_add_attribute (column, cell,
2693 cell = gtk_cell_renderer_text_new ();
2694 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2695 gtk_tree_view_column_pack_start (column, cell, TRUE);
2696 gtk_tree_view_column_add_attribute (column, cell,
2700 gtk_tree_view_append_column (view, column);
2702 /* set up treeview properties */
2703 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
2704 gtk_tree_view_set_row_separator_func (view, who_row_is_separator,
2707 gtk_tree_sortable_set_sort_column_id (sortable,
2708 COL_WHO_NAME_SORT_KEY,
2709 GTK_SORT_ASCENDING);
2710 gtk_tree_sortable_set_sort_func (sortable,
2711 COL_WHO_NAME_SORT_KEY, sort_by_name_key,
2714 gtk_tree_view_set_search_column (view, COL_WHO_NAME);
2715 gtk_tree_view_set_tooltip_column (view, COL_WHO_ID);
2717 /* set up signals */
2718 g_signal_connect (selection, "changed",
2719 G_CALLBACK (log_window_who_changed_cb), self);
2721 g_object_unref (store);
2725 log_window_chats_accounts_changed_cb (GtkWidget *combobox,
2726 EmpathyLogWindow *self)
2728 /* Clear all current messages shown in the textview */
2729 gtk_tree_store_clear (self->priv->store_events);
2731 log_window_who_populate (self);
2735 log_window_chats_set_selected (EmpathyLogWindow *self)
2738 GtkTreeModel *model;
2739 GtkTreeSelection *selection;
2744 view = GTK_TREE_VIEW (self->priv->treeview_who);
2745 model = gtk_tree_view_get_model (view);
2746 selection = gtk_tree_view_get_selection (view);
2748 for (next = gtk_tree_model_get_iter_first (model, &iter);
2750 next = gtk_tree_model_iter_next (model, &iter))
2752 TpAccount *this_account;
2753 TplEntity *this_target;
2754 const gchar *this_chat_id;
2755 gboolean this_is_chatroom;
2758 gtk_tree_model_get (model, &iter,
2759 COL_WHO_TYPE, &this_type,
2760 COL_WHO_ACCOUNT, &this_account,
2761 COL_WHO_TARGET, &this_target,
2764 if (this_type != COL_TYPE_NORMAL)
2767 this_chat_id = tpl_entity_get_identifier (this_target);
2768 this_is_chatroom = tpl_entity_get_entity_type (this_target)
2771 if (this_account == self->priv->selected_account &&
2772 !tp_strdiff (this_chat_id, self->priv->selected_chat_id) &&
2773 this_is_chatroom == self->priv->selected_is_chatroom)
2775 gtk_tree_selection_select_iter (selection, &iter);
2776 path = gtk_tree_model_get_path (model, &iter);
2777 gtk_tree_view_scroll_to_cell (view, path, NULL, TRUE, 0.5, 0.0);
2778 gtk_tree_path_free (path);
2779 g_object_unref (this_account);
2780 g_object_unref (this_target);
2784 g_object_unref (this_account);
2785 g_object_unref (this_target);
2788 tp_clear_object (&self->priv->selected_account);
2789 tp_clear_pointer (&self->priv->selected_chat_id, g_free);
2793 sort_by_date (GtkTreeModel *model,
2798 GDate *date1, *date2;
2800 gtk_tree_model_get (model, a,
2801 COL_WHEN_DATE, &date1,
2804 gtk_tree_model_get (model, b,
2805 COL_WHEN_DATE, &date2,
2808 return g_date_compare (date1, date2);
2812 when_row_is_separator (GtkTreeModel *model,
2819 gtk_tree_model_get (model, iter,
2820 COL_WHEN_TEXT, &when,
2823 ret = !tp_strdiff (when, "separator");
2829 log_window_when_changed_cb (GtkTreeSelection *selection,
2830 EmpathyLogWindow *self)
2833 GtkTreeModel *model;
2836 DEBUG ("log_window_when_changed_cb");
2838 view = gtk_tree_selection_get_tree_view (selection);
2839 model = gtk_tree_view_get_model (view);
2841 /* If 'Anytime' is selected, everything else should be deselected */
2842 if (gtk_tree_model_get_iter_first (model, &iter))
2844 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2846 g_signal_handlers_block_by_func (selection,
2847 log_window_when_changed_cb,
2850 gtk_tree_selection_unselect_all (selection);
2851 gtk_tree_selection_select_iter (selection, &iter);
2853 g_signal_handlers_unblock_by_func (selection,
2854 log_window_when_changed_cb,
2859 log_window_chats_get_messages (self, FALSE);
2863 log_window_when_setup (EmpathyLogWindow *self)
2866 GtkTreeModel *model;
2867 GtkTreeSelection *selection;
2868 GtkTreeSortable *sortable;
2869 GtkTreeViewColumn *column;
2870 GtkListStore *store;
2871 GtkCellRenderer *cell;
2873 view = GTK_TREE_VIEW (self->priv->treeview_when);
2874 selection = gtk_tree_view_get_selection (view);
2877 store = gtk_list_store_new (COL_WHEN_COUNT,
2878 G_TYPE_DATE, /* date */
2879 G_TYPE_STRING, /* stringified date */
2880 G_TYPE_STRING); /* icon */
2882 model = GTK_TREE_MODEL (store);
2883 sortable = GTK_TREE_SORTABLE (store);
2885 gtk_tree_view_set_model (view, model);
2888 column = gtk_tree_view_column_new ();
2889 gtk_tree_view_column_set_title (column, _("When"));
2891 cell = gtk_cell_renderer_pixbuf_new ();
2892 gtk_tree_view_column_pack_start (column, cell, FALSE);
2893 gtk_tree_view_column_add_attribute (column, cell,
2894 "icon-name", COL_WHEN_ICON);
2896 cell = gtk_cell_renderer_text_new ();
2897 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2898 gtk_tree_view_column_pack_start (column, cell, TRUE);
2899 gtk_tree_view_column_add_attribute (column, cell,
2903 gtk_tree_view_append_column (view, column);
2905 /* set up treeview properties */
2906 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
2907 gtk_tree_view_set_row_separator_func (view, when_row_is_separator,
2909 gtk_tree_sortable_set_sort_column_id (sortable,
2911 GTK_SORT_DESCENDING);
2912 gtk_tree_sortable_set_sort_func (sortable,
2913 COL_WHEN_DATE, sort_by_date,
2916 gtk_tree_view_set_search_column (view, COL_WHEN_TEXT);
2918 /* set up signals */
2919 g_signal_connect (selection, "changed",
2920 G_CALLBACK (log_window_when_changed_cb),
2923 g_object_unref (store);
2927 what_row_is_separator (GtkTreeModel *model,
2933 gtk_tree_model_get (model, iter,
2934 COL_WHAT_TYPE, &type,
2937 return (type == WHAT_TYPE_SEPARATOR);
2941 log_window_what_changed_cb (GtkTreeSelection *selection,
2942 EmpathyLogWindow *self)
2945 GtkTreeModel *model;
2948 DEBUG ("log_window_what_changed_cb");
2950 view = gtk_tree_selection_get_tree_view (selection);
2951 model = gtk_tree_view_get_model (view);
2953 /* If 'Anything' is selected, everything else should be deselected */
2954 if (gtk_tree_model_get_iter_first (model, &iter))
2956 if (gtk_tree_selection_iter_is_selected (selection, &iter))
2958 g_signal_handlers_block_by_func (selection,
2959 log_window_what_changed_cb,
2962 gtk_tree_selection_unselect_all (selection);
2963 gtk_tree_selection_select_iter (selection, &iter);
2965 g_signal_handlers_unblock_by_func (selection,
2966 log_window_what_changed_cb,
2971 /* The dates need to be updated if we're not searching */
2972 log_window_chats_get_messages (self, self->priv->hits == NULL);
2976 log_window_what_collapse_row_cb (GtkTreeView *tree_view,
2981 /* Reject collapsing */
2988 EventSubtype subtype;
2994 log_window_what_setup (EmpathyLogWindow *self)
2997 GtkTreeModel *model;
2998 GtkTreeSelection *selection;
2999 GtkTreeViewColumn *column;
3001 GtkTreeStore *store;
3002 GtkCellRenderer *cell;
3004 struct event events [] = {
3005 { TPL_EVENT_MASK_ANY, 0, NULL, _("Anything") },
3006 { WHAT_TYPE_SEPARATOR, 0, NULL, "separator" },
3007 { TPL_EVENT_MASK_TEXT, 0, "format-justify-fill", _("Text chats") },
3008 #ifdef HAVE_CALL_LOGS
3009 { TPL_EVENT_MASK_CALL, EVENT_CALL_ALL, EMPATHY_IMAGE_CALL, _("Calls") },
3012 #ifdef HAVE_CALL_LOGS
3013 struct event call_events [] = {
3014 { TPL_EVENT_MASK_CALL, EVENT_CALL_INCOMING, EMPATHY_IMAGE_CALL_INCOMING, _("Incoming calls") },
3015 { TPL_EVENT_MASK_CALL, EVENT_CALL_OUTGOING, EMPATHY_IMAGE_CALL_OUTGOING, _("Outgoing calls") },
3016 { TPL_EVENT_MASK_CALL, EVENT_CALL_MISSED, EMPATHY_IMAGE_CALL_MISSED, _("Missed calls") }
3021 view = GTK_TREE_VIEW (self->priv->treeview_what);
3022 selection = gtk_tree_view_get_selection (view);
3025 store = gtk_tree_store_new (COL_WHAT_COUNT,
3026 G_TYPE_INT, /* history type */
3027 G_TYPE_INT, /* history subtype */
3028 G_TYPE_BOOLEAN, /* sensitive */
3029 G_TYPE_STRING, /* stringified history type */
3030 G_TYPE_STRING); /* icon */
3032 model = GTK_TREE_MODEL (store);
3034 gtk_tree_view_set_model (view, model);
3037 column = gtk_tree_view_column_new ();
3038 gtk_tree_view_column_set_title (column, _("What"));
3040 cell = gtk_cell_renderer_pixbuf_new ();
3041 gtk_tree_view_column_pack_start (column, cell, FALSE);
3042 gtk_tree_view_column_add_attribute (column, cell,
3043 "icon-name", COL_WHAT_ICON);
3045 cell = gtk_cell_renderer_text_new ();
3046 g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
3047 gtk_tree_view_column_pack_start (column, cell, TRUE);
3048 gtk_tree_view_column_add_attribute (column, cell,
3049 "text", COL_WHAT_TEXT);
3050 gtk_tree_view_column_add_attribute (column, cell,
3051 "sensitive", COL_WHAT_SENSITIVE);
3053 gtk_tree_view_append_column (view, column);
3054 gtk_tree_view_set_search_column (view, COL_WHAT_TEXT);
3056 /* set up treeview properties */
3057 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
3058 gtk_tree_view_set_show_expanders (view, FALSE);
3059 gtk_tree_view_set_level_indentation (view, 12);
3060 gtk_tree_view_expand_all (view);
3061 gtk_tree_view_set_row_separator_func (view, what_row_is_separator,
3065 for (i = 0; i < G_N_ELEMENTS (events); i++)
3067 gtk_tree_store_append (store, &iter, NULL);
3068 gtk_tree_store_set (store, &iter,
3069 COL_WHAT_TYPE, events[i].type,
3070 COL_WHAT_SUBTYPE, events[i].subtype,
3071 COL_WHAT_SENSITIVE, TRUE,
3072 COL_WHAT_TEXT, events[i].text,
3073 COL_WHAT_ICON, events[i].icon,
3077 #ifdef HAVE_CALL_LOGS
3078 gtk_tree_model_iter_nth_child (model, &parent, NULL, 3);
3079 for (i = 0; i < G_N_ELEMENTS (call_events); i++)
3081 gtk_tree_store_append (store, &iter, &parent);
3082 gtk_tree_store_set (store, &iter,
3083 COL_WHAT_TYPE, call_events[i].type,
3084 COL_WHAT_SUBTYPE, call_events[i].subtype,
3085 COL_WHAT_SENSITIVE, TRUE,
3086 COL_WHAT_TEXT, call_events[i].text,
3087 COL_WHAT_ICON, call_events[i].icon,
3092 gtk_tree_view_expand_all (view);
3094 /* select 'Anything' */
3095 if (gtk_tree_model_get_iter_first (model, &iter))
3096 gtk_tree_selection_select_iter (selection, &iter);
3098 /* set up signals */
3099 g_signal_connect (view, "test-collapse-row",
3100 G_CALLBACK (log_window_what_collapse_row_cb),
3102 g_signal_connect (selection, "changed",
3103 G_CALLBACK (log_window_what_changed_cb),
3106 g_object_unref (store);
3110 log_window_maybe_expand_events (void)
3112 GtkTreeModel *model = GTK_TREE_MODEL (log_window->priv->store_events);
3114 /* If there's only one result, expand it */
3115 if (gtk_tree_model_iter_n_children (model, NULL) == 1)
3116 webkit_web_view_execute_script (
3117 WEBKIT_WEB_VIEW (log_window->priv->webview),
3118 "javascript:expandAll()");
3122 show_spinner (gpointer data)
3126 if (log_window == NULL)
3129 g_object_get (log_window->priv->spinner, "active", &active, NULL);
3132 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3139 show_events (TplActionChain *chain,
3142 log_window_maybe_expand_events ();
3143 gtk_spinner_stop (GTK_SPINNER (log_window->priv->spinner));
3144 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3147 _tpl_action_chain_continue (chain);
3151 start_spinner (void)
3153 gtk_spinner_start (GTK_SPINNER (log_window->priv->spinner));
3154 gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3157 g_timeout_add (1000, show_spinner, NULL);
3158 _tpl_action_chain_append (log_window->priv->chain, show_events, NULL);
3162 log_window_got_messages_for_date_cb (GObject *manager,
3163 GAsyncResult *result,
3166 Ctx *ctx = user_data;
3167 GtkTreeModel *model;
3171 GError *error = NULL;
3174 if (log_window == NULL)
3180 if (log_window->priv->count != ctx->count)
3183 if (!tpl_log_manager_get_events_for_date_finish (TPL_LOG_MANAGER (manager),
3184 result, &events, &error))
3186 DEBUG ("Unable to retrieve messages for the selected date: %s. Aborting",
3188 g_error_free (error);
3192 for (l = events; l; l = l->next)
3194 TplEvent *event = l->data;
3195 gboolean append = TRUE;
3197 #ifdef HAVE_CALL_LOGS
3198 if (TPL_IS_CALL_EVENT (l->data)
3199 && ctx->event_mask & TPL_EVENT_MASK_CALL
3200 && ctx->event_mask != TPL_EVENT_MASK_ANY)
3202 TplCallEvent *call = l->data;
3206 if (ctx->subtype & EVENT_CALL_ALL)
3212 TplCallEndReason reason = tpl_call_event_get_end_reason (call);
3213 TplEntity *sender = tpl_event_get_sender (event);
3214 TplEntity *receiver = tpl_event_get_receiver (event);
3216 if (reason == TPL_CALL_END_REASON_NO_ANSWER)
3218 if (ctx->subtype & EVENT_CALL_MISSED)
3221 else if (ctx->subtype & EVENT_CALL_OUTGOING
3222 && tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
3226 else if (ctx->subtype & EVENT_CALL_INCOMING
3227 && tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF)
3237 EmpathyMessage *msg = empathy_message_from_tpl_log_event (event);
3238 log_window_append_message (event, msg);
3239 tp_clear_object (&msg);
3242 g_object_unref (event);
3244 g_list_free (events);
3246 model = GTK_TREE_MODEL (log_window->priv->store_events);
3247 n = gtk_tree_model_iter_n_children (model, NULL) - 1;
3249 if (n >= 0 && gtk_tree_model_iter_nth_child (model, &iter, NULL, n))
3254 path = gtk_tree_model_get_path (model, &iter);
3255 str = gtk_tree_path_to_string (path);
3257 script = g_strdup_printf ("javascript:scrollToRow([%s]);",
3258 g_strdelimit (str, ":", ','));
3260 webkit_web_view_execute_script (
3261 WEBKIT_WEB_VIEW (log_window->priv->webview),
3264 gtk_tree_path_free (path);
3272 _tpl_action_chain_continue (log_window->priv->chain);
3276 get_events_for_date (TplActionChain *chain, gpointer user_data)
3278 Ctx *ctx = user_data;
3280 tpl_log_manager_get_events_for_date_async (ctx->self->priv->log_manager,
3281 ctx->account, ctx->entity, ctx->event_mask,
3283 log_window_got_messages_for_date_cb,
3288 log_window_get_messages_for_dates (EmpathyLogWindow *self,
3291 GList *accounts, *targets, *acc, *targ, *l;
3292 TplEventTypeMask event_mask;
3293 EventSubtype subtype;
3294 GDate *date, *anytime, *separator;
3296 if (!log_window_get_selected (self,
3297 &accounts, &targets, NULL, NULL, &event_mask, &subtype))
3300 anytime = g_date_new_dmy (2, 1, -1);
3301 separator = g_date_new_dmy (1, 1, -1);
3303 _tpl_action_chain_clear (self->priv->chain);
3304 self->priv->count++;
3306 for (acc = accounts, targ = targets;
3307 acc != NULL && targ != NULL;
3308 acc = acc->next, targ = targ->next)
3310 TpAccount *account = acc->data;
3311 TplEntity *target = targ->data;
3313 for (l = dates; l != NULL; l = l->next)
3318 if (g_date_compare (date, anytime) != 0)
3322 ctx = ctx_new (self, account, target, date, event_mask, subtype,
3324 _tpl_action_chain_append (self->priv->chain, get_events_for_date, ctx);
3328 GtkTreeView *view = GTK_TREE_VIEW (self->priv->treeview_when);
3329 GtkTreeModel *model = gtk_tree_view_get_model (view);
3334 for (next = gtk_tree_model_get_iter_first (model, &iter);
3336 next = gtk_tree_model_iter_next (model, &iter))
3340 gtk_tree_model_get (model, &iter,
3344 if (g_date_compare (d, anytime) != 0 &&
3345 g_date_compare (d, separator) != 0)
3347 ctx = ctx_new (self, account, target, d,
3348 event_mask, subtype, self->priv->count);
3349 _tpl_action_chain_append (self->priv->chain, get_events_for_date, ctx);
3357 _tpl_action_chain_start (self->priv->chain);
3359 g_list_free_full (accounts, g_object_unref);
3360 g_list_free_full (targets, g_object_unref);
3361 g_date_free (separator);
3362 g_date_free (anytime);
3366 log_manager_got_dates_cb (GObject *manager,
3367 GAsyncResult *result,
3370 Ctx *ctx = user_data;
3372 GtkTreeModel *model;
3373 GtkListStore *store;
3377 GError *error = NULL;
3379 if (log_window == NULL)
3385 if (log_window->priv->count != ctx->count)
3388 if (!tpl_log_manager_get_dates_finish (TPL_LOG_MANAGER (manager),
3389 result, &dates, &error))
3391 DEBUG ("Unable to retrieve messages' dates: %s. Aborting",
3396 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
3397 model = gtk_tree_view_get_model (view);
3398 store = GTK_LIST_STORE (model);
3400 for (l = dates; l != NULL; l = l->next)
3402 GDate *date = l->data;
3404 /* Add the date if it's not already there */
3405 has_element = FALSE;
3406 gtk_tree_model_foreach (model, model_has_date, date);
3409 gchar *text = format_date_for_display (date);
3411 gtk_list_store_append (store, &iter);
3412 gtk_list_store_set (store, &iter,
3413 COL_WHEN_DATE, date,
3414 COL_WHEN_TEXT, text,
3415 COL_WHEN_ICON, CALENDAR_ICON,
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)
3435 gtk_list_store_prepend (store, &iter);
3436 gtk_list_store_set (store, &iter,
3437 COL_WHEN_DATE, g_date_new_dmy (1, 1, -1),
3438 COL_WHEN_TEXT, "separator",
3441 gtk_list_store_prepend (store, &iter);
3442 gtk_list_store_set (store, &iter,
3443 COL_WHEN_DATE, g_date_new_dmy (2, 1, -1),
3444 COL_WHEN_TEXT, _("Anytime"),
3449 g_list_free_full (dates, g_free);
3452 _tpl_action_chain_continue (log_window->priv->chain);
3456 select_date (TplActionChain *chain, gpointer user_data)
3459 GtkTreeModel *model;
3460 GtkTreeSelection *selection;
3463 gboolean selected = FALSE;
3465 view = GTK_TREE_VIEW (log_window->priv->treeview_when);
3466 model = gtk_tree_view_get_model (view);
3467 selection = gtk_tree_view_get_selection (view);
3469 if (log_window->priv->current_dates != NULL)
3471 for (next = gtk_tree_model_get_iter_first (model, &iter);
3473 next = gtk_tree_model_iter_next (model, &iter))
3477 gtk_tree_model_get (model, &iter,
3478 COL_WHEN_DATE, &date,
3481 if (g_list_find_custom (log_window->priv->current_dates, date,
3482 (GCompareFunc) g_date_compare) != NULL)
3486 gtk_tree_selection_select_iter (selection, &iter);
3487 path = gtk_tree_model_get_path (model, &iter);
3488 gtk_tree_view_scroll_to_cell (view, path, NULL, FALSE, 0, 0);
3491 gtk_tree_path_free (path);
3500 /* Show messages of the most recent date */
3501 if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 2))
3502 gtk_tree_selection_select_iter (selection, &iter);
3505 _tpl_action_chain_continue (log_window->priv->chain);
3509 get_dates_for_entity (TplActionChain *chain, gpointer user_data)
3511 Ctx *ctx = user_data;
3513 tpl_log_manager_get_dates_async (ctx->self->priv->log_manager,
3514 ctx->account, ctx->entity, ctx->event_mask,
3515 log_manager_got_dates_cb, ctx);
3519 log_window_chats_get_messages (EmpathyLogWindow *self,
3520 gboolean force_get_dates)
3522 GList *accounts, *targets, *dates;
3523 TplEventTypeMask event_mask;
3525 GtkTreeModel *model;
3526 GtkListStore *store;
3527 GtkTreeSelection *selection;
3529 if (!log_window_get_selected (self, &accounts, &targets, NULL,
3530 &dates, &event_mask, NULL))
3533 view = GTK_TREE_VIEW (self->priv->treeview_when);
3534 selection = gtk_tree_view_get_selection (view);
3535 model = gtk_tree_view_get_model (view);
3536 store = GTK_LIST_STORE (model);
3538 /* Clear all current messages shown in the textview */
3539 gtk_tree_store_clear (self->priv->store_events);
3541 _tpl_action_chain_clear (self->priv->chain);
3542 self->priv->count++;
3544 /* If there's a search use the returned hits */
3545 if (self->priv->hits != NULL)
3547 if (force_get_dates)
3549 g_signal_handlers_block_by_func (selection,
3550 log_window_when_changed_cb,
3553 gtk_list_store_clear (store);
3555 g_signal_handlers_unblock_by_func (selection,
3556 log_window_when_changed_cb,
3559 populate_dates_from_search_hits (accounts, targets);
3563 populate_events_from_search_hits (accounts, targets, dates);
3566 /* Either use the supplied date or get the last */
3567 else if (force_get_dates || dates == NULL)
3571 if (self->priv->current_dates != NULL)
3573 g_list_free_full (self->priv->current_dates,
3574 (GDestroyNotify) g_date_free);
3575 self->priv->current_dates = NULL;
3578 if (gtk_tree_selection_count_selected_rows (selection) > 0)
3583 paths = gtk_tree_selection_get_selected_rows (selection, NULL);
3585 for (l = paths; l != NULL; l = l->next)
3587 GtkTreePath *path = l->data;
3590 gtk_tree_model_get_iter (model, &iter, path);
3591 gtk_tree_model_get (model, &iter,
3592 COL_WHEN_DATE, &date,
3595 /* The list takes ownership of the date. */
3596 self->priv->current_dates =
3597 g_list_prepend (self->priv->current_dates, date);
3600 g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
3603 g_signal_handlers_block_by_func (selection,
3604 log_window_when_changed_cb,
3607 gtk_list_store_clear (store);
3609 g_signal_handlers_unblock_by_func (selection,
3610 log_window_when_changed_cb,
3613 /* Get a list of dates and show them on the treeview */
3614 for (targ = targets, acc = accounts;
3615 targ != NULL && acc != NULL;
3616 targ = targ->next, acc = acc->next)
3618 TpAccount *account = acc->data;
3619 TplEntity *target = targ->data;
3620 Ctx *ctx = ctx_new (self, account, target, NULL, event_mask, 0,
3623 _tpl_action_chain_append (self->priv->chain, get_dates_for_entity, ctx);
3625 _tpl_action_chain_append (self->priv->chain, select_date, NULL);
3626 _tpl_action_chain_start (self->priv->chain);
3630 /* Show messages of the selected date */
3631 log_window_get_messages_for_dates (self, dates);
3634 g_list_free_full (accounts, g_object_unref);
3635 g_list_free_full (targets, g_object_unref);
3636 g_list_free_full (dates, (GFreeFunc) g_date_free);
3640 EmpathyAccountChooserFilterResultCallback callback;
3642 } FilterCallbackData;
3645 got_entities (GObject *manager,
3646 GAsyncResult *result,
3649 FilterCallbackData *data = user_data;
3651 GError *error = NULL;
3653 if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager),
3654 result, &entities, &error))
3656 DEBUG ("Could not get entities: %s", error->message);
3657 g_error_free (error);
3658 data->callback (FALSE, data->user_data);
3662 data->callback (entities != NULL, data->user_data);
3664 g_list_free_full (entities, g_object_unref);
3667 g_slice_free (FilterCallbackData, data);
3671 empathy_account_chooser_filter_has_logs (TpAccount *account,
3672 EmpathyAccountChooserFilterResultCallback callback,
3673 gpointer callback_data,
3676 TplLogManager *manager = tpl_log_manager_dup_singleton ();
3677 FilterCallbackData *cb_data = g_slice_new0 (FilterCallbackData);
3679 cb_data->callback = callback;
3680 cb_data->user_data = callback_data;
3682 tpl_log_manager_get_entities_async (manager, account, got_entities, cb_data);
3684 g_object_unref (manager);
3688 log_window_logger_clear_account_cb (TpProxy *proxy,
3689 const GError *error,
3691 GObject *weak_object)
3693 EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (user_data);
3696 g_warning ("Error when clearing logs: %s", error->message);
3698 /* Refresh the log viewer so the logs are cleared if the account
3699 * has been deleted */
3700 gtk_tree_store_clear (self->priv->store_events);
3701 log_window_who_populate (self);
3703 /* Re-filter the account chooser so the accounts without logs get
3705 empathy_account_chooser_refilter (
3706 EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser));
3710 log_window_clear_logs_chooser_select_account (EmpathyAccountChooser *chooser,
3711 EmpathyLogWindow *self)
3713 EmpathyAccountChooser *account_chooser;
3715 account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
3717 empathy_account_chooser_set_account (chooser,
3718 empathy_account_chooser_get_account (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 if (empathy_account_chooser_is_ready (account_chooser))
3739 log_window_clear_logs_chooser_select_account (account_chooser, self);
3741 g_signal_connect (account_chooser, "ready",
3742 G_CALLBACK (log_window_clear_logs_chooser_select_account), self);
3744 dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (self),
3745 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING,
3747 _("Are you sure you want to delete all logs of previous conversations?"));
3749 gtk_dialog_add_buttons (GTK_DIALOG (dialog),
3750 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
3751 _("Clear All"), GTK_RESPONSE_APPLY,
3754 content_area = gtk_message_dialog_get_message_area (
3755 GTK_MESSAGE_DIALOG (dialog));
3757 hbox = gtk_hbox_new (FALSE, 6);
3758 label = gtk_label_new (_("Delete from:"));
3759 gtk_box_pack_start (GTK_BOX (hbox), label,
3761 gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (account_chooser),
3763 gtk_box_pack_start (GTK_BOX (content_area), hbox,
3766 gtk_widget_show_all (hbox);
3768 response_id = gtk_dialog_run (GTK_DIALOG (dialog));
3770 if (response_id != GTK_RESPONSE_APPLY)
3773 bus = tp_dbus_daemon_dup (&error);
3776 g_warning ("Could not delete logs: %s", error->message);
3777 g_error_free (error);
3781 logger = g_object_new (TP_TYPE_PROXY,
3782 "bus-name", "org.freedesktop.Telepathy.Logger",
3783 "object-path", "/org/freedesktop/Telepathy/Logger",
3786 g_object_unref (bus);
3788 tp_proxy_add_interface_by_id (logger, EMP_IFACE_QUARK_LOGGER);
3790 if (empathy_account_chooser_has_all_selected (account_chooser))
3792 DEBUG ("Deleting logs for all the accounts");
3794 emp_cli_logger_call_clear (logger, -1,
3795 log_window_logger_clear_account_cb,
3796 self, NULL, G_OBJECT (self));
3802 account = empathy_account_chooser_get_account (account_chooser);
3804 DEBUG ("Deleting logs for %s", tp_proxy_get_object_path (account));
3806 emp_cli_logger_call_clear_account (logger, -1,
3807 tp_proxy_get_object_path (account),
3808 log_window_logger_clear_account_cb,
3809 self, NULL, G_OBJECT (self));
3812 g_object_unref (logger);
3814 gtk_widget_destroy (dialog);