diff options
Diffstat (limited to 'libempathy-gtk/empathy-log-window.c')
| -rw-r--r-- | libempathy-gtk/empathy-log-window.c | 3751 |
1 files changed, 2517 insertions, 1234 deletions
diff --git a/libempathy-gtk/empathy-log-window.c b/libempathy-gtk/empathy-log-window.c index f6b5edf16..d3aa07027 100644 --- a/libempathy-gtk/empathy-log-window.c +++ b/libempathy-gtk/empathy-log-window.c @@ -1,7 +1,6 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ /* * Copyright (C) 2006-2007 Imendio AB - * Copyright (C) 2007-2008 Collabora Ltd. + * Copyright (C) 2007-2011 Collabora Ltd. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -20,6 +19,7 @@ * * Authors: Martyn Russell <martyn@imendio.com> * Xavier Claessens <xclaesse@gmail.com> + * Emilio Pozuelo Monfort <emilio.pozuelo@collabora.co.uk> */ #include "config.h" @@ -30,13 +30,15 @@ #include <glib/gi18n-lib.h> #include <gtk/gtk.h> -#include <telepathy-glib/account-manager.h> +#include <telepathy-glib/telepathy-glib.h> #include <telepathy-glib/proxy-subclass.h> -#include <telepathy-logger/log-manager.h> +#include <telepathy-logger/telepathy-logger.h> +#include <telepathy-logger/call-event.h> #include <extensions/extensions.h> +#include <libempathy/action-chain-internal.h> #include <libempathy/empathy-chatroom-manager.h> #include <libempathy/empathy-chatroom.h> #include <libempathy/empathy-message.h> @@ -45,1511 +47,2792 @@ #include "empathy-log-window.h" #include "empathy-account-chooser.h" +#include "empathy-call-utils.h" #include "empathy-chat-view.h" +#include "empathy-contact-dialogs.h" +#include "empathy-images.h" #include "empathy-theme-manager.h" #include "empathy-ui-utils.h" #define DEBUG_FLAG EMPATHY_DEBUG_OTHER #include <libempathy/empathy-debug.h> -typedef struct { - GtkWidget *window; - - GtkWidget *notebook; - - GtkWidget *entry_find; - GtkWidget *button_find; - GtkWidget *treeview_find; - GtkWidget *scrolledwindow_find; - EmpathyChatView *chatview_find; - GtkWidget *button_previous; - GtkWidget *button_next; - - GtkWidget *hbox_chats; - GtkWidget *account_chooser_chats; - GtkWidget *entry_chats; - GtkWidget *calendar_chats; - GtkWidget *treeview_chats; - GtkWidget *scrolledwindow_chats; - EmpathyChatView *chatview_chats; - - gchar *last_find; - - TplLogManager *log_manager; - - /* Those are only used while waiting for the account chooser to be ready */ - TpAccount *selected_account; - gchar *selected_chat_id; - gboolean selected_is_chatroom; +typedef struct +{ + GtkWidget *window; + + GtkWidget *button_profile; + GtkWidget *button_chat; + GtkWidget *button_call; + GtkWidget *button_video; + + GtkWidget *search_entry; + + GtkWidget *treeview_who; + GtkWidget *treeview_what; + GtkWidget *treeview_when; + GtkWidget *treeview_events; + + GtkTreeStore *store_events; + + GtkWidget *account_chooser; + + gchar *last_find; + + TplActionChain *chain; + TplLogManager *log_manager; + + /* Used to cancel logger calls when no longer needed */ + guint count; + + /* List of owned TplLogSearchHits, free with tpl_log_search_hit_free */ + GList *hits; + guint source; + + /* Only used while waiting for the account chooser to be ready */ + TpAccount *selected_account; + gchar *selected_chat_id; + gboolean selected_is_chatroom; } EmpathyLogWindow; -static void log_window_destroy_cb (GtkWidget *widget, - EmpathyLogWindow *window); -static void log_window_entry_find_changed_cb (GtkWidget *entry, - EmpathyLogWindow *window); -static void log_window_find_changed_cb (GtkTreeSelection *selection, - EmpathyLogWindow *window); -static void log_window_find_populate (EmpathyLogWindow *window, - const gchar *search_criteria); -static void log_window_find_setup (EmpathyLogWindow *window); -static void log_window_button_find_clicked_cb (GtkWidget *widget, - EmpathyLogWindow *window); -static void log_window_entry_find_activate_cb (GtkWidget *widget, - EmpathyLogWindow *window); -static void log_window_button_next_clicked_cb (GtkWidget *widget, - EmpathyLogWindow *window); -static void log_window_button_previous_clicked_cb (GtkWidget *widget, - EmpathyLogWindow *window); -static void log_window_chats_changed_cb (GtkTreeSelection *selection, - EmpathyLogWindow *window); -static void log_window_chats_populate (EmpathyLogWindow *window); -static void log_window_chats_setup (EmpathyLogWindow *window); -static void log_window_chats_accounts_changed_cb (GtkWidget *combobox, - EmpathyLogWindow *window); -static void log_window_chats_set_selected (EmpathyLogWindow *window); -static gboolean log_window_chats_get_selected (EmpathyLogWindow *window, - TpAccount **account, - TplEntity **target); -static void log_window_chats_get_messages (EmpathyLogWindow *window, - GDate *date_to_show); -static void log_window_calendar_chats_day_selected_cb (GtkWidget *calendar, - EmpathyLogWindow *window); -static void log_window_calendar_chats_month_changed_cb (GtkWidget *calendar, - EmpathyLogWindow *window); -static void log_window_entry_chats_changed_cb (GtkWidget *entry, - EmpathyLogWindow *window); -static void log_window_entry_chats_activate_cb (GtkWidget *entry, - EmpathyLogWindow *window); -static void log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem, - EmpathyLogWindow *window); +static void log_window_destroy_cb (GtkWidget *widget, + EmpathyLogWindow *window); +static void log_window_search_entry_changed_cb (GtkWidget *entry, + EmpathyLogWindow *window); +static void log_window_search_entry_activate_cb (GtkWidget *widget, + EmpathyLogWindow *window); +static void log_window_search_entry_icon_pressed_cb (GtkEntry *entry, + GtkEntryIconPosition icon_pos, + GdkEvent *event, + gpointer user_data); +static void log_window_who_populate (EmpathyLogWindow *window); +static void log_window_who_setup (EmpathyLogWindow *window); +static void log_window_when_setup (EmpathyLogWindow *window); +static void log_window_what_setup (EmpathyLogWindow *window); +static void log_window_events_setup (EmpathyLogWindow *window); +static void log_window_chats_accounts_changed_cb (GtkWidget *combobox, + EmpathyLogWindow *window); +static void log_window_chats_set_selected (EmpathyLogWindow *window); +static void log_window_chats_get_messages (EmpathyLogWindow *window, + gboolean force_get_dates); +static void log_window_when_changed_cb (GtkTreeSelection *selection, + EmpathyLogWindow *window); +static void log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem, + EmpathyLogWindow *window); static void empathy_account_chooser_filter_has_logs (TpAccount *account, - EmpathyAccountChooserFilterResultCallback callback, - gpointer callback_data, - gpointer user_data); - -enum { - COL_FIND_ACCOUNT_ICON, - COL_FIND_ACCOUNT_NAME, - COL_FIND_ACCOUNT, - COL_FIND_CHAT_NAME, - COL_FIND_TARGET, - COL_FIND_DATE, - COL_FIND_DATE_READABLE, - COL_FIND_COUNT + EmpathyAccountChooserFilterResultCallback callback, + gpointer callback_data, + gpointer user_data); + +enum +{ + COL_TYPE_ANY, + COL_TYPE_SEPARATOR, + COL_TYPE_NORMAL }; -enum { - COL_CHAT_ICON, - COL_CHAT_NAME, - COL_CHAT_ACCOUNT, - COL_CHAT_TARGET, - COL_CHAT_COUNT +enum +{ + COL_WHO_TYPE, + COL_WHO_ICON, + COL_WHO_NAME, + COL_WHO_ACCOUNT, + COL_WHO_TARGET, + COL_WHO_COUNT }; -static EmpathyLogWindow *log_window = NULL; +enum +{ + COL_WHAT_TYPE, + COL_WHAT_SUBTYPE, + COL_WHAT_TEXT, + COL_WHAT_ICON, + COL_WHAT_EXPANDER, + COL_WHAT_COUNT +}; -static void -account_manager_prepared_cb (GObject *source_object, - GAsyncResult *result, - gpointer user_data) +enum +{ + COL_WHEN_DATE, + COL_WHEN_TEXT, + COL_WHEN_ICON, + COL_WHEN_COUNT +}; + +enum +{ + COL_EVENTS_TYPE, + COL_EVENTS_TS, + COL_EVENTS_PRETTY_DATE, + COL_EVENTS_ICON, + COL_EVENTS_TEXT, + COL_EVENTS_ACCOUNT, + COL_EVENTS_TARGET, + COL_EVENTS_EVENT, + COL_EVENTS_COUNT +}; + +#define CALENDAR_ICON "stock_calendar" + +/* Seconds between two messages to be considered one conversation */ +#define MAX_GAP 30*60 + +#define WHAT_TYPE_SEPARATOR -1 + +typedef enum { - TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object); - EmpathyLogWindow *window = user_data; - guint account_num; - GList *accounts; - GError *error = NULL; + EVENT_CALL_INCOMING = 1 << 0, + EVENT_CALL_OUTGOING = 1 << 1, + EVENT_CALL_MISSED = 1 << 2, + EVENT_CALL_ALL = 1 << 3, +} EventSubtype; - if (log_window == NULL) - return; +static EmpathyLogWindow *log_window = NULL; - if (!tp_account_manager_prepare_finish (account_manager, result, &error)) { - DEBUG ("Failed to prepare account manager: %s", error->message); - g_error_free (error); - return; - } +static gboolean has_element; - accounts = tp_account_manager_get_valid_accounts (account_manager); - account_num = g_list_length (accounts); - g_list_free (accounts); +#ifndef _date_copy +#define _date_copy(d) g_date_new_julian (g_date_get_julian (d)) +#endif - gtk_widget_show_all (window->hbox_chats); +typedef struct +{ + EmpathyLogWindow *window; + TpAccount *account; + TplEntity *entity; + GDate *date; + TplEventTypeMask event_mask; + EventSubtype subtype; + guint count; +} Ctx; + +static Ctx * +ctx_new (EmpathyLogWindow *window, + TpAccount *account, + TplEntity *entity, + GDate *date, + TplEventTypeMask event_mask, + EventSubtype subtype, + guint count) +{ + Ctx *ctx = g_slice_new0 (Ctx); + + ctx->window = window; + if (account != NULL) + ctx->account = g_object_ref (account); + if (entity != NULL) + ctx->entity = g_object_ref (entity); + if (date != NULL) + ctx->date = _date_copy (date); + ctx->event_mask = event_mask; + ctx->subtype = subtype; + ctx->count = count; + + return ctx; } static void -account_chooser_ready_cb (EmpathyAccountChooser *chooser, - EmpathyLogWindow *window) +ctx_free (Ctx *ctx) { - gtk_notebook_set_current_page (GTK_NOTEBOOK (window->notebook), 1); + tp_clear_object (&ctx->account); + tp_clear_object (&ctx->entity); + tp_clear_pointer (&ctx->date, g_date_free); - /* We'll display the account once the model has been populate with the chats - * of this account. */ - empathy_account_chooser_set_account (EMPATHY_ACCOUNT_CHOOSER ( - window->account_chooser_chats), window->selected_account); + g_slice_free (Ctx, ctx); +} + +static void +account_chooser_ready_cb (EmpathyAccountChooser *chooser, + EmpathyLogWindow *window) +{ + /* We'll display the account once the model has been populate with the chats + * of this account. */ + empathy_account_chooser_set_account (EMPATHY_ACCOUNT_CHOOSER ( + window->account_chooser), window->selected_account); } static void select_account_once_ready (EmpathyLogWindow *self, - TpAccount *account, - const gchar *chat_id, - gboolean is_chatroom) + TpAccount *account, + const gchar *chat_id, + gboolean is_chatroom) { - EmpathyAccountChooser *account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->account_chooser_chats); + EmpathyAccountChooser *account_chooser; - tp_clear_object (&self->selected_account); - self->selected_account = g_object_ref (account); + account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->account_chooser); - g_free (self->selected_chat_id); - self->selected_chat_id = g_strdup (chat_id); + tp_clear_object (&self->selected_account); + self->selected_account = g_object_ref (account); - self->selected_is_chatroom = is_chatroom; + g_free (self->selected_chat_id); + self->selected_chat_id = g_strdup (chat_id); - if (empathy_account_chooser_is_ready (account_chooser)) - account_chooser_ready_cb (account_chooser, self); - else - /* Chat will be selected once the account chooser is ready */ - g_signal_connect (account_chooser, "ready", - G_CALLBACK (account_chooser_ready_cb), self); -} + self->selected_is_chatroom = is_chatroom; -GtkWidget * -empathy_log_window_show (TpAccount *account, - const gchar *chat_id, - gboolean is_chatroom, - GtkWindow *parent) -{ - EmpathyAccountChooser *account_chooser; - TpAccountManager *account_manager; - GtkBuilder *gui; - gchar *filename; - EmpathyLogWindow *window; - EmpathyThemeManager *theme_mgr; - GtkWidget *menu_delete; - - if (log_window != NULL) { - gtk_window_present (GTK_WINDOW (log_window->window)); - - if (account != NULL && chat_id != NULL) { - gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->notebook), 1); - select_account_once_ready (log_window, account, chat_id, is_chatroom); - } - - return log_window->window; - } - - log_window = g_new0 (EmpathyLogWindow, 1); - log_window->log_manager = tpl_log_manager_dup_singleton (); - - window = log_window; - - filename = empathy_file_lookup ("empathy-log-window.ui", - "libempathy-gtk"); - gui = empathy_builder_get_file (filename, - "log_window", &window->window, - "menu_delete", &menu_delete, - "notebook", &window->notebook, - "entry_find", &window->entry_find, - "button_find", &window->button_find, - "treeview_find", &window->treeview_find, - "scrolledwindow_find", &window->scrolledwindow_find, - "button_previous", &window->button_previous, - "button_next", &window->button_next, - "entry_chats", &window->entry_chats, - "calendar_chats", &window->calendar_chats, - "hbox_chats", &window->hbox_chats, - "treeview_chats", &window->treeview_chats, - "scrolledwindow_chats", &window->scrolledwindow_chats, - NULL); - g_free (filename); - - empathy_builder_connect (gui, window, - "log_window", "destroy", log_window_destroy_cb, - "entry_find", "changed", log_window_entry_find_changed_cb, - "entry_find", "activate", log_window_entry_find_activate_cb, - "button_previous", "clicked", log_window_button_previous_clicked_cb, - "button_next", "clicked", log_window_button_next_clicked_cb, - "button_find", "clicked", log_window_button_find_clicked_cb, - "entry_chats", "changed", log_window_entry_chats_changed_cb, - "entry_chats", "activate", log_window_entry_chats_activate_cb, - "menu_delete", "activate", log_window_delete_menu_clicked_cb, - NULL); - - g_object_unref (gui); - - g_object_add_weak_pointer (G_OBJECT (window->window), - (gpointer) &log_window); - - /* We set this up here so we can block it when needed. */ - g_signal_connect (window->calendar_chats, "day-selected", - G_CALLBACK (log_window_calendar_chats_day_selected_cb), - window); - g_signal_connect (window->calendar_chats, "month-changed", - G_CALLBACK (log_window_calendar_chats_month_changed_cb), - window); - - /* Configure Search EmpathyChatView */ - theme_mgr = empathy_theme_manager_dup_singleton (); - window->chatview_find = empathy_theme_manager_create_view (theme_mgr); - gtk_container_add (GTK_CONTAINER (window->scrolledwindow_find), - GTK_WIDGET (window->chatview_find)); - gtk_widget_show (GTK_WIDGET (window->chatview_find)); - - /* Configure Contacts EmpathyChatView */ - window->chatview_chats = empathy_theme_manager_create_view (theme_mgr); - gtk_container_add (GTK_CONTAINER (window->scrolledwindow_chats), - GTK_WIDGET (window->chatview_chats)); - gtk_widget_show (GTK_WIDGET (window->chatview_chats)); - g_object_unref (theme_mgr); - - /* Account chooser for chats */ - window->account_chooser_chats = empathy_account_chooser_new (); - account_chooser = EMPATHY_ACCOUNT_CHOOSER (window->account_chooser_chats); - empathy_account_chooser_set_filter (account_chooser, empathy_account_chooser_filter_has_logs, NULL); - - gtk_box_pack_start (GTK_BOX (window->hbox_chats), - window->account_chooser_chats, - FALSE, TRUE, 0); - - g_signal_connect (window->account_chooser_chats, "changed", - G_CALLBACK (log_window_chats_accounts_changed_cb), - window); - - /* Populate */ - account_manager = tp_account_manager_dup (); - tp_account_manager_prepare_async (account_manager, NULL, - account_manager_prepared_cb, window); - g_object_unref (account_manager); - - /* Search List */ - log_window_find_setup (window); - - /* Contacts */ - log_window_chats_setup (window); - log_window_chats_populate (window); - - if (account != NULL && chat_id != NULL) - select_account_once_ready (window, account, chat_id, is_chatroom); - - if (parent != NULL) { - gtk_window_set_transient_for (GTK_WINDOW (window->window), - GTK_WINDOW (parent)); - } - - gtk_widget_show (window->window); - - return window->window; + if (empathy_account_chooser_is_ready (account_chooser)) + account_chooser_ready_cb (account_chooser, self); + else + /* Chat will be selected once the account chooser is ready */ + g_signal_connect (account_chooser, "ready", + G_CALLBACK (account_chooser_ready_cb), self); } static void -log_window_destroy_cb (GtkWidget *widget, - EmpathyLogWindow *window) +toolbutton_profile_clicked (GtkToolButton *toolbutton, + EmpathyLogWindow *window) { - g_free (window->last_find); - g_object_unref (window->log_manager); - tp_clear_object (&window->selected_account); - g_free (window->selected_chat_id); + GtkTreeView *view; + GtkTreeSelection *selection; + GtkTreeModel *model; + GtkTreeIter iter; + GtkTreePath *path; + GList *paths; + TpAccount *account; + TplEntity *target; + EmpathyContact *contact; + gint type; + + g_return_if_fail (window != NULL); + + view = GTK_TREE_VIEW (log_window->treeview_who); + selection = gtk_tree_view_get_selection (view); + + paths = gtk_tree_selection_get_selected_rows (selection, &model); + g_return_if_fail (paths != NULL); - g_free (window); + path = paths->data; + gtk_tree_model_get_iter (model, &iter, path); + gtk_tree_model_get (model, &iter, + COL_WHO_ACCOUNT, &account, + COL_WHO_TARGET, &target, + COL_WHO_TYPE, &type, + -1); + + g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free); + + g_return_if_fail (type == COL_TYPE_NORMAL); + + contact = empathy_contact_from_tpl_contact (account, target); + empathy_contact_information_dialog_show (contact, + GTK_WINDOW (window->window)); + g_object_unref (contact); + + g_object_unref (account); + g_object_unref (target); } -/* - * Search code. - */ static void -log_window_entry_find_changed_cb (GtkWidget *entry, - EmpathyLogWindow *window) +toolbutton_chat_clicked (GtkToolButton *toolbutton, + EmpathyLogWindow *window) { - const gchar *str; - gboolean is_sensitive = TRUE; + GtkTreeView *view; + GtkTreeSelection *selection; + GtkTreeModel *model; + GtkTreeIter iter; + GtkTreePath *path; + GList *paths; + TpAccount *account; + TplEntity *target; + EmpathyContact *contact; + gint type; + + g_return_if_fail (window != NULL); + + view = GTK_TREE_VIEW (log_window->treeview_who); + selection = gtk_tree_view_get_selection (view); - str = gtk_entry_get_text (GTK_ENTRY (window->entry_find)); + paths = gtk_tree_selection_get_selected_rows (selection, &model); + g_return_if_fail (paths != NULL); - is_sensitive &= !EMP_STR_EMPTY (str); - is_sensitive &= - !window->last_find || - (window->last_find && tp_strdiff (window->last_find, str)); + path = paths->data; + gtk_tree_model_get_iter (model, &iter, path); + gtk_tree_model_get (model, &iter, + COL_WHO_ACCOUNT, &account, + COL_WHO_TARGET, &target, + COL_WHO_TYPE, &type, + -1); - gtk_widget_set_sensitive (window->button_find, is_sensitive); + g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free); + + g_return_if_fail (type == COL_TYPE_NORMAL); + + contact = empathy_contact_from_tpl_contact (account, target); + empathy_dispatcher_chat_with_contact (contact, + gtk_get_current_event_time ()); + + g_object_unref (contact); + g_object_unref (account); + g_object_unref (target); } static void -got_events_for_date_cb (GObject *manager, - GAsyncResult *result, - gpointer user_data) -{ - EmpathyLogWindow *window = user_data; - GList *messages; - GList *l; - gboolean can_do_previous; - gboolean can_do_next; - GError *error = NULL; - - if (log_window == NULL) - return; - - if (!tpl_log_manager_get_events_for_date_finish (TPL_LOG_MANAGER (manager), - result, &messages, &error)) { - DEBUG ("Unable to retrieve messages for the selected date: %s. Aborting", - error->message); - empathy_chat_view_append_event (window->chatview_find, - "Unable to retrieve messages for the selected date"); - g_error_free (error); - return; - } - - for (l = messages; l; l = l->next) { - EmpathyMessage *message; - - g_assert (TPL_IS_EVENT (l->data)); - - message = empathy_message_from_tpl_log_event (l->data); - g_object_unref (l->data); - empathy_chat_view_append_message (window->chatview_find, message); - g_object_unref (message); - } - g_list_free (messages); - - /* Scroll to the most recent messages */ - empathy_chat_view_scroll (window->chatview_find, TRUE); - - /* Highlight and find messages */ - empathy_chat_view_highlight (window->chatview_find, - window->last_find, - FALSE); - empathy_chat_view_find_next (window->chatview_find, - window->last_find, - TRUE, - FALSE); - empathy_chat_view_find_abilities (window->chatview_find, - window->last_find, - FALSE, - &can_do_previous, - &can_do_next); - gtk_widget_set_sensitive (window->button_previous, can_do_previous); - gtk_widget_set_sensitive (window->button_next, can_do_next); - gtk_widget_set_sensitive (window->button_find, FALSE); -} - -static GDate * -gdate_from_str (const gchar *str) -{ - guint u; - guint day, month, year; - - if (sscanf (str, "%u", &u) != 1) - return NULL; - - day = (u % 100); - month = ((u / 100) % 100); - year = (u / 10000); - - if (!g_date_valid_dmy (day, month, year)) - return NULL; - - return g_date_new_dmy (day, month, year); +toolbutton_av_clicked (GtkToolButton *toolbutton, + EmpathyLogWindow *window) +{ + GtkTreeView *view; + GtkTreeSelection *selection; + GtkTreeModel *model; + GtkTreeIter iter; + GtkTreePath *path; + GList *paths; + TpAccount *account; + gchar *contact; + gint type; + gboolean video; + + g_return_if_fail (window != NULL); + + view = GTK_TREE_VIEW (log_window->treeview_who); + selection = gtk_tree_view_get_selection (view); + + paths = gtk_tree_selection_get_selected_rows (selection, &model); + g_return_if_fail (paths != NULL); + + path = paths->data; + gtk_tree_model_get_iter (model, &iter, path); + gtk_tree_model_get (model, &iter, + COL_WHO_ACCOUNT, &account, + COL_WHO_NAME, &contact, + COL_WHO_TYPE, &type, + -1); + + g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free); + + g_return_if_fail (type == COL_TYPE_NORMAL); + + video = (GTK_WIDGET (toolbutton) == window->button_video); + + empathy_call_new_with_streams (contact, account, + TRUE, video, gtk_get_current_event_time ()); + + g_free (contact); + g_object_unref (account); } -static void -log_window_find_changed_cb (GtkTreeSelection *selection, - EmpathyLogWindow *window) +GtkWidget * +empathy_log_window_show (TpAccount *account, + const gchar *chat_id, + gboolean is_chatroom, + GtkWindow *parent) { - GtkTreeView *view; - GtkTreeModel *model; - GtkTreeIter iter; - TpAccount *account; - TplEntity *target; - gchar *date; - GDate *gdate; + EmpathyAccountChooser *account_chooser; + GtkBuilder *gui; + gchar *filename; + EmpathyLogWindow *window; + GtkWidget *vbox, *accounts, *search, *label, *quit; + + if (log_window != NULL) + { + gtk_window_present (GTK_WINDOW (log_window->window)); + + if (account != NULL && chat_id != NULL) + select_account_once_ready (log_window, account, chat_id, is_chatroom); + + return log_window->window; + } + + log_window = g_new0 (EmpathyLogWindow, 1); + log_window->chain = _tpl_action_chain_new_async (NULL, NULL, NULL); + + log_window->log_manager = tpl_log_manager_dup_singleton (); + + window = log_window; + + filename = empathy_file_lookup ("empathy-log-window.ui", "libempathy-gtk"); + gui = empathy_builder_get_file (filename, + "log_window", &window->window, + "toolbutton_profile", &window->button_profile, + "toolbutton_chat", &window->button_chat, + "toolbutton_call", &window->button_call, + "toolbutton_video", &window->button_video, + "toolbutton_accounts", &accounts, + "toolbutton_search", &search, + "imagemenuitem_quit", &quit, + "treeview_who", &window->treeview_who, + "treeview_what", &window->treeview_what, + "treeview_when", &window->treeview_when, + "treeview_events", &window->treeview_events, + NULL); + g_free (filename); + + empathy_builder_connect (gui, window, + "log_window", "destroy", log_window_destroy_cb, + "toolbutton_profile", "clicked", toolbutton_profile_clicked, + "toolbutton_chat", "clicked", toolbutton_chat_clicked, + "toolbutton_call", "clicked", toolbutton_av_clicked, + "toolbutton_video", "clicked", toolbutton_av_clicked, + "imagemenuitem_delete", "activate", log_window_delete_menu_clicked_cb, + NULL); + + g_object_unref (gui); + + g_object_add_weak_pointer (G_OBJECT (window->window), + (gpointer) &log_window); + + g_signal_connect_swapped (quit, "activate", + G_CALLBACK (gtk_widget_destroy), window->window); + + /* Account chooser for chats */ + vbox = gtk_vbox_new (FALSE, 3); + + window->account_chooser = empathy_account_chooser_new (); + account_chooser = EMPATHY_ACCOUNT_CHOOSER (window->account_chooser); + empathy_account_chooser_set_has_all_option (account_chooser, TRUE); + empathy_account_chooser_set_filter (account_chooser, + empathy_account_chooser_filter_has_logs, NULL); + + g_signal_connect (window->account_chooser, "changed", + G_CALLBACK (log_window_chats_accounts_changed_cb), + window); + + label = gtk_label_new (_("Show")); - /* Get selected information */ - view = GTK_TREE_VIEW (window->treeview_find); - model = gtk_tree_view_get_model (view); + gtk_box_pack_start (GTK_BOX (vbox), + window->account_chooser, + FALSE, FALSE, 0); - if (!gtk_tree_selection_get_selected (selection, NULL, &iter)) { - gtk_widget_set_sensitive (window->button_previous, FALSE); - gtk_widget_set_sensitive (window->button_next, FALSE); + gtk_box_pack_start (GTK_BOX (vbox), + label, + FALSE, FALSE, 0); - empathy_chat_view_clear (window->chatview_find); + gtk_widget_show_all (vbox); + gtk_container_add (GTK_CONTAINER (accounts), vbox); - return; - } + /* Search entry */ + vbox = gtk_vbox_new (FALSE, 3); - gtk_widget_set_sensitive (window->button_previous, TRUE); - gtk_widget_set_sensitive (window->button_next, TRUE); + window->search_entry = gtk_entry_new (); + gtk_entry_set_icon_from_stock (GTK_ENTRY (window->search_entry), + GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_FIND); + gtk_entry_set_icon_from_stock (GTK_ENTRY (window->search_entry), + GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR); - gtk_tree_model_get (model, &iter, - COL_FIND_ACCOUNT, &account, - COL_FIND_TARGET, &target, - COL_FIND_DATE, &date, - -1); + label = gtk_label_new (_("Search")); - /* Clear all current messages shown in the textview */ - empathy_chat_view_clear (window->chatview_find); + gtk_box_pack_start (GTK_BOX (vbox), + window->search_entry, + FALSE, FALSE, 0); - /* Turn off scrolling temporarily */ - empathy_chat_view_scroll (window->chatview_find, FALSE); + gtk_box_pack_start (GTK_BOX (vbox), + label, + FALSE, FALSE, 0); - /* Get messages */ - gdate = gdate_from_str (date); + gtk_widget_show_all (vbox); + gtk_container_add (GTK_CONTAINER (search), vbox); - if (gdate != NULL) { - tpl_log_manager_get_events_for_date_async (window->log_manager, - account, - target, - TPL_EVENT_MASK_TEXT, - gdate, - got_events_for_date_cb, - window); + g_signal_connect (window->search_entry, "changed", + G_CALLBACK (log_window_search_entry_changed_cb), + window); - g_date_free (gdate); - } + g_signal_connect (window->search_entry, "activate", + G_CALLBACK (log_window_search_entry_activate_cb), + window); - g_object_unref (account); - g_object_unref (target); - g_free (date); -} + g_signal_connect (window->search_entry, "icon-press", + G_CALLBACK (log_window_search_entry_icon_pressed_cb), + window); + /* Contacts */ + log_window_events_setup (window); + log_window_who_setup (window); + log_window_what_setup (window); + log_window_when_setup (window); -static void -log_manager_searched_new_cb (GObject *manager, - GAsyncResult *result, - gpointer user_data) -{ - GList *hits; - GList *l; - GtkTreeIter iter; - GtkListStore *store = user_data; - GError *error = NULL; - - if (log_window == NULL) - return; - - if (!tpl_log_manager_search_finish (TPL_LOG_MANAGER (manager), result, - &hits, &error)) { - DEBUG ("%s. Aborting", error->message); - g_error_free (error); - return; - } - - for (l = hits; l; l = l->next) { - TplLogSearchHit *hit; - const gchar *account_name; - const gchar *account_icon; - gchar date_readable[255]; - gchar tmp[255]; - - hit = l->data; - - /* Protect against invalid data (corrupt or old log files. */ - if (hit->account == NULL || hit->target == NULL) { - continue; - } - - g_date_strftime (date_readable, sizeof (date_readable), - EMPATHY_DATE_FORMAT_DISPLAY_SHORT, hit->date); - - g_date_strftime (tmp, sizeof (tmp), - "%Y%m%d", hit->date); - - account_name = tp_account_get_display_name (hit->account); - account_icon = tp_account_get_icon_name (hit->account); - - gtk_list_store_append (store, &iter); - gtk_list_store_set (store, &iter, - COL_FIND_ACCOUNT_ICON, account_icon, - COL_FIND_ACCOUNT_NAME, account_name, - COL_FIND_ACCOUNT, hit->account, - COL_FIND_CHAT_NAME, tpl_entity_get_alias (hit->target), - COL_FIND_TARGET, hit->target, - COL_FIND_DATE, tmp, - COL_FIND_DATE_READABLE, date_readable, - -1); - - /* FIXME: Update COL_FIND_CHAT_NAME */ - if (tpl_entity_get_entity_type (hit->target) == TPL_ENTITY_ROOM) { - } else { - } - } - - if (hits != NULL) { - tpl_log_manager_search_free (hits); - } + log_window_who_populate (window); + + if (account != NULL && chat_id != NULL) + select_account_once_ready (window, account, chat_id, is_chatroom); + + if (parent != NULL) + gtk_window_set_transient_for (GTK_WINDOW (window->window), + GTK_WINDOW (parent)); + + gtk_widget_show (window->window); + + return window->window; } static void -log_window_find_populate (EmpathyLogWindow *window, - const gchar *search_criteria) +log_window_destroy_cb (GtkWidget *widget, + EmpathyLogWindow *window) { - GtkTreeView *view; - GtkTreeModel *model; - GtkTreeSelection *selection; - GtkListStore *store; + if (window->source != 0) + g_source_remove (window->source); - view = GTK_TREE_VIEW (window->treeview_find); - model = gtk_tree_view_get_model (view); - selection = gtk_tree_view_get_selection (view); - store = GTK_LIST_STORE (model); + g_free (window->last_find); + _tpl_action_chain_free (window->chain); + g_object_unref (window->log_manager); + tp_clear_object (&window->selected_account); + g_free (window->selected_chat_id); - empathy_chat_view_clear (window->chatview_find); + g_free (window); +} - gtk_list_store_clear (store); +static gboolean +account_equal (TpAccount *a, + TpAccount *b) +{ + return g_str_equal (tp_proxy_get_object_path (a), + tp_proxy_get_object_path (b)); +} - if (EMP_STR_EMPTY (search_criteria)) { - /* Just clear the search. */ - return; - } +static gboolean +entity_equal (TplEntity *a, + TplEntity *b) +{ + return g_str_equal (tpl_entity_get_identifier (a), + tpl_entity_get_identifier (b)); +} - tpl_log_manager_search_async (window->log_manager, - search_criteria, TPL_EVENT_MASK_TEXT, - log_manager_searched_new_cb, (gpointer) store); +static gboolean +is_same_confroom (TplEvent *e1, + TplEvent *e2) +{ + TplEntity *sender1 = tpl_event_get_sender (e1); + TplEntity *receiver1 = tpl_event_get_receiver (e1); + TplEntity *sender2 = tpl_event_get_sender (e2); + TplEntity *receiver2 = tpl_event_get_receiver (e2); + TplEntity *room1, *room2; + + if (tpl_entity_get_entity_type (sender1) == TPL_ENTITY_ROOM) + room1 = sender1; + else if (tpl_entity_get_entity_type (receiver1) == TPL_ENTITY_ROOM) + room1 = receiver1; + else + return FALSE; + + if (tpl_entity_get_entity_type (sender2) == TPL_ENTITY_ROOM) + room2 = sender2; + else if (tpl_entity_get_entity_type (receiver2) == TPL_ENTITY_ROOM) + room2 = receiver2; + else + return FALSE; + + return g_str_equal (tpl_entity_get_identifier (room1), + tpl_entity_get_identifier (room1)); } -static void -log_window_find_setup (EmpathyLogWindow *window) -{ - GtkTreeView *view; - GtkTreeModel *model; - GtkTreeSelection *selection; - GtkTreeSortable *sortable; - GtkTreeViewColumn *column; - GtkListStore *store; - GtkCellRenderer *cell; - gint offset; - - view = GTK_TREE_VIEW (window->treeview_find); - selection = gtk_tree_view_get_selection (view); - - /* New store */ - store = gtk_list_store_new (COL_FIND_COUNT, - G_TYPE_STRING, /* account icon name */ - G_TYPE_STRING, /* account name */ - TP_TYPE_ACCOUNT, /* account */ - G_TYPE_STRING, /* chat name */ - TPL_TYPE_ENTITY, /* target */ - G_TYPE_STRING, /* date */ - G_TYPE_STRING); /* date_readable */ - - model = GTK_TREE_MODEL (store); - sortable = GTK_TREE_SORTABLE (store); - - gtk_tree_view_set_model (view, model); - - /* New column */ - column = gtk_tree_view_column_new (); - - cell = gtk_cell_renderer_pixbuf_new (); - gtk_tree_view_column_pack_start (column, cell, FALSE); - gtk_tree_view_column_add_attribute (column, cell, - "icon-name", - COL_FIND_ACCOUNT_ICON); - - cell = gtk_cell_renderer_text_new (); - gtk_tree_view_column_pack_start (column, cell, TRUE); - gtk_tree_view_column_add_attribute (column, cell, - "text", - COL_FIND_ACCOUNT_NAME); - - gtk_tree_view_column_set_title (column, _("Account")); - gtk_tree_view_append_column (view, column); - - gtk_tree_view_column_set_resizable (column, TRUE); - gtk_tree_view_column_set_clickable (column, TRUE); - - cell = gtk_cell_renderer_text_new (); - offset = gtk_tree_view_insert_column_with_attributes (view, -1, _("Conversation"), - cell, "text", COL_FIND_CHAT_NAME, - NULL); - - column = gtk_tree_view_get_column (view, offset - 1); - gtk_tree_view_column_set_sort_column_id (column, COL_FIND_CHAT_NAME); - gtk_tree_view_column_set_resizable (column, TRUE); - gtk_tree_view_column_set_clickable (column, TRUE); - - cell = gtk_cell_renderer_text_new (); - offset = gtk_tree_view_insert_column_with_attributes (view, -1, _("Date"), - cell, "text", COL_FIND_DATE_READABLE, - NULL); - - column = gtk_tree_view_get_column (view, offset - 1); - gtk_tree_view_column_set_sort_column_id (column, COL_FIND_DATE); - gtk_tree_view_column_set_resizable (column, TRUE); - gtk_tree_view_column_set_clickable (column, TRUE); - - /* Set up treeview properties */ - gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); - gtk_tree_sortable_set_sort_column_id (sortable, - COL_FIND_DATE, - GTK_SORT_ASCENDING); - - /* Set up signals */ - g_signal_connect (selection, "changed", - G_CALLBACK (log_window_find_changed_cb), - window); - - g_object_unref (store); +static TplEntity * +event_get_target (TplEvent *event) +{ + TplEntity *sender = tpl_event_get_sender (event); + TplEntity *receiver = tpl_event_get_receiver (event); + + if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF) + return receiver; + + return sender; } -static void -start_find_search (EmpathyLogWindow *window) +static gboolean +model_is_parent (GtkTreeModel *model, + GtkTreeIter *iter, + TplEvent *event) { - const gchar *str; + TplEvent *stored_event; + TplEntity *target; + TpAccount *account; + gboolean found = FALSE; + GtkTreeIter parent; + + if (gtk_tree_model_iter_parent (model, &parent, iter)) + return FALSE; + + gtk_tree_model_get (model, iter, + COL_EVENTS_ACCOUNT, &account, + COL_EVENTS_TARGET, &target, + COL_EVENTS_EVENT, &stored_event, + -1); + + if (G_OBJECT_TYPE (event) == G_OBJECT_TYPE (stored_event) && + account_equal (account, tpl_event_get_account (event)) && + (entity_equal (target, event_get_target (event)) || + is_same_confroom (event, stored_event))) + { + GtkTreeIter child; + gint64 timestamp; + + gtk_tree_model_iter_nth_child (model, &child, iter, + gtk_tree_model_iter_n_children (model, iter) - 1); + + gtk_tree_model_get (model, &child, + COL_EVENTS_TS, ×tamp, + -1); + + if (ABS (tpl_event_get_timestamp (event) - timestamp) < MAX_GAP) + { + /* The gap is smaller than 30 min */ + found = TRUE; + } + } + + g_object_unref (stored_event); + g_object_unref (account); + g_object_unref (target); - str = gtk_entry_get_text (GTK_ENTRY (window->entry_find)); + return found; +} + +static const gchar * +get_contact_alias_for_message (EmpathyMessage *message) +{ + EmpathyContact *sender, *receiver; - /* Don't find the same crap again */ - if (window->last_find && !tp_strdiff (window->last_find, str)) { - return; - } + sender = empathy_message_get_sender (message); + receiver = empathy_message_get_receiver (message); - g_free (window->last_find); - window->last_find = g_strdup (str); + if (empathy_contact_is_user (sender)) + return empathy_contact_get_alias (receiver); - log_window_find_populate (window, str); + return empathy_contact_get_alias (sender); } static void -log_window_button_find_clicked_cb (GtkWidget *widget, - EmpathyLogWindow *window) +get_parent_iter_for_message (TplEvent *event, + EmpathyMessage *message, + GtkTreeIter *parent) { - start_find_search (window); + GtkTreeStore *store; + GtkTreeModel *model; + GtkTreeIter iter; + gboolean parent_found = FALSE; + gboolean next; + + store = log_window->store_events; + model = GTK_TREE_MODEL (store); + + for (next = gtk_tree_model_get_iter_first (model, &iter); + next; + next = gtk_tree_model_iter_next (model, &iter)) + { + if ((parent_found = model_is_parent (model, &iter, event))) + break; + } + + if (parent_found) + { + *parent = iter; + } + else + { + GDateTime *date; + gchar *body, *pretty_date; + + date = g_date_time_new_from_unix_utc ( + tpl_event_get_timestamp (event)); + + pretty_date = g_date_time_format (date, + C_("A date with the time", "%A, %e %B %Y %X")); + + body = g_strdup_printf (_("Chat with %s"), + get_contact_alias_for_message (message)); + + gtk_tree_store_append (store, &iter, NULL); + gtk_tree_store_set (store, &iter, + COL_EVENTS_TS, tpl_event_get_timestamp (event), + COL_EVENTS_PRETTY_DATE, pretty_date, + COL_EVENTS_TEXT, body, + COL_EVENTS_ICON, "stock_text_justify", + COL_EVENTS_ACCOUNT, tpl_event_get_account (event), + COL_EVENTS_TARGET, event_get_target (event), + COL_EVENTS_EVENT, event, + -1); + + *parent = iter; + + g_free (body); + g_free (pretty_date); + g_date_time_unref (date); + } } -static void -log_window_entry_find_activate_cb (GtkWidget *entry, - EmpathyLogWindow *self) +static const gchar * +get_icon_for_event (TplEvent *event) { - start_find_search (self); + const gchar *icon = NULL; + + if (TPL_IS_CALL_EVENT (event)) + { + TplCallEvent *call = TPL_CALL_EVENT (event); + TplCallEndReason reason = tpl_call_event_get_end_reason (call); + TplEntity *sender = tpl_event_get_sender (event); + TplEntity *receiver = tpl_event_get_receiver (event); + + if (reason == TPL_CALL_END_REASON_NO_ANSWER) + icon = EMPATHY_IMAGE_CALL_MISSED; + else if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF) + icon = EMPATHY_IMAGE_CALL_OUTGOING; + else if (tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF) + icon = EMPATHY_IMAGE_CALL_INCOMING; + } + + return icon; } static void -log_window_button_next_clicked_cb (GtkWidget *widget, - EmpathyLogWindow *window) -{ - if (window->last_find) { - gboolean can_do_previous; - gboolean can_do_next; - - empathy_chat_view_find_next (window->chatview_find, - window->last_find, - FALSE, - FALSE); - empathy_chat_view_find_abilities (window->chatview_find, - window->last_find, - FALSE, - &can_do_previous, - &can_do_next); - gtk_widget_set_sensitive (window->button_previous, can_do_previous); - gtk_widget_set_sensitive (window->button_next, can_do_next); - } +log_window_append_chat_message (TplEvent *event, + EmpathyMessage *message) +{ + GtkTreeStore *store = log_window->store_events; + GtkTreeIter iter, parent; + gchar *pretty_date, *body; + GDateTime *date; + + date = g_date_time_new_from_unix_utc ( + tpl_event_get_timestamp (event)); + + pretty_date = g_date_time_format (date, "%X"); + + get_parent_iter_for_message (event, message, &parent); + + if (tpl_text_event_get_message_type (TPL_TEXT_EVENT (event)) + == TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION) + { + body = g_strdup_printf ("* %s %s", + tpl_entity_get_alias (tpl_event_get_sender (event)), + empathy_message_get_body (message)); + } + else + { + body = g_strdup_printf ( + C_("First is a contact, second is what was said", "%s: %s"), + tpl_entity_get_alias (tpl_event_get_sender (event)), + empathy_message_get_body (message)); + } + + gtk_tree_store_append (store, &iter, &parent); + gtk_tree_store_set (store, &iter, + COL_EVENTS_TS, tpl_event_get_timestamp (event), + COL_EVENTS_PRETTY_DATE, pretty_date, + COL_EVENTS_TEXT, body, + COL_EVENTS_ICON, get_icon_for_event (event), + COL_EVENTS_ACCOUNT, tpl_event_get_account (event), + COL_EVENTS_TARGET, event_get_target (event), + COL_EVENTS_EVENT, event, + -1); + + g_free (body); + g_free (pretty_date); + g_date_time_unref (date); } static void -log_window_button_previous_clicked_cb (GtkWidget *widget, - EmpathyLogWindow *window) -{ - if (window->last_find) { - gboolean can_do_previous; - gboolean can_do_next; - - empathy_chat_view_find_previous (window->chatview_find, - window->last_find, - FALSE, - FALSE); - empathy_chat_view_find_abilities (window->chatview_find, - window->last_find, - FALSE, - &can_do_previous, - &can_do_next); - gtk_widget_set_sensitive (window->button_previous, can_do_previous); - gtk_widget_set_sensitive (window->button_next, can_do_next); - } +log_window_append_call (TplEvent *event, + EmpathyMessage *message) +{ + TplCallEvent *call = TPL_CALL_EVENT (event); + GtkTreeStore *store = log_window->store_events; + GtkTreeIter iter, child; + gchar *pretty_date, *body, *duration, *finished; + GDateTime *started_date, *finished_date; + GTimeSpan span; + + started_date = g_date_time_new_from_unix_utc ( + tpl_event_get_timestamp (event)); + + pretty_date = g_date_time_format (started_date, + C_("A date with the time", "%A, %e %B %Y %X")); + + gtk_tree_store_append (store, &iter, NULL); + gtk_tree_store_set (store, &iter, + COL_EVENTS_TS, tpl_event_get_timestamp (event), + COL_EVENTS_PRETTY_DATE, pretty_date, + COL_EVENTS_TEXT, empathy_message_get_body (message), + COL_EVENTS_ICON, get_icon_for_event (event), + COL_EVENTS_ACCOUNT, tpl_event_get_account (event), + COL_EVENTS_TARGET, event_get_target (event), + COL_EVENTS_EVENT, event, + -1); + + if (tpl_call_event_get_end_reason (call) != TPL_CALL_END_REASON_NO_ANSWER) + { + span = tpl_call_event_get_duration (TPL_CALL_EVENT (event)); + if (span < 60) + duration = g_strdup_printf (_("%" G_GINT64_FORMAT " seconds"), span); + else + duration = g_strdup_printf (_("%" G_GINT64_FORMAT " minutes"), + span / 60); + + finished_date = g_date_time_add (started_date, -span); + finished = g_date_time_format (finished_date, "%X"); + g_date_time_unref (finished_date); + + body = g_strdup_printf (_("Call took %s, ended at %s"), + duration, finished); + + g_free (duration); + g_free (finished); + + gtk_tree_store_append (store, &child, &iter); + gtk_tree_store_set (store, &child, + COL_EVENTS_TS, tpl_event_get_timestamp (event), + COL_EVENTS_TEXT, body, + COL_EVENTS_ACCOUNT, tpl_event_get_account (event), + COL_EVENTS_TARGET, event_get_target (event), + COL_EVENTS_EVENT, event, + -1); + } + + g_free (body); + g_free (pretty_date); + g_date_time_unref (started_date); } -/* - * Chats Code - */ +static void +log_window_append_message (TplEvent *event, + EmpathyMessage *message) +{ + if (TPL_IS_TEXT_EVENT (event)) + log_window_append_chat_message (event, message); + else if (TPL_IS_CALL_EVENT (event)) + log_window_append_call (event, message); + else + DEBUG ("Message type not handled"); +} static void -log_window_chats_changed_cb (GtkTreeSelection *selection, - EmpathyLogWindow *window) +add_all_accounts_and_entities (GList **accounts, + GList **entities) { - gboolean selected; + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeIter iter; + + view = GTK_TREE_VIEW (log_window->treeview_who); + model = gtk_tree_view_get_model (view); + + if (!gtk_tree_model_get_iter_first (model, &iter)) + return; + + do + { + TpAccount *account; + TplEntity *entity; + gint type; + + gtk_tree_model_get (model, &iter, + COL_WHO_ACCOUNT, &account, + COL_WHO_TARGET, &entity, + COL_WHO_TYPE, &type, + -1); - /* The calendar has to be sensitive only if there is something selected */ - selected = log_window_chats_get_selected (window, NULL, NULL); - gtk_widget_set_sensitive (window->calendar_chats, selected); + if (type != COL_TYPE_NORMAL) + continue; - /* Use last date by default */ - gtk_calendar_clear_marks (GTK_CALENDAR (window->calendar_chats)); + if (accounts != NULL) + *accounts = g_list_append (*accounts, account); - log_window_chats_get_messages (window, NULL); + if (entities != NULL) + *entities = g_list_append (*entities, entity); + } + while (gtk_tree_model_iter_next (model, &iter)); } -static void -log_manager_got_entities_cb (GObject *manager, - GAsyncResult *result, - gpointer user_data) -{ - GList *entities; - GList *l; - GtkTreeView *view; - GtkTreeModel *model; - GtkTreeSelection *selection; - GtkListStore *store; - GtkTreeIter iter; - GError *error = NULL; - gboolean select_account = FALSE; - TpAccount *account = user_data; - - if (log_window == NULL) - goto out; - - if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager), - result, &entities, &error)) { - DEBUG ("%s. Aborting", error->message); - g_error_free (error); - goto out; - } - - view = GTK_TREE_VIEW (log_window->treeview_chats); - model = gtk_tree_view_get_model (view); - selection = gtk_tree_view_get_selection (view); - store = GTK_LIST_STORE (model); - - for (l = entities; l; l = l->next) { - TplEntity *entity; - - entity = TPL_ENTITY (l->data); - - gtk_list_store_append (store, &iter); - gtk_list_store_set (store, &iter, - COL_CHAT_ICON, "empathy-available", /* FIXME */ - COL_CHAT_NAME, tpl_entity_get_alias (entity), - COL_CHAT_ACCOUNT, account, - COL_CHAT_TARGET, entity, - -1); - - if (log_window->selected_account != NULL && - !tp_strdiff (tp_proxy_get_object_path (account), - tp_proxy_get_object_path (log_window->selected_account))) - select_account = TRUE; - - /* FIXME: Update COL_CHAT_ICON/NAME */ - if (tpl_entity_get_entity_type (entity) == TPL_ENTITY_ROOM) { - } else { - } - } - g_list_free_full (entities, g_object_unref); - - /* Unblock signals */ - g_signal_handlers_unblock_by_func (selection, - log_window_chats_changed_cb, - log_window); - - /* We display the selected account if we populate the model with chats from - * this account. */ - if (select_account) - log_window_chats_set_selected (log_window); +static gboolean +log_window_get_selected (EmpathyLogWindow *window, + GList **accounts, + GList **entities, + GList **dates, + TplEventTypeMask *event_mask, + EventSubtype *subtype) +{ + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeSelection *selection; + GtkTreeIter iter; + TplEventTypeMask ev = 0; + EventSubtype st = 0; + GList *paths, *l; + gint type; + + view = GTK_TREE_VIEW (window->treeview_who); + model = gtk_tree_view_get_model (view); + selection = gtk_tree_view_get_selection (view); + + paths = gtk_tree_selection_get_selected_rows (selection, NULL); + if (paths == NULL) + return FALSE; + + if (accounts != NULL) + *accounts = NULL; + if (entities != NULL) + *entities = NULL; + + for (l = paths; l != NULL; l = l->next) + { + GtkTreePath *path = l->data; + TpAccount *account; + TplEntity *entity; + + gtk_tree_model_get_iter (model, &iter, path); + gtk_tree_model_get (model, &iter, + COL_WHO_ACCOUNT, &account, + COL_WHO_TARGET, &entity, + COL_WHO_TYPE, &type, + -1); + + if (type == COL_TYPE_ANY) + { + if (accounts != NULL || entities != NULL) + add_all_accounts_and_entities (accounts, entities); + break; + } + + if (accounts != NULL) + *accounts = g_list_append (*accounts, g_object_ref (account)); + + if (entities != NULL) + *entities = g_list_append (*entities, g_object_ref (entity)); + + g_object_unref (account); + g_object_unref (entity); + } + g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free); + + view = GTK_TREE_VIEW (window->treeview_what); + model = gtk_tree_view_get_model (view); + selection = gtk_tree_view_get_selection (view); + + paths = gtk_tree_selection_get_selected_rows (selection, NULL); + for (l = paths; l != NULL; l = l->next) + { + GtkTreePath *path = l->data; + TplEventTypeMask mask; + EventSubtype submask; + + gtk_tree_model_get_iter (model, &iter, path); + gtk_tree_model_get (model, &iter, + COL_WHAT_TYPE, &mask, + COL_WHAT_SUBTYPE, &submask, + -1); + + ev |= mask; + st |= submask; + } + g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free); + + view = GTK_TREE_VIEW (window->treeview_when); + model = gtk_tree_view_get_model (view); + selection = gtk_tree_view_get_selection (view); + + if (dates != NULL) + { + *dates = NULL; + + paths = gtk_tree_selection_get_selected_rows (selection, NULL); + for (l = paths; l != NULL; l = l->next) + { + GtkTreePath *path = l->data; + GDate *date; + + gtk_tree_model_get_iter (model, &iter, path); + gtk_tree_model_get (model, &iter, + COL_WHEN_DATE, &date, + -1); + + *dates = g_list_append (*dates, date); + } + g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free); + } + + if (event_mask != NULL) + *event_mask = ev; + + if (subtype != NULL) + *subtype = st; + + return TRUE; +} -out: - g_object_unref (account); +static gboolean +model_has_entity (GtkTreeModel *model, + GtkTreePath *path, + GtkTreeIter *iter, + gpointer data) +{ + TplLogSearchHit *hit = data; + TplEntity *e; + TpAccount *a; + gboolean ret = FALSE; + + gtk_tree_model_get (model, iter, + COL_WHO_TARGET, &e, + COL_WHO_ACCOUNT, &a, + -1); + + if (e != NULL && entity_equal (hit->target, e) && + a != NULL && account_equal (hit->account, a)) + { + ret = has_element = TRUE; + } + + tp_clear_object (&e); + tp_clear_object (&a); + + return ret; } +static gboolean +model_has_date (GtkTreeModel *model, + GtkTreePath *path, + GtkTreeIter *iter, + gpointer data) +{ + GDate *date = data; + GDate *d; + + gtk_tree_model_get (model, iter, + COL_WHEN_DATE, &d, + -1); + + if (!g_date_compare (date, d)) + { + has_element = TRUE; + return TRUE; + } + + return FALSE; +} + +static void +get_events_for_date (TplActionChain *chain, gpointer user_data); + static void -log_window_chats_populate (EmpathyLogWindow *window) +populate_events_from_search_hits (GList *accounts, + GList *targets, + GList *dates) { - EmpathyAccountChooser *account_chooser; - TpAccount *account; + TplEventTypeMask event_mask; + EventSubtype subtype; + GDate *anytime; + GList *l; + gboolean is_anytime = FALSE; - GtkTreeView *view; - GtkTreeModel *model; - GtkTreeSelection *selection; - GtkListStore *store; + if (!log_window_get_selected (log_window, + NULL, NULL, NULL, &event_mask, &subtype)) + return; - account_chooser = EMPATHY_ACCOUNT_CHOOSER (window->account_chooser_chats); - account = empathy_account_chooser_dup_account (account_chooser); + anytime = g_date_new_dmy (2, 1, -1); + if (g_list_find_custom (dates, anytime, (GCompareFunc) g_date_compare)) + is_anytime = TRUE; + + for (l = log_window->hits; l != NULL; l = l->next) + { + TplLogSearchHit *hit = l->data; + GList *acc, *targ; + gboolean found = FALSE; + + /* Protect against invalid data (corrupt or old log files). */ + if (hit->account == NULL || hit->target == NULL) + continue; + + for (acc = accounts, targ = targets; + acc != NULL && targ != NULL && !found; + acc = acc->next, targ = targ->next) + { + TpAccount *account = acc->data; + TplEntity *target = targ->data; + + if (account_equal (hit->account, account) && + entity_equal (hit->target, target)) + found = TRUE; + } + + if (!found) + continue; - view = GTK_TREE_VIEW (window->treeview_chats); - model = gtk_tree_view_get_model (view); - selection = gtk_tree_view_get_selection (view); - store = GTK_LIST_STORE (model); + if (is_anytime || + g_list_find_custom (dates, hit->date, (GCompareFunc) g_date_compare) + != NULL) + { + Ctx *ctx; - if (account == NULL) { - gtk_list_store_clear (store); - return; - } + ctx = ctx_new (log_window, hit->account, hit->target, hit->date, + event_mask, subtype, log_window->count); + _tpl_action_chain_append (log_window->chain, + get_events_for_date, ctx); + } + } - /* Block signals to stop the logs being retrieved prematurely */ - g_signal_handlers_block_by_func (selection, - log_window_chats_changed_cb, - window); + _tpl_action_chain_start (log_window->chain); - gtk_list_store_clear (store); + g_date_free (anytime); +} - /* Pass the account reference to the callback */ - tpl_log_manager_get_entities_async (window->log_manager, account, - log_manager_got_entities_cb, account); +static gchar * +format_date_for_display (GDate *date) +{ + gchar *text; + GDate *now = NULL; + gint days_elapsed; + + /* g_date_strftime sucks */ + + now = g_date_new (); + g_date_set_time_t (now, time (NULL)); + + days_elapsed = g_date_days_between (date, now); + + if (days_elapsed < 0) + { + text = NULL; + } + else if (days_elapsed == 0) + { + text = g_strdup (_("Today")); + } + else if (days_elapsed == 1) + { + text = g_strdup (_("Yesterday")); + } + else + { + GDateTime *dt; + + dt = g_date_time_new_utc (g_date_get_year (date), + g_date_get_month (date), g_date_get_day (date), + 0, 0, 0); + + if (days_elapsed <= 7) + text = g_date_time_format (dt, "%A"); + else + text = g_date_time_format (dt, + C_("A date such as '23 May 2010', " + "%e is the day, %B the month and %Y the year", + "%e %B %Y")); + + g_date_time_unref (dt); + } + + g_date_free (now); + + return text; } static void -log_window_chats_setup (EmpathyLogWindow *window) +populate_dates_from_search_hits (GList *accounts, + GList *targets) { - GtkTreeView *view; - GtkTreeModel *model; - GtkTreeSelection *selection; - GtkTreeSortable *sortable; - GtkTreeViewColumn *column; - GtkListStore *store; - GtkCellRenderer *cell; + GList *l; + GtkTreeView *view; + GtkTreeModel *model; + GtkListStore *store; + GtkTreeSelection *selection; + GtkTreeIter iter; - view = GTK_TREE_VIEW (window->treeview_chats); - selection = gtk_tree_view_get_selection (view); + if (log_window == NULL) + return; - /* new store */ - store = gtk_list_store_new (COL_CHAT_COUNT, - G_TYPE_STRING, /* icon */ - G_TYPE_STRING, /* name */ - TP_TYPE_ACCOUNT, /* account */ - TPL_TYPE_ENTITY); /* target */ + view = GTK_TREE_VIEW (log_window->treeview_when); + model = gtk_tree_view_get_model (view); + store = GTK_LIST_STORE (model); + selection = gtk_tree_view_get_selection (view); + + for (l = log_window->hits; l != NULL; l = l->next) + { + TplLogSearchHit *hit = l->data; + GList *acc, *targ; + gboolean found = FALSE; + + /* Protect against invalid data (corrupt or old log files). */ + if (hit->account == NULL || hit->target == NULL) + continue; + + for (acc = accounts, targ = targets; + acc != NULL && targ != NULL && !found; + acc = acc->next, targ = targ->next) + { + TpAccount *account = acc->data; + TplEntity *target = targ->data; + + if (account_equal (hit->account, account) && + entity_equal (hit->target, target)) + found = TRUE; + } + + if (!found) + continue; - model = GTK_TREE_MODEL (store); - sortable = GTK_TREE_SORTABLE (store); + /* Add the date if it's not already there */ + has_element = FALSE; + gtk_tree_model_foreach (model, model_has_date, hit->date); + if (!has_element) + { + gchar *text = format_date_for_display (hit->date); + + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, + COL_WHEN_DATE, hit->date, + COL_WHEN_TEXT, text, + COL_WHEN_ICON, CALENDAR_ICON, + -1); + } + } + + if (gtk_tree_model_get_iter_first (model, &iter)) + { + gtk_list_store_prepend (store, &iter); + gtk_list_store_set (store, &iter, + COL_WHEN_DATE, g_date_new_dmy (1, 1, -1), + COL_WHEN_TEXT, "separator", + -1); + + gtk_list_store_prepend (store, &iter); + gtk_list_store_set (store, &iter, + COL_WHEN_DATE, g_date_new_dmy (2, 1, -1), + COL_WHEN_TEXT, _("Anytime"), + -1); + + gtk_tree_selection_select_iter (selection, &iter); + } +} - gtk_tree_view_set_model (view, model); +static void +populate_entities_from_search_hits (void) +{ + EmpathyAccountChooser *account_chooser; + TpAccount *account; + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeIter iter; + GtkListStore *store; + GList *l; - /* new column */ - column = gtk_tree_view_column_new (); + view = GTK_TREE_VIEW (log_window->treeview_who); + model = gtk_tree_view_get_model (view); + store = GTK_LIST_STORE (model); + + gtk_list_store_clear (store); + + account_chooser = EMPATHY_ACCOUNT_CHOOSER (log_window->account_chooser); + account = empathy_account_chooser_get_account (account_chooser); + + for (l = log_window->hits; l; l = l->next) + { + TplLogSearchHit *hit = l->data; + + /* Protect against invalid data (corrupt or old log files). */ + if (hit->account == NULL || hit->target == NULL) + continue; + + /* Filter based on the selected account */ + if (account != NULL && !account_equal (account, hit->account)) + continue; + + /* Add the entity if it's not already there */ + has_element = FALSE; + gtk_tree_model_foreach (model, model_has_entity, hit); + if (!has_element) + { + TplEntityType type = tpl_entity_get_entity_type (hit->target); + gboolean room = type == TPL_ENTITY_ROOM; + + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, + COL_WHO_TYPE, COL_TYPE_NORMAL, + COL_WHO_ICON, room ? EMPATHY_IMAGE_GROUP_MESSAGE + : EMPATHY_IMAGE_AVATAR_DEFAULT, + COL_WHO_NAME, tpl_entity_get_alias (hit->target), + COL_WHO_ACCOUNT, hit->account, + COL_WHO_TARGET, hit->target, + -1); + } + } + + if (gtk_tree_model_get_iter_first (model, &iter)) + { + gtk_list_store_prepend (store, &iter); + gtk_list_store_set (store, &iter, + COL_WHO_TYPE, COL_TYPE_SEPARATOR, + COL_WHO_NAME, "separator", + -1); + + gtk_list_store_prepend (store, &iter); + gtk_list_store_set (store, &iter, + COL_WHO_TYPE, COL_TYPE_ANY, + COL_WHO_NAME, _("Anyone"), + -1); + } + + /* FIXME: select old entity if still available */ +} - cell = gtk_cell_renderer_pixbuf_new (); - gtk_tree_view_column_pack_start (column, cell, FALSE); - gtk_tree_view_column_add_attribute (column, cell, - "icon-name", - COL_CHAT_ICON); +static void +log_manager_searched_new_cb (GObject *manager, + GAsyncResult *result, + gpointer user_data) +{ + GList *hits; + GtkTreeView *view; + GtkTreeSelection *selection; + GError *error = NULL; - cell = gtk_cell_renderer_text_new (); - g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL); - gtk_tree_view_column_pack_start (column, cell, TRUE); - gtk_tree_view_column_add_attribute (column, cell, - "text", - COL_CHAT_NAME); + if (log_window == NULL) + return; + + if (!tpl_log_manager_search_finish (TPL_LOG_MANAGER (manager), + result, &hits, &error)) + { + DEBUG ("%s. Aborting", error->message); + g_error_free (error); + return; + } - gtk_tree_view_append_column (view, column); + tp_clear_pointer (&log_window->hits, tpl_log_manager_search_free); + log_window->hits = hits; - /* set up treeview properties */ - gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); - gtk_tree_sortable_set_sort_column_id (sortable, - COL_CHAT_NAME, - GTK_SORT_ASCENDING); + populate_entities_from_search_hits (); - /* set up signals */ - g_signal_connect (selection, "changed", - G_CALLBACK (log_window_chats_changed_cb), - window); + view = GTK_TREE_VIEW (log_window->treeview_when); + selection = gtk_tree_view_get_selection (view); - g_object_unref (store); + g_signal_handlers_unblock_by_func (selection, + log_window_when_changed_cb, + log_window); } static void -log_window_chats_accounts_changed_cb (GtkWidget *combobox, - EmpathyLogWindow *window) +log_window_find_populate (EmpathyLogWindow *window, + const gchar *search_criteria) { - /* Clear all current messages shown in the textview */ - empathy_chat_view_clear (window->chatview_chats); + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeSelection *selection; + GtkListStore *store; - log_window_chats_populate (window); + gtk_tree_store_clear (window->store_events); - /* No chat is selected as we just changed the account */ - gtk_widget_set_sensitive (window->calendar_chats, FALSE); -} + view = GTK_TREE_VIEW (window->treeview_who); + model = gtk_tree_view_get_model (view); + store = GTK_LIST_STORE (model); -static void -log_window_chats_set_selected (EmpathyLogWindow *window) -{ - GtkTreeView *view; - GtkTreeModel *model; - GtkTreeSelection *selection; - GtkTreeIter iter; - GtkTreePath *path; - gboolean ok; - - view = GTK_TREE_VIEW (window->treeview_chats); - model = gtk_tree_view_get_model (view); - selection = gtk_tree_view_get_selection (view); - - if (!gtk_tree_model_get_iter_first (model, &iter)) { - return; - } - - for (ok = TRUE; ok; ok = gtk_tree_model_iter_next (model, &iter)) { - TpAccount *this_account; - TplEntity *this_target; - const gchar *this_chat_id; - gboolean this_is_chatroom; - - gtk_tree_model_get (model, &iter, - COL_CHAT_ACCOUNT, &this_account, - COL_CHAT_TARGET, &this_target, - -1); - - this_chat_id = tpl_entity_get_identifier (this_target); - this_is_chatroom = tpl_entity_get_entity_type (this_target) == TPL_ENTITY_ROOM; - - if (this_account == window->selected_account && - !tp_strdiff (this_chat_id, window->selected_chat_id) && - this_is_chatroom == window->selected_is_chatroom) { - gtk_tree_selection_select_iter (selection, &iter); - path = gtk_tree_model_get_path (model, &iter); - gtk_tree_view_scroll_to_cell (view, path, NULL, TRUE, 0.5, 0.0); - gtk_tree_path_free (path); - g_object_unref (this_account); - g_object_unref (this_target); - break; - } - - g_object_unref (this_account); - g_object_unref (this_target); - } - - tp_clear_object (&window->selected_account); - tp_clear_pointer (&window->selected_chat_id, g_free); + gtk_list_store_clear (store); + + view = GTK_TREE_VIEW (window->treeview_when); + model = gtk_tree_view_get_model (view); + store = GTK_LIST_STORE (model); + selection = gtk_tree_view_get_selection (view); + + gtk_list_store_clear (store); + + if (EMP_STR_EMPTY (search_criteria)) + { + tp_clear_pointer (&window->hits, tpl_log_manager_search_free); + log_window_who_populate (window); + return; + } + + g_signal_handlers_block_by_func (selection, + log_window_when_changed_cb, + window); + + tpl_log_manager_search_async (window->log_manager, + search_criteria, TPL_EVENT_MASK_ANY, + log_manager_searched_new_cb, NULL); } static gboolean -log_window_chats_get_selected (EmpathyLogWindow *window, - TpAccount **account, - TplEntity **target) +start_find_search (EmpathyLogWindow *window) { - GtkTreeView *view; - GtkTreeModel *model; - GtkTreeSelection *selection; - GtkTreeIter iter; - TplEntity *targ; - TpAccount *acc = NULL; + const gchar *str; - view = GTK_TREE_VIEW (window->treeview_chats); - model = gtk_tree_view_get_model (view); - selection = gtk_tree_view_get_selection (view); + str = gtk_entry_get_text (GTK_ENTRY (window->search_entry)); - if (!gtk_tree_selection_get_selected (selection, NULL, &iter)) { - return FALSE; - } + /* Don't find the same crap again */ + if (window->last_find && !tp_strdiff (window->last_find, str)) + return FALSE; - gtk_tree_model_get (model, &iter, - COL_CHAT_ACCOUNT, &acc, - COL_CHAT_TARGET, &targ, - -1); + g_free (window->last_find); + window->last_find = g_strdup (str); - if (account != NULL) { - *account = g_object_ref (acc); - } + log_window_find_populate (window, str); - if (target != NULL) { - *target = g_object_ref (targ); - } + return FALSE; +} - g_object_unref (acc); - g_object_unref (targ); +static void +log_window_search_entry_changed_cb (GtkWidget *entry, + EmpathyLogWindow *window) +{ + if (window->source != 0) + g_source_remove (window->source); + window->source = g_timeout_add (500, (GSourceFunc) start_find_search, + window); +} - return TRUE; +static void +log_window_search_entry_activate_cb (GtkWidget *entry, + EmpathyLogWindow *self) +{ + start_find_search (self); } static void -log_window_got_messages_for_date_cb (GObject *manager, +log_window_search_entry_icon_pressed_cb (GtkEntry *entry, + GtkEntryIconPosition icon_pos, + GdkEvent *event, + gpointer user_data) +{ + if (icon_pos != GTK_ENTRY_ICON_SECONDARY) + return; + + gtk_entry_buffer_set_text (gtk_entry_get_buffer (entry), + "", -1); +} + +/* + * Chats Code + */ + +static void +log_window_who_changed_cb (GtkTreeSelection *selection, + EmpathyLogWindow *window) +{ + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeIter iter; + gboolean someone = FALSE; + + DEBUG ("log_window_who_changed_cb"); + + view = gtk_tree_selection_get_tree_view (selection); + model = gtk_tree_view_get_model (view); + + if (gtk_tree_model_get_iter_first (model, &iter)) + { + /* If 'Anyone' is selected, everything else should be deselected */ + if (gtk_tree_selection_iter_is_selected (selection, &iter)) + { + g_signal_handlers_block_by_func (selection, + log_window_who_changed_cb, + window); + + gtk_tree_selection_unselect_all (selection); + gtk_tree_selection_select_iter (selection, &iter); + + g_signal_handlers_unblock_by_func (selection, + log_window_who_changed_cb, + window); + } + else if (gtk_tree_selection_count_selected_rows (selection) == 1) + { + someone = TRUE; + } + } + + gtk_widget_set_sensitive (window->button_profile, someone); + gtk_widget_set_sensitive (window->button_chat, someone); + gtk_widget_set_sensitive (window->button_call, someone); + gtk_widget_set_sensitive (window->button_video, someone); + + /* The contact changed, so the dates need to be updated */ + log_window_chats_get_messages (window, TRUE); +} + +static void +log_manager_got_entities_cb (GObject *manager, GAsyncResult *result, gpointer user_data) { - EmpathyLogWindow *window = user_data; - GList *events; - GList *l; - GError *error = NULL; + Ctx *ctx = user_data; + GList *entities; + GList *l; + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeSelection *selection; + GtkListStore *store; + GtkTreeIter iter; + GError *error = NULL; + gboolean select_account = FALSE; if (log_window == NULL) - return; + goto out; - if (!tpl_log_manager_get_events_for_date_finish (TPL_LOG_MANAGER (manager), - result, &events, &error)) { - DEBUG ("Unable to retrieve messages for the selected date: %s. Aborting", - error->message); - empathy_chat_view_append_event (window->chatview_find, - "Unable to retrieve messages for the selected date"); - g_error_free (error); - return; - } - - for (l = events; l; l = l->next) { - EmpathyMessage *message = empathy_message_from_tpl_log_event (l->data); - g_object_unref (l->data); - empathy_chat_view_append_message (window->chatview_chats, - message); - g_object_unref (message); - } - g_list_free (events); + if (log_window->count != ctx->count) + goto out; - /* Turn back on scrolling */ - empathy_chat_view_scroll (window->chatview_find, TRUE); + if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager), + result, &entities, &error)) + { + DEBUG ("%s. Aborting", error->message); + g_error_free (error); + goto out; + } + + view = GTK_TREE_VIEW (ctx->window->treeview_who); + model = gtk_tree_view_get_model (view); + selection = gtk_tree_view_get_selection (view); + store = GTK_LIST_STORE (model); + + /* Block signals to stop the logs being retrieved prematurely */ + g_signal_handlers_block_by_func (selection, + log_window_who_changed_cb, ctx->window); + + for (l = entities; l; l = l->next) + { + TplEntity *entity = TPL_ENTITY (l->data); + TplEntityType type = tpl_entity_get_entity_type (entity); + gboolean room = type == TPL_ENTITY_ROOM; + + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, + COL_WHO_TYPE, COL_TYPE_NORMAL, + COL_WHO_ICON, room ? EMPATHY_IMAGE_GROUP_MESSAGE + : EMPATHY_IMAGE_AVATAR_DEFAULT, + COL_WHO_NAME, tpl_entity_get_alias (entity), + COL_WHO_ACCOUNT, ctx->account, + COL_WHO_TARGET, entity, + -1); + + if (ctx->window->selected_account != NULL && + !tp_strdiff (tp_proxy_get_object_path (ctx->account), + tp_proxy_get_object_path (ctx->window->selected_account))) + select_account = TRUE; + } + g_list_free_full (entities, g_object_unref); + + if (gtk_tree_model_get_iter_first (model, &iter)) + { + gint type; + + gtk_tree_model_get (model, &iter, + COL_WHO_TYPE, &type, + -1); + + if (type != COL_TYPE_ANY) + { + gtk_list_store_prepend (store, &iter); + gtk_list_store_set (store, &iter, + COL_WHO_TYPE, COL_TYPE_SEPARATOR, + COL_WHO_NAME, "separator", + -1); + + gtk_list_store_prepend (store, &iter); + gtk_list_store_set (store, &iter, + COL_WHO_TYPE, COL_TYPE_ANY, + COL_WHO_NAME, _("Anyone"), + -1); + } + } + + /* Unblock signals */ + g_signal_handlers_unblock_by_func (selection, + log_window_who_changed_cb, + ctx->window); + + /* We display the selected account if we populate the model with chats from + * this account. */ + if (select_account) + log_window_chats_set_selected (ctx->window); - /* Give the search entry main focus */ - gtk_widget_grab_focus (window->entry_chats); +out: + _tpl_action_chain_continue (log_window->chain); + ctx_free (ctx); } - static void -log_window_get_messages_for_date (EmpathyLogWindow *window, - GDate *date) +get_entities_for_account (TplActionChain *chain, gpointer user_data) { - TpAccount *account; - TplEntity *target; + Ctx *ctx = user_data; - if (!log_window_chats_get_selected (window, &account, &target)) { - return; - } + tpl_log_manager_get_entities_async (ctx->window->log_manager, ctx->account, + log_manager_got_entities_cb, ctx); +} - /* Clear all current messages shown in the textview */ - empathy_chat_view_clear (window->chatview_chats); +static void +select_first_entity (TplActionChain *chain, gpointer user_data) +{ + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeSelection *selection; + GtkTreeIter iter; - /* Turn off scrolling temporarily */ - empathy_chat_view_scroll (window->chatview_find, FALSE); + view = GTK_TREE_VIEW (log_window->treeview_who); + model = gtk_tree_view_get_model (view); + selection = gtk_tree_view_get_selection (view); - /* Get events */ - tpl_log_manager_get_events_for_date_async (window->log_manager, - account, target, TPL_EVENT_MASK_TEXT, - date, - log_window_got_messages_for_date_cb, - (gpointer) window); + if (gtk_tree_model_get_iter_first (model, &iter)) + gtk_tree_selection_select_iter (selection, &iter); - g_object_unref (account); - g_object_unref (target); + _tpl_action_chain_continue (log_window->chain); } static void -log_manager_got_dates_cb (GObject *manager, - GAsyncResult *result, - gpointer user_data) +log_window_who_populate (EmpathyLogWindow *window) { - EmpathyLogWindow *window = user_data; - GList *dates; - GList *l; - guint year_selected; - guint month_selected; - gboolean day_selected = FALSE; - GDate *date = NULL; - GError *error = NULL; + EmpathyAccountChooser *account_chooser; + TpAccount *account; + gboolean all_accounts; + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeSelection *selection; + GtkListStore *store; + Ctx *ctx; + + if (window->hits != NULL) + { + populate_entities_from_search_hits (); + return; + } - if (log_window == NULL) - return; + account_chooser = EMPATHY_ACCOUNT_CHOOSER (window->account_chooser); + account = empathy_account_chooser_dup_account (account_chooser); + all_accounts = empathy_account_chooser_has_all_selected (account_chooser); - if (!tpl_log_manager_get_dates_finish (TPL_LOG_MANAGER (manager), - result, &dates, &error)) { - DEBUG ("Unable to retrieve messages' dates: %s. Aborting", - error->message); - empathy_chat_view_append_event (window->chatview_find, - "Unable to retrieve messages' dates"); - return; - } + view = GTK_TREE_VIEW (window->treeview_who); + model = gtk_tree_view_get_model (view); + selection = gtk_tree_view_get_selection (view); + store = GTK_LIST_STORE (model); - for (l = dates; l; l = l->next) { - GDate *d = l->data; + /* Block signals to stop the logs being retrieved prematurely */ + g_signal_handlers_block_by_func (selection, + log_window_who_changed_cb, + window); - gtk_calendar_get_date (GTK_CALENDAR (window->calendar_chats), - &year_selected, - &month_selected, - NULL); + gtk_list_store_clear (store); - month_selected++; + /* Unblock signals */ + g_signal_handlers_unblock_by_func (selection, + log_window_who_changed_cb, + window); - if (!l->next) { - date = d; - } + _tpl_action_chain_clear (window->chain); + window->count++; - if (g_date_get_year (d) != year_selected || - g_date_get_month (d) != month_selected) { - continue; - } + if (!all_accounts && account == NULL) + { + return; + } + else if (!all_accounts) + { + ctx = ctx_new (window, account, NULL, NULL, 0, 0, window->count); + _tpl_action_chain_append (window->chain, get_entities_for_account, ctx); + } + else + { + TpAccountManager *manager; + GList *accounts, *l; + + manager = empathy_account_chooser_get_account_manager (account_chooser); + accounts = tp_account_manager_get_valid_accounts (manager); + + for (l = accounts; l != NULL; l = l->next) + { + account = l->data; + + ctx = ctx_new (window, account, NULL, NULL, 0, 0, window->count); + _tpl_action_chain_append (window->chain, + get_entities_for_account, ctx); + } + + g_list_free (accounts); + } + _tpl_action_chain_append (window->chain, select_first_entity, NULL); + _tpl_action_chain_start (window->chain); +} - DEBUG ("Marking date: %04u-%02u-%02u", g_date_get_year (d), - g_date_get_month (d), g_date_get_day (d)); +static gint +sort_by_name (GtkTreeModel *model, + GtkTreeIter *a, + GtkTreeIter *b, + gpointer user_data) +{ + gchar *name1, *name2; + gint type1, type2; + gint ret; + + gtk_tree_model_get (model, a, + COL_WHO_TYPE, &type1, + COL_WHO_NAME, &name1, + -1); + + gtk_tree_model_get (model, b, + COL_WHO_TYPE, &type2, + COL_WHO_NAME, &name2, + -1); + + if (type1 == COL_TYPE_ANY) + ret = -1; + else if (type2 == COL_TYPE_ANY) + ret = 1; + else if (type1 == COL_TYPE_SEPARATOR) + ret = -1; + else if (type2 == COL_TYPE_SEPARATOR) + ret = 1; + else + ret = g_strcmp0 (name1, name2); + + g_free (name1); + g_free (name2); + + return ret; +} - gtk_calendar_mark_day (GTK_CALENDAR (window->calendar_chats), - g_date_get_day (d)); +static gboolean +who_row_is_separator (GtkTreeModel *model, + GtkTreeIter *iter, + gpointer data) +{ + gint type; - if (l->next) { - continue; - } + gtk_tree_model_get (model, iter, + COL_WHO_TYPE, &type, + -1); - day_selected = TRUE; + return (type == COL_TYPE_SEPARATOR); +} - gtk_calendar_select_day (GTK_CALENDAR (window->calendar_chats), - g_date_get_day (d)); - } +static void +log_window_events_setup (EmpathyLogWindow *window) +{ + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeSelection *selection; + GtkTreeSortable *sortable; + GtkTreeViewColumn *column; + GtkTreeStore *store; + GtkCellRenderer *cell; + + view = GTK_TREE_VIEW (window->treeview_events); + selection = gtk_tree_view_get_selection (view); + + /* new store */ + window->store_events = store = gtk_tree_store_new (COL_EVENTS_COUNT, + G_TYPE_INT, /* type */ + G_TYPE_INT64, /* timestamp */ + G_TYPE_STRING, /* stringified date */ + G_TYPE_STRING, /* icon */ + G_TYPE_STRING, /* name */ + TP_TYPE_ACCOUNT, /* account */ + TPL_TYPE_ENTITY, /* target */ + TPL_TYPE_EVENT); /* event */ + + model = GTK_TREE_MODEL (store); + sortable = GTK_TREE_SORTABLE (store); + + gtk_tree_view_set_model (view, model); + + /* new column */ + column = gtk_tree_view_column_new (); + + cell = gtk_cell_renderer_pixbuf_new (); + gtk_tree_view_column_pack_start (column, cell, FALSE); + gtk_tree_view_column_add_attribute (column, cell, + "icon-name", COL_EVENTS_ICON); + + cell = gtk_cell_renderer_text_new (); + g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL); + gtk_tree_view_column_pack_start (column, cell, TRUE); + gtk_tree_view_column_add_attribute (column, cell, + "text", COL_EVENTS_TEXT); + + cell = gtk_cell_renderer_text_new (); + g_object_set (cell, "xalign", 1.0, NULL); + gtk_tree_view_column_pack_end (column, cell, FALSE); + gtk_tree_view_column_add_attribute (column, cell, + "text", COL_EVENTS_PRETTY_DATE); + + gtk_tree_view_append_column (view, column); + + /* set up treeview properties */ + gtk_tree_selection_set_mode (selection, GTK_SELECTION_NONE); + gtk_tree_view_set_headers_visible (view, FALSE); + + gtk_tree_sortable_set_sort_column_id (sortable, + COL_EVENTS_TS, + GTK_SORT_ASCENDING); + + g_object_unref (store); +} - if (!day_selected) { - /* Unselect the day in the calendar */ - gtk_calendar_select_day (GTK_CALENDAR (window->calendar_chats), 0); - } +static void +log_window_who_setup (EmpathyLogWindow *window) +{ + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeSelection *selection; + GtkTreeSortable *sortable; + GtkTreeViewColumn *column; + GtkListStore *store; + GtkCellRenderer *cell; + + view = GTK_TREE_VIEW (window->treeview_who); + selection = gtk_tree_view_get_selection (view); + + /* new store */ + store = gtk_list_store_new (COL_WHO_COUNT, + G_TYPE_INT, /* type */ + G_TYPE_STRING, /* icon */ + G_TYPE_STRING, /* name */ + TP_TYPE_ACCOUNT, /* account */ + TPL_TYPE_ENTITY); /* target */ + + model = GTK_TREE_MODEL (store); + sortable = GTK_TREE_SORTABLE (store); + + gtk_tree_view_set_model (view, model); + + /* new column */ + column = gtk_tree_view_column_new (); + gtk_tree_view_column_set_title (column, _("Who")); + + cell = gtk_cell_renderer_pixbuf_new (); + gtk_tree_view_column_pack_start (column, cell, FALSE); + gtk_tree_view_column_add_attribute (column, cell, + "icon-name", + COL_WHO_ICON); + + cell = gtk_cell_renderer_text_new (); + g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL); + gtk_tree_view_column_pack_start (column, cell, TRUE); + gtk_tree_view_column_add_attribute (column, cell, + "text", + COL_WHO_NAME); + + gtk_tree_view_append_column (view, column); + + /* set up treeview properties */ + gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE); + gtk_tree_view_set_row_separator_func (view, who_row_is_separator, + NULL, NULL); + + gtk_tree_sortable_set_sort_column_id (sortable, + COL_WHO_NAME, + GTK_SORT_ASCENDING); + gtk_tree_sortable_set_sort_func (sortable, + COL_WHO_NAME, sort_by_name, + NULL, NULL); + + /* set up signals */ + g_signal_connect (selection, "changed", + G_CALLBACK (log_window_who_changed_cb), window); + + g_object_unref (store); +} - g_signal_handlers_unblock_by_func (window->calendar_chats, - log_window_calendar_chats_day_selected_cb, - window); +static void +log_window_chats_accounts_changed_cb (GtkWidget *combobox, + EmpathyLogWindow *window) +{ + /* Clear all current messages shown in the textview */ + gtk_tree_store_clear (window->store_events); - if (date != NULL) { - /* Show messages of the most recent date */ - log_window_get_messages_for_date (window, date); - } + log_window_who_populate (window); +} - g_list_foreach (dates, (GFunc) g_free, NULL); - g_list_free (dates); +static void +log_window_chats_set_selected (EmpathyLogWindow *window) +{ + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeSelection *selection; + GtkTreeIter iter; + GtkTreePath *path; + gboolean next; + + view = GTK_TREE_VIEW (window->treeview_who); + model = gtk_tree_view_get_model (view); + selection = gtk_tree_view_get_selection (view); + + for (next = gtk_tree_model_get_iter_first (model, &iter); + next; + next = gtk_tree_model_iter_next (model, &iter)) + { + TpAccount *this_account; + TplEntity *this_target; + const gchar *this_chat_id; + gboolean this_is_chatroom; + + gtk_tree_model_get (model, &iter, + COL_WHO_ACCOUNT, &this_account, + COL_WHO_TARGET, &this_target, + -1); + + this_chat_id = tpl_entity_get_identifier (this_target); + this_is_chatroom = tpl_entity_get_entity_type (this_target) + == TPL_ENTITY_ROOM; + + if (this_account == window->selected_account && + !tp_strdiff (this_chat_id, window->selected_chat_id) && + this_is_chatroom == window->selected_is_chatroom) + { + gtk_tree_selection_select_iter (selection, &iter); + path = gtk_tree_model_get_path (model, &iter); + gtk_tree_view_scroll_to_cell (view, path, NULL, TRUE, 0.5, 0.0); + gtk_tree_path_free (path); + g_object_unref (this_account); + g_object_unref (this_target); + break; + } + + g_object_unref (this_account); + g_object_unref (this_target); + } + + tp_clear_object (&window->selected_account); + tp_clear_pointer (&window->selected_chat_id, g_free); } +static gint +sort_by_date (GtkTreeModel *model, + GtkTreeIter *a, + GtkTreeIter *b, + gpointer user_data) +{ + GDate *date1, *date2; -static void -log_window_chats_get_messages (EmpathyLogWindow *window, - GDate *date) + gtk_tree_model_get (model, a, + COL_WHEN_DATE, &date1, + -1); + + gtk_tree_model_get (model, b, + COL_WHEN_DATE, &date2, + -1); + + return g_date_compare (date1, date2); +} + +static gboolean +when_row_is_separator (GtkTreeModel *model, + GtkTreeIter *iter, + gpointer data) { - TpAccount *account; - TplEntity *target; - guint year_selected; - guint month_selected; - guint day; + gchar *when; + gboolean ret; + gtk_tree_model_get (model, iter, + COL_WHEN_TEXT, &when, + -1); - if (!log_window_chats_get_selected (window, &account, &target)) { - return; - } + ret = g_str_equal (when, "separator"); + g_free (when); + return ret; +} - g_signal_handlers_block_by_func (window->calendar_chats, - log_window_calendar_chats_day_selected_cb, - window); +static void +log_window_when_changed_cb (GtkTreeSelection *selection, + EmpathyLogWindow *window) +{ + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeIter iter; + + DEBUG ("log_window_when_changed_cb"); + + view = gtk_tree_selection_get_tree_view (selection); + model = gtk_tree_view_get_model (view); + + /* If 'Anytime' is selected, everything else should be deselected */ + if (gtk_tree_model_get_iter_first (model, &iter)) + { + if (gtk_tree_selection_iter_is_selected (selection, &iter)) + { + g_signal_handlers_block_by_func (selection, + log_window_when_changed_cb, + window); + + gtk_tree_selection_unselect_all (selection); + gtk_tree_selection_select_iter (selection, &iter); + + g_signal_handlers_unblock_by_func (selection, + log_window_when_changed_cb, + window); + } + } + + log_window_chats_get_messages (window, FALSE); +} - /* Either use the supplied date or get the last */ - if (date == NULL) { - /* Get a list of dates and show them on the calendar */ - tpl_log_manager_get_dates_async (window->log_manager, - account, target, TPL_EVENT_MASK_TEXT, - log_manager_got_dates_cb, (gpointer) window); - /* signal unblocked at the end of the CB flow */ - } else { - day = g_date_get_day (date); - gtk_calendar_get_date (GTK_CALENDAR (window->calendar_chats), - &year_selected, - &month_selected, - NULL); +static void +log_window_when_setup (EmpathyLogWindow *window) +{ + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeSelection *selection; + GtkTreeSortable *sortable; + GtkTreeViewColumn *column; + GtkListStore *store; + GtkCellRenderer *cell; + + view = GTK_TREE_VIEW (window->treeview_when); + selection = gtk_tree_view_get_selection (view); + + /* new store */ + store = gtk_list_store_new (COL_WHEN_COUNT, + G_TYPE_DATE, /* date */ + G_TYPE_STRING, /* stringified date */ + G_TYPE_STRING); /* icon */ + + model = GTK_TREE_MODEL (store); + sortable = GTK_TREE_SORTABLE (store); + + gtk_tree_view_set_model (view, model); + + /* new column */ + column = gtk_tree_view_column_new (); + gtk_tree_view_column_set_title (column, _("When")); + + cell = gtk_cell_renderer_pixbuf_new (); + gtk_tree_view_column_pack_start (column, cell, FALSE); + gtk_tree_view_column_add_attribute (column, cell, + "icon-name", COL_WHEN_ICON); + + cell = gtk_cell_renderer_text_new (); + g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL); + gtk_tree_view_column_pack_start (column, cell, TRUE); + gtk_tree_view_column_add_attribute (column, cell, + "text", + COL_WHEN_TEXT); + + gtk_tree_view_append_column (view, column); + + /* set up treeview properties */ + gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE); + gtk_tree_view_set_row_separator_func (view, when_row_is_separator, + NULL, NULL); + gtk_tree_sortable_set_sort_column_id (sortable, + COL_WHEN_DATE, + GTK_SORT_DESCENDING); + gtk_tree_sortable_set_sort_func (sortable, + COL_WHEN_DATE, sort_by_date, + NULL, NULL); + + /* set up signals */ + g_signal_connect (selection, "changed", + G_CALLBACK (log_window_when_changed_cb), + window); - month_selected++; + g_object_unref (store); +} - if (g_date_get_year (date) != year_selected && - g_date_get_month (date) != month_selected) { - day = 0; - } +static gboolean +what_row_is_separator (GtkTreeModel *model, + GtkTreeIter *iter, + gpointer data) +{ + gint type; - gtk_calendar_select_day (GTK_CALENDAR (window->calendar_chats), day); + gtk_tree_model_get (model, iter, + COL_WHAT_TYPE, &type, + -1); - g_signal_handlers_unblock_by_func (window->calendar_chats, - log_window_calendar_chats_day_selected_cb, - window); - } + return (type == WHAT_TYPE_SEPARATOR); +} - if (date != NULL) { - /* Show messages of the selected date */ - log_window_get_messages_for_date (window, date); - } +static void +log_window_what_changed_cb (GtkTreeSelection *selection, + EmpathyLogWindow *window) +{ + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeIter iter; + + DEBUG ("log_window_what_changed_cb"); + + view = gtk_tree_selection_get_tree_view (selection); + model = gtk_tree_view_get_model (view); + + /* If 'Anything' is selected, everything else should be deselected */ + if (gtk_tree_model_get_iter_first (model, &iter)) + { + if (gtk_tree_selection_iter_is_selected (selection, &iter)) + { + g_signal_handlers_block_by_func (selection, + log_window_what_changed_cb, + window); + + gtk_tree_selection_unselect_all (selection); + gtk_tree_selection_select_iter (selection, &iter); + + g_signal_handlers_unblock_by_func (selection, + log_window_what_changed_cb, + window); + } + } + + /* The dates need to be updated if we're not searching */ + log_window_chats_get_messages (window, window->hits == NULL); +} - g_object_unref (account); - g_object_unref (target); +static gboolean +log_window_what_collapse_row_cb (GtkTreeView *tree_view, + GtkTreeIter *iter, + GtkTreePath *path, + gpointer user_data) +{ + /* Reject collapsing */ + return TRUE; } +struct event +{ + gint type; + EventSubtype subtype; + const gchar *icon; + const gchar *text; +}; + static void -log_window_calendar_chats_day_selected_cb (GtkWidget *calendar, - EmpathyLogWindow *window) +log_window_what_setup (EmpathyLogWindow *window) { - guint year; - guint month; - guint day; - GDate *date; + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeSelection *selection; + GtkTreeSortable *sortable; + GtkTreeViewColumn *column; + GtkTreeIter iter, parent; + GtkTreeStore *store; + GtkCellRenderer *cell; + guint i; + struct event events [] = { + { TPL_EVENT_MASK_ANY, 0, NULL, _("Anything") }, + { WHAT_TYPE_SEPARATOR, 0, NULL, "separator" }, + { TPL_EVENT_MASK_TEXT, 0, "stock_text_justify", _("Text chats") }, + { TPL_EVENT_MASK_CALL, EVENT_CALL_ALL, "call-start", _("Calls") } + }; + struct event call_events [] = { + { TPL_EVENT_MASK_CALL, EVENT_CALL_INCOMING, "call-start", _("Incoming calls") }, + { TPL_EVENT_MASK_CALL, EVENT_CALL_OUTGOING, "call-start", _("Outgoing calls") }, + { TPL_EVENT_MASK_CALL, EVENT_CALL_MISSED, "call-stop", _("Missed calls") } + }; + + view = GTK_TREE_VIEW (window->treeview_what); + selection = gtk_tree_view_get_selection (view); + + /* new store */ + store = gtk_tree_store_new (COL_WHAT_COUNT, + G_TYPE_INT, /* history type */ + G_TYPE_INT, /* history subtype */ + G_TYPE_STRING, /* stringified history type */ + G_TYPE_STRING, /* icon */ + G_TYPE_BOOLEAN); /* expander (hidden) */ + + model = GTK_TREE_MODEL (store); + sortable = GTK_TREE_SORTABLE (store); + + gtk_tree_view_set_model (view, model); + + /* new column */ + column = gtk_tree_view_column_new (); + gtk_tree_view_column_set_title (column, _("What")); + + cell = gtk_cell_renderer_pixbuf_new (); + gtk_tree_view_column_pack_start (column, cell, FALSE); + gtk_tree_view_column_add_attribute (column, cell, + "icon-name", COL_WHAT_ICON); + + cell = gtk_cell_renderer_text_new (); + g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL); + gtk_tree_view_column_pack_start (column, cell, TRUE); + gtk_tree_view_column_add_attribute (column, cell, + "text", COL_WHAT_TEXT); + + gtk_tree_view_append_column (view, column); + + /* set up treeview properties */ + gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE); + gtk_tree_view_set_show_expanders (view, FALSE); + gtk_tree_view_set_level_indentation (view, 12); + gtk_tree_view_expand_all (view); + gtk_tree_view_set_row_separator_func (view, what_row_is_separator, + NULL, NULL); + + /* populate */ + for (i = 0; i < G_N_ELEMENTS (events); i++) + { + gtk_tree_store_append (store, &iter, NULL); + gtk_tree_store_set (store, &iter, + COL_WHAT_TYPE, events[i].type, + COL_WHAT_SUBTYPE, events[i].subtype, + COL_WHAT_TEXT, events[i].text, + COL_WHAT_ICON, events[i].icon, + -1); + } + + gtk_tree_model_iter_nth_child (model, &parent, NULL, 3); + for (i = 0; i < G_N_ELEMENTS (call_events); i++) + { + gtk_tree_store_append (store, &iter, &parent); + gtk_tree_store_set (store, &iter, + COL_WHAT_TYPE, call_events[i].type, + COL_WHAT_SUBTYPE, call_events[i].subtype, + COL_WHAT_TEXT, call_events[i].text, + COL_WHAT_ICON, call_events[i].icon, + -1); + } + + gtk_tree_view_expand_all (view); + + /* select 'Anything' */ + if (gtk_tree_model_get_iter_first (model, &iter)) + gtk_tree_selection_select_iter (selection, &iter); + + /* set up signals */ + g_signal_connect (view, "test-collapse-row", + G_CALLBACK (log_window_what_collapse_row_cb), + NULL); + g_signal_connect (selection, "changed", + G_CALLBACK (log_window_what_changed_cb), + window); - gtk_calendar_get_date (GTK_CALENDAR (calendar), &year, &month, &day); - if (day == 0) - /* No date selected */ - return; + g_object_unref (store); +} + +static void +log_window_got_messages_for_date_cb (GObject *manager, + GAsyncResult *result, + gpointer user_data) +{ + Ctx *ctx = user_data; + GList *events; + GList *l; + GError *error = NULL; - /* We need this hear because it appears that the months start from 0 */ - month++; + if (log_window == NULL) + goto out; - date = g_date_new_dmy (day, month, year); + if (log_window->count != ctx->count) + goto out; - DEBUG ("Currently selected date is: %04u-%02u-%02u", year, month, day); + if (!tpl_log_manager_get_events_for_date_finish (TPL_LOG_MANAGER (manager), + result, &events, &error)) + { + DEBUG ("Unable to retrieve messages for the selected date: %s. Aborting", + error->message); + g_error_free (error); + goto out; + } + + for (l = events; l; l = l->next) + { + TplEvent *event = l->data; + gboolean append = TRUE; + + if (TPL_IS_CALL_EVENT (l->data) + && ctx->event_mask & TPL_EVENT_MASK_CALL + && ctx->event_mask != TPL_EVENT_MASK_ANY) + { + TplCallEvent *call = l->data; + + append = FALSE; + + if (ctx->subtype & EVENT_CALL_ALL) + { + append = TRUE; + } + else + { + TplCallEndReason reason = tpl_call_event_get_end_reason (call); + TplEntity *sender = tpl_event_get_sender (event); + TplEntity *receiver = tpl_event_get_receiver (event); + + if (reason == TPL_CALL_END_REASON_NO_ANSWER) + { + if (ctx->subtype & EVENT_CALL_MISSED) + append = TRUE; + } + else if (ctx->subtype & EVENT_CALL_OUTGOING + && tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF) + { + append = TRUE; + } + else if (ctx->subtype & EVENT_CALL_INCOMING + && tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF) + { + append = TRUE; + } + } + } + + if (append) + { + EmpathyMessage *msg = empathy_message_from_tpl_log_event (event); + log_window_append_message (event, msg); + g_object_unref (msg); + } + + g_object_unref (event); + } + g_list_free (events); - log_window_chats_get_messages (window, date); + out: + ctx_free (ctx); - g_date_free (date); + _tpl_action_chain_continue (log_window->chain); } static void -log_window_updating_calendar_month_cb (GObject *manager, - GAsyncResult *result, gpointer user_data) -{ - EmpathyLogWindow *window = user_data; - GList *dates; - GList *l; - guint year_selected; - guint month_selected; - GError *error = NULL; - - if (log_window == NULL) - return; - - if (!tpl_log_manager_get_dates_finish (TPL_LOG_MANAGER (manager), - result, &dates, &error)) { - DEBUG ("Unable to retrieve messages' dates: %s. Aborting", - error->message); - empathy_chat_view_append_event (window->chatview_find, - "Unable to retrieve messages' dates"); - g_error_free (error); - return; - } - - gtk_calendar_clear_marks (GTK_CALENDAR (window->calendar_chats)); - g_object_get (window->calendar_chats, - "month", &month_selected, - "year", &year_selected, - NULL); - - /* We need this here because it appears that the months start from 0 */ - month_selected++; - - for (l = dates; l; l = l->next) { - GDate *date = l->data; - - if (g_date_get_year (date) == year_selected && - g_date_get_month (date) == month_selected) { - DEBUG ("Marking date: %04u-%02u-%02u", g_date_get_year (date), - g_date_get_month (date), g_date_get_day (date)); - gtk_calendar_mark_day (GTK_CALENDAR (window->calendar_chats), g_date_get_day (date)); - } - } - - g_list_foreach (dates, (GFunc) g_free, NULL); - g_list_free (dates); - - DEBUG ("Currently showing month %d and year %d", month_selected, - year_selected); +get_events_for_date (TplActionChain *chain, gpointer user_data) +{ + Ctx *ctx = user_data; + + tpl_log_manager_get_events_for_date_async (ctx->window->log_manager, + ctx->account, ctx->entity, ctx->event_mask, + ctx->date, + log_window_got_messages_for_date_cb, + ctx); } static void -log_window_calendar_chats_month_changed_cb (GtkWidget *calendar, - EmpathyLogWindow *window) +log_window_get_messages_for_dates (EmpathyLogWindow *window, + GList *dates) { - TpAccount *account; - TplEntity *target; + GList *accounts, *targets, *acc, *targ, *l; + TplEventTypeMask event_mask; + EventSubtype subtype; + GDate *date, *anytime, *separator; + + if (!log_window_get_selected (window, + &accounts, &targets, NULL, &event_mask, &subtype)) + return; - gtk_calendar_clear_marks (GTK_CALENDAR (calendar)); + anytime = g_date_new_dmy (2, 1, -1); + separator = g_date_new_dmy (1, 1, -1); + + _tpl_action_chain_clear (window->chain); + window->count++; + + for (acc = accounts, targ = targets; + acc != NULL && targ != NULL; + acc = acc->next, targ = targ->next) + { + TpAccount *account = acc->data; + TplEntity *target = targ->data; + + for (l = dates; l != NULL; l = l->next) + { + date = l->data; + + /* Get events */ + if (g_date_compare (date, anytime) != 0) + { + Ctx *ctx; + + ctx = ctx_new (window, account, target, date, event_mask, subtype, + window->count); + _tpl_action_chain_append (window->chain, get_events_for_date, ctx); + } + else + { + GtkTreeView *view = GTK_TREE_VIEW (window->treeview_when); + GtkTreeModel *model = gtk_tree_view_get_model (view); + GtkTreeIter iter; + gboolean next; + GDate *d; + + for (next = gtk_tree_model_get_iter_first (model, &iter); + next; + next = gtk_tree_model_iter_next (model, &iter)) + { + Ctx *ctx; + + gtk_tree_model_get (model, &iter, + COL_WHEN_DATE, &d, + -1); + + if (g_date_compare (d, anytime) != 0 && + g_date_compare (d, separator) != 0) + { + ctx = ctx_new (window, account, target, d, + event_mask, subtype, window->count); + _tpl_action_chain_append (window->chain, get_events_for_date, ctx); + } + } + } + } + } + + _tpl_action_chain_start (window->chain); + + g_list_free_full (accounts, g_object_unref); + g_list_free_full (targets, g_object_unref); + g_date_free (separator); + g_date_free (anytime); +} - if (!log_window_chats_get_selected (window, &account, &target)) { - DEBUG ("No chat selected to get dates for..."); - return; - } +static void +log_manager_got_dates_cb (GObject *manager, + GAsyncResult *result, + gpointer user_data) +{ + Ctx *ctx = user_data; + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeSelection *selection; + GtkListStore *store; + GtkTreeIter iter; + GList *dates; + GList *l; + GError *error = NULL; - /* Get the log object for this contact */ - tpl_log_manager_get_dates_async (window->log_manager, account, target, - TPL_EVENT_MASK_TEXT, - log_window_updating_calendar_month_cb, - (gpointer) window); + if (log_window == NULL) + goto out; - g_object_unref (account); - g_object_unref (target); + if (log_window->count != ctx->count) + goto out; + + if (!tpl_log_manager_get_dates_finish (TPL_LOG_MANAGER (manager), + result, &dates, &error)) + { + DEBUG ("Unable to retrieve messages' dates: %s. Aborting", + error->message); + goto out; + } + + view = GTK_TREE_VIEW (log_window->treeview_when); + model = gtk_tree_view_get_model (view); + store = GTK_LIST_STORE (model); + selection = gtk_tree_view_get_selection (view); + + for (l = dates; l != NULL; l = l->next) + { + GDate *date = l->data; + + /* Add the date if it's not already there */ + has_element = FALSE; + gtk_tree_model_foreach (model, model_has_date, date); + if (!has_element) + { + gchar *text = format_date_for_display (date); + + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, + COL_WHEN_DATE, date, + COL_WHEN_TEXT, text, + COL_WHEN_ICON, CALENDAR_ICON, + -1); + + g_free (text); + } + } + + if (gtk_tree_model_get_iter_first (model, &iter)) + { + gchar *separator = NULL; + + if (gtk_tree_model_iter_next (model, &iter)) + { + gtk_tree_model_get (model, &iter, + COL_WHEN_TEXT, &separator, + -1); + } + + if (g_strcmp0 (separator, "separator") != 0) + { + gtk_list_store_prepend (store, &iter); + gtk_list_store_set (store, &iter, + COL_WHEN_DATE, g_date_new_dmy (1, 1, -1), + COL_WHEN_TEXT, "separator", + -1); + + gtk_list_store_prepend (store, &iter); + gtk_list_store_set (store, &iter, + COL_WHEN_DATE, g_date_new_dmy (2, 1, -1), + COL_WHEN_TEXT, _("Anytime"), + -1); + } + } + + g_list_free_full (dates, g_free); + out: + ctx_free (ctx); + _tpl_action_chain_continue (log_window->chain); } static void -log_window_entry_chats_changed_cb (GtkWidget *entry, - EmpathyLogWindow *window) +select_first_date (TplActionChain *chain, gpointer user_data) { - const gchar *str; + GtkTreeView *view; + GtkTreeModel *model; + GtkTreeSelection *selection; + GtkTreeIter iter; + + view = GTK_TREE_VIEW (log_window->treeview_when); + model = gtk_tree_view_get_model (view); + selection = gtk_tree_view_get_selection (view); - str = gtk_entry_get_text (GTK_ENTRY (window->entry_chats)); - empathy_chat_view_highlight (window->chatview_chats, str, FALSE); + /* Show messages of the most recent date */ + if (gtk_tree_model_get_iter_first (model, &iter)) + gtk_tree_selection_select_iter (selection, &iter); - if (str != NULL) { - empathy_chat_view_find_next (window->chatview_chats, - str, - TRUE, - FALSE); - } + _tpl_action_chain_continue (log_window->chain); } static void -log_window_entry_chats_activate_cb (GtkWidget *entry, - EmpathyLogWindow *window) +get_dates_for_entity (TplActionChain *chain, gpointer user_data) { - const gchar *str; + Ctx *ctx = user_data; - str = gtk_entry_get_text (GTK_ENTRY (window->entry_chats)); + tpl_log_manager_get_dates_async (ctx->window->log_manager, + ctx->account, ctx->entity, ctx->event_mask, + log_manager_got_dates_cb, ctx); +} + +static void +log_window_chats_get_messages (EmpathyLogWindow *window, + gboolean force_get_dates) +{ + GList *accounts, *targets, *dates; + TplEventTypeMask event_mask; + GtkTreeView *view; + GtkTreeModel *model; + GtkListStore *store; + GtkTreeSelection *selection; + + if (!log_window_get_selected (window, &accounts, &targets, + &dates, &event_mask, NULL)) + return; - if (str != NULL) { - empathy_chat_view_find_next (window->chatview_chats, - str, - FALSE, - FALSE); - } + view = GTK_TREE_VIEW (window->treeview_when); + selection = gtk_tree_view_get_selection (view); + model = gtk_tree_view_get_model (view); + store = GTK_LIST_STORE (model); + + /* Clear all current messages shown in the textview */ + gtk_tree_store_clear (window->store_events); + + _tpl_action_chain_clear (window->chain); + window->count++; + + /* If there's a search use the returned hits */ + if (window->hits != NULL) + { + if (force_get_dates) + { + g_signal_handlers_block_by_func (selection, + log_window_when_changed_cb, + window); + + gtk_list_store_clear (store); + + g_signal_handlers_unblock_by_func (selection, + log_window_when_changed_cb, + window); + + populate_dates_from_search_hits (accounts, targets); + } + else + { + populate_events_from_search_hits (accounts, targets, dates); + } + } + /* Either use the supplied date or get the last */ + else if (force_get_dates || dates == NULL) + { + GList *acc, *targ; + + g_signal_handlers_block_by_func (selection, + log_window_when_changed_cb, + window); + + gtk_list_store_clear (store); + + g_signal_handlers_unblock_by_func (selection, + log_window_when_changed_cb, + window); + + /* Get a list of dates and show them on the treeview */ + for (targ = targets, acc = accounts; + targ != NULL && acc != NULL; + targ = targ->next, acc = acc->next) + { + TpAccount *account = acc->data; + TplEntity *target = targ->data; + Ctx *ctx = ctx_new (window, account, target, NULL, event_mask, 0, + window->count); + + _tpl_action_chain_append (window->chain, get_dates_for_entity, ctx); + } + _tpl_action_chain_append (window->chain, select_first_date, NULL); + _tpl_action_chain_start (window->chain); + } + else + { + /* Show messages of the selected date */ + log_window_get_messages_for_dates (window, dates); + } + + g_list_free_full (accounts, g_object_unref); + g_list_free_full (targets, g_object_unref); + g_list_free_full (dates, (GFreeFunc) g_date_free); } typedef struct { - EmpathyAccountChooserFilterResultCallback callback; - gpointer user_data; + EmpathyAccountChooserFilterResultCallback callback; + gpointer user_data; } FilterCallbackData; static void -got_entities (GObject *manager, - GAsyncResult *result, - gpointer user_data) +got_entities (GObject *manager, + GAsyncResult *result, + gpointer user_data) { - FilterCallbackData *data = user_data; - GList *entities; - GError *error; + FilterCallbackData *data = user_data; + GList *entities; + GError *error = NULL; - if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager), result, &entities, &error)) { - DEBUG ("Could not get entities: %s", error->message); - g_error_free (error); - data->callback (FALSE, data->user_data); - } else { - data->callback (entities != NULL, data->user_data); + if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager), + result, &entities, &error)) + { + DEBUG ("Could not get entities: %s", error->message); + g_error_free (error); + data->callback (FALSE, data->user_data); + } + else + { + data->callback (entities != NULL, data->user_data); - g_list_free_full (entities, g_object_unref); - } + g_list_free_full (entities, g_object_unref); + } - g_slice_free (FilterCallbackData, data); + g_slice_free (FilterCallbackData, data); } static void empathy_account_chooser_filter_has_logs (TpAccount *account, - EmpathyAccountChooserFilterResultCallback callback, - gpointer callback_data, - gpointer user_data) + EmpathyAccountChooserFilterResultCallback callback, + gpointer callback_data, + gpointer user_data) { - TplLogManager *manager = tpl_log_manager_dup_singleton (); - FilterCallbackData *cb_data = g_slice_new0 (FilterCallbackData); + TplLogManager *manager = tpl_log_manager_dup_singleton (); + FilterCallbackData *cb_data = g_slice_new0 (FilterCallbackData); - cb_data->callback = callback; - cb_data->user_data = callback_data; + cb_data->callback = callback; + cb_data->user_data = callback_data; - tpl_log_manager_get_entities_async (manager, account, got_entities, cb_data); + tpl_log_manager_get_entities_async (manager, account, got_entities, cb_data); - g_object_unref (manager); + g_object_unref (manager); } static void log_window_logger_clear_account_cb (TpProxy *proxy, - const GError *error, - gpointer user_data, - GObject *weak_object) + const GError *error, + gpointer user_data, + GObject *weak_object) { - EmpathyLogWindow *window = user_data; + EmpathyLogWindow *window = user_data; - if (error != NULL) - g_warning ("Error when clearing logs: %s", error->message); + if (error != NULL) + g_warning ("Error when clearing logs: %s", error->message); - /* Refresh the log viewer so the logs are cleared if the account - * has been deleted */ - empathy_chat_view_clear (window->chatview_chats); - log_window_chats_populate (window); + /* Refresh the log viewer so the logs are cleared if the account + * has been deleted */ + gtk_tree_store_clear (window->store_events); + log_window_who_populate (window); - /* Re-filter the account chooser so the accounts without logs get greyed out */ - empathy_account_chooser_set_filter (EMPATHY_ACCOUNT_CHOOSER (window->account_chooser_chats), - empathy_account_chooser_filter_has_logs, NULL); + /* Re-filter the account chooser so the accounts without logs get greyed out */ + empathy_account_chooser_set_filter ( + EMPATHY_ACCOUNT_CHOOSER (window->account_chooser), + empathy_account_chooser_filter_has_logs, NULL); } static void log_window_clear_logs_chooser_select_account (EmpathyAccountChooser *chooser, - EmpathyLogWindow *window) + EmpathyLogWindow *window) { - empathy_account_chooser_set_account (chooser, - empathy_account_chooser_get_account (EMPATHY_ACCOUNT_CHOOSER (window->account_chooser_chats))); + EmpathyAccountChooser *account_chooser; + + account_chooser = EMPATHY_ACCOUNT_CHOOSER (window->account_chooser); + + empathy_account_chooser_set_account (chooser, + empathy_account_chooser_get_account (account_chooser)); } static void -log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem, - EmpathyLogWindow *window) -{ - GtkWidget *dialog, *content_area, *hbox, *label; - EmpathyAccountChooser *account_chooser; - gint response_id; - TpDBusDaemon *bus; - TpProxy *logger; - GError *error = NULL; - - account_chooser = (EmpathyAccountChooser *) empathy_account_chooser_new (); - empathy_account_chooser_set_has_all_option (account_chooser, TRUE); - empathy_account_chooser_set_filter (account_chooser, empathy_account_chooser_filter_has_logs, NULL); - - /* Select the same account as in the history window */ - if (empathy_account_chooser_is_ready (account_chooser)) - log_window_clear_logs_chooser_select_account (account_chooser, window); - else - g_signal_connect (account_chooser, "ready", - G_CALLBACK (log_window_clear_logs_chooser_select_account), window); - - dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (window->window), - GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, - GTK_BUTTONS_NONE, - _("Are you sure you want to delete all logs of previous conversations?")); - - gtk_dialog_add_buttons (GTK_DIALOG (dialog), - GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, - _("Clear All"), GTK_RESPONSE_APPLY, - NULL); - - content_area = gtk_message_dialog_get_message_area ( - GTK_MESSAGE_DIALOG (dialog)); - - hbox = gtk_hbox_new (FALSE, 6); - label = gtk_label_new (_("Delete from:")); - gtk_box_pack_start (GTK_BOX (hbox), label, - FALSE, FALSE, 0); - gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (account_chooser), - FALSE, FALSE, 0); - gtk_box_pack_start (GTK_BOX (content_area), hbox, - FALSE, FALSE, 0); - - gtk_widget_show_all (hbox); - - response_id = gtk_dialog_run (GTK_DIALOG (dialog)); - - if (response_id != GTK_RESPONSE_APPLY) - goto out; - - bus = tp_dbus_daemon_dup (&error); - if (error != NULL) { - g_warning ("Could not delete logs: %s", error->message); - g_error_free (error); - goto out; - } - - logger = g_object_new (TP_TYPE_PROXY, - "bus-name", "org.freedesktop.Telepathy.Logger", - "object-path", "/org/freedesktop/Telepathy/Logger", - "dbus-daemon", bus, - NULL); - g_object_unref (bus); - - tp_proxy_add_interface_by_id (logger, EMP_IFACE_QUARK_LOGGER); - - if (empathy_account_chooser_has_all_selected (account_chooser)) { - DEBUG ("Deleting logs for all the accounts"); - - emp_cli_logger_call_clear (logger, -1, - log_window_logger_clear_account_cb, - window, NULL, G_OBJECT (window->window)); - } else { - TpAccount *account = empathy_account_chooser_get_account (account_chooser); - - DEBUG ("Deleting logs for %s", tp_proxy_get_object_path (account)); - - emp_cli_logger_call_clear_account (logger, -1, - tp_proxy_get_object_path (account), - log_window_logger_clear_account_cb, - window, NULL, G_OBJECT (window->window)); - } - - g_object_unref (logger); +log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem, + EmpathyLogWindow *window) +{ + GtkWidget *dialog, *content_area, *hbox, *label; + EmpathyAccountChooser *account_chooser; + gint response_id; + TpDBusDaemon *bus; + TpProxy *logger; + GError *error = NULL; + + account_chooser = (EmpathyAccountChooser *) empathy_account_chooser_new (); + empathy_account_chooser_set_has_all_option (account_chooser, TRUE); + empathy_account_chooser_set_filter (account_chooser, + empathy_account_chooser_filter_has_logs, NULL); + + /* Select the same account as in the history window */ + if (empathy_account_chooser_is_ready (account_chooser)) + log_window_clear_logs_chooser_select_account (account_chooser, window); + else + g_signal_connect (account_chooser, "ready", + G_CALLBACK (log_window_clear_logs_chooser_select_account), window); + + dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (window->window), + GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, + GTK_BUTTONS_NONE, + _("Are you sure you want to delete all logs of previous conversations?")); + + gtk_dialog_add_buttons (GTK_DIALOG (dialog), + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + _("Clear All"), GTK_RESPONSE_APPLY, + NULL); + + content_area = gtk_message_dialog_get_message_area ( + GTK_MESSAGE_DIALOG (dialog)); + + hbox = gtk_hbox_new (FALSE, 6); + label = gtk_label_new (_("Delete from:")); + gtk_box_pack_start (GTK_BOX (hbox), label, + FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (account_chooser), + FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (content_area), hbox, + FALSE, FALSE, 0); + + gtk_widget_show_all (hbox); + + response_id = gtk_dialog_run (GTK_DIALOG (dialog)); + + if (response_id != GTK_RESPONSE_APPLY) + goto out; + + bus = tp_dbus_daemon_dup (&error); + if (error != NULL) + { + g_warning ("Could not delete logs: %s", error->message); + g_error_free (error); + goto out; + } + + logger = g_object_new (TP_TYPE_PROXY, + "bus-name", "org.freedesktop.Telepathy.Logger", + "object-path", "/org/freedesktop/Telepathy/Logger", + "dbus-daemon", bus, + NULL); + g_object_unref (bus); + + tp_proxy_add_interface_by_id (logger, EMP_IFACE_QUARK_LOGGER); + + if (empathy_account_chooser_has_all_selected (account_chooser)) + { + DEBUG ("Deleting logs for all the accounts"); + + emp_cli_logger_call_clear (logger, -1, + log_window_logger_clear_account_cb, + window, NULL, G_OBJECT (window->window)); + } + else + { + TpAccount *account; + + account = empathy_account_chooser_get_account (account_chooser); + + DEBUG ("Deleting logs for %s", tp_proxy_get_object_path (account)); + + emp_cli_logger_call_clear_account (logger, -1, + tp_proxy_get_object_path (account), + log_window_logger_clear_account_cb, + window, NULL, G_OBJECT (window->window)); + } + + g_object_unref (logger); out: - gtk_widget_destroy (dialog); + gtk_widget_destroy (dialog); } |