libempathy-gtk/empathy-log-window.c

   1 /*
   2  * Copyright (C) 2006-2007 Imendio AB
   3  * Copyright (C) 2007-2011 Collabora Ltd.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public
  16  * License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  18  * Boston, MA  02110-1301  USA
  19  *
  20  * Authors: Martyn Russell <martyn@imendio.com>
  21  *          Xavier Claessens <xclaesse@gmail.com>
  22  *          Emilio Pozuelo Monfort <emilio.pozuelo@collabora.co.uk>
  23  */
  24
  25 #include "config.h"
  26
  27 #include <string.h>
  28 #include <stdlib.h>
  29
  30 #include <glib/gi18n-lib.h>
  31 #include <gtk/gtk.h>
  32 #include <webkit/webkit.h>
  33
  34 #include <telepathy-glib/telepathy-glib.h>
  35 #include <telepathy-glib/proxy-subclass.h>
  36
  37 #include <telepathy-yell/telepathy-yell.h>
  38
  39 #include <telepathy-logger/telepathy-logger.h>
  40 #ifdef HAVE_CALL_LOGS
  41 # include <telepathy-logger/call-event.h>
  42 #endif
  43
  44 #include <extensions/extensions.h>
  45
  46 #include <libempathy/action-chain-internal.h>
  47 #include <libempathy/empathy-camera-monitor.h>
  48 #include <libempathy/empathy-chatroom-manager.h>
  49 #include <libempathy/empathy-chatroom.h>
  50 #include <libempathy/empathy-gsettings.h>
  51 #include <libempathy/empathy-message.h>
  52 #include <libempathy/empathy-request-util.h>
  53 #include <libempathy/empathy-utils.h>
  54 #include <libempathy/empathy-time.h>
  55
  56 #include "empathy-log-window.h"
  57 #include "empathy-account-chooser.h"
  58 #include "empathy-call-utils.h"
  59 #include "empathy-chat-view.h"
  60 #include "empathy-contact-dialogs.h"
  61 #include "empathy-images.h"
  62 #include "empathy-theme-manager.h"
  63 #include "empathy-ui-utils.h"
  64 #include "empathy-webkit-utils.h"
  65 #include "empathy-geometry.h"
  66
  67 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
  68 #include <libempathy/empathy-debug.h>
  69
  70 #define EMPATHY_NS "http://live.gnome.org/Empathy"
  71
  72 G_DEFINE_TYPE (EmpathyLogWindow, empathy_log_window, GTK_TYPE_WINDOW);
  73
  74 struct _EmpathyLogWindowPriv
  75 {
  76   GtkWidget *vbox;
  77
  78   GtkWidget *button_profile;
  79   GtkWidget *button_chat;
  80   GtkWidget *button_call;
  81   GtkWidget *button_video;
  82
  83   GtkWidget *search_entry;
  84
  85   GtkWidget *notebook;
  86   GtkWidget *spinner;
  87
  88   GtkWidget *treeview_who;
  89   GtkWidget *treeview_what;
  90   GtkWidget *treeview_when;
  91   GtkWidget *webview;
  92
  93   GtkTreeStore *store_events;
  94
  95   GtkWidget *account_chooser;
  96
  97   gchar *last_find;
  98
  99   /* List of selected GDates, free with g_list_free_full (l, g_date_free) */
 100   GList *current_dates;
 101
 102   TplActionChain *chain;
 103   TplLogManager *log_manager;
 104
 105   /* Hash of TpChannel<->TpAccount for use by the observer until we can
 106    * get a TpAccount from a TpConnection or wherever */
 107   GHashTable *channels;
 108   TpBaseClient *observer;
 109
 110   EmpathyContact *selected_contact;
 111   EmpathyContact *events_contact;
 112
 113   EmpathyCameraMonitor *camera_monitor;
 114   GBinding *button_video_binding;
 115
 116   /* Used to cancel logger calls when no longer needed */
 117   guint count;
 118
 119   /* List of owned TplLogSearchHits, free with tpl_log_search_hit_free */
 120   GList *hits;
 121   guint source;
 122
 123   /* Only used while waiting for the account chooser to be ready */
 124   TpAccount *selected_account;
 125   gchar *selected_chat_id;
 126   gboolean selected_is_chatroom;
 127
 128   GSettings *gsettings_chat;
 129   GSettings *gsettings_desktop;
 130 };
 131
 132 static void log_window_search_entry_changed_cb   (GtkWidget        *entry,
 133                                                   EmpathyLogWindow *self);
 134 static void log_window_search_entry_activate_cb  (GtkWidget        *widget,
 135                                                   EmpathyLogWindow *self);
 136 static void log_window_search_entry_icon_pressed_cb (GtkEntry      *entry,
 137                                                   GtkEntryIconPosition icon_pos,
 138                                                   GdkEvent *event,
 139                                                   gpointer user_data);
 140 static void log_window_who_populate              (EmpathyLogWindow *self);
 141 static void log_window_who_setup                 (EmpathyLogWindow *self);
 142 static void log_window_when_setup                (EmpathyLogWindow *self);
 143 static void log_window_what_setup                (EmpathyLogWindow *self);
 144 static void log_window_events_setup              (EmpathyLogWindow *self);
 145 static void log_window_chats_accounts_changed_cb (GtkWidget        *combobox,
 146                                                   EmpathyLogWindow *self);
 147 static void log_window_chats_set_selected        (EmpathyLogWindow *self);
 148 static void log_window_chats_get_messages        (EmpathyLogWindow *self,
 149                                                   gboolean force_get_dates);
 150 static void log_window_when_changed_cb           (GtkTreeSelection *selection,
 151                                                   EmpathyLogWindow *self);
 152 static void log_window_delete_menu_clicked_cb    (GtkMenuItem      *menuitem,
 153                                                   EmpathyLogWindow *self);
 154 static void start_spinner                        (void);
 155
 156 static void log_window_create_observer           (EmpathyLogWindow *window);
 157 static gboolean log_window_events_button_press_event (GtkWidget *webview,
 158     GdkEventButton *event, EmpathyLogWindow *self);
 159 static void log_window_update_buttons_sensitivity (EmpathyLogWindow *self);
 160
 161 static void
 162 empathy_account_chooser_filter_has_logs (TpAccount *account,
 163     EmpathyAccountChooserFilterResultCallback callback,
 164     gpointer callback_data,
 165     gpointer user_data);
 166
 167 enum
 168 {
 169   PAGE_EVENTS,
 170   PAGE_SPINNER,
 171   PAGE_EMPTY
 172 };
 173
 174 enum
 175 {
 176   COL_TYPE_ANY,
 177   COL_TYPE_SEPARATOR,
 178   COL_TYPE_NORMAL
 179 };
 180
 181 enum
 182 {
 183   COL_WHO_TYPE,
 184   COL_WHO_ICON,
 185   COL_WHO_NAME,
 186   COL_WHO_NAME_SORT_KEY,
 187   COL_WHO_ID,
 188   COL_WHO_ACCOUNT,
 189   COL_WHO_TARGET,
 190   COL_WHO_COUNT
 191 };
 192
 193 enum
 194 {
 195   COL_WHAT_TYPE,
 196   COL_WHAT_SUBTYPE,
 197   COL_WHAT_SENSITIVE,
 198   COL_WHAT_TEXT,
 199   COL_WHAT_ICON,
 200   COL_WHAT_COUNT
 201 };
 202
 203 enum
 204 {
 205   COL_WHEN_DATE,
 206   COL_WHEN_TEXT,
 207   COL_WHEN_ICON,
 208   COL_WHEN_COUNT
 209 };
 210
 211 enum
 212 {
 213   COL_EVENTS_TYPE,
 214   COL_EVENTS_TS,
 215   COL_EVENTS_PRETTY_DATE,
 216   COL_EVENTS_ICON,
 217   COL_EVENTS_TEXT,
 218   COL_EVENTS_ACCOUNT,
 219   COL_EVENTS_TARGET,
 220   COL_EVENTS_EVENT,
 221   COL_EVENTS_COUNT
 222 };
 223
 224 #define CALENDAR_ICON "stock_calendar"
 225
 226 /* Seconds between two messages to be considered one conversation */
 227 #define MAX_GAP 30*60
 228
 229 #define WHAT_TYPE_SEPARATOR -1
 230
 231 typedef enum
 232 {
 233   EVENT_CALL_INCOMING = 1 << 0,
 234   EVENT_CALL_OUTGOING = 1 << 1,
 235   EVENT_CALL_MISSED   = 1 << 2,
 236   EVENT_CALL_ALL      = 1 << 3,
 237 } EventSubtype;
 238
 239 static gboolean
 240 log_window_get_selected (EmpathyLogWindow *window,
 241     GList **accounts,
 242     GList **entities,
 243     gboolean *anyone,
 244     GList **dates,
 245     TplEventTypeMask *event_mask,
 246     EventSubtype *subtype);
 247
 248 static EmpathyLogWindow *log_window = NULL;
 249
 250 static gboolean has_element;
 251
 252 #ifndef _date_copy
 253 #define _date_copy(d) g_date_new_julian (g_date_get_julian (d))
 254 #endif
 255
 256 typedef struct
 257 {
 258   EmpathyLogWindow *self;
 259   TpAccount *account;
 260   TplEntity *entity;
 261   GDate *date;
 262   TplEventTypeMask event_mask;
 263   EventSubtype subtype;
 264   guint count;
 265 } Ctx;
 266
 267 static Ctx *
 268 ctx_new (EmpathyLogWindow *self,
 269     TpAccount *account,
 270     TplEntity *entity,
 271     GDate *date,
 272     TplEventTypeMask event_mask,
 273     EventSubtype subtype,
 274     guint count)
 275 {
 276   Ctx *ctx = g_slice_new0 (Ctx);
 277
 278   ctx->self = self;
 279   if (account != NULL)
 280     ctx->account = g_object_ref (account);
 281   if (entity != NULL)
 282     ctx->entity = g_object_ref (entity);
 283   if (date != NULL)
 284     ctx->date = _date_copy (date);
 285   ctx->event_mask = event_mask;
 286   ctx->subtype = subtype;
 287   ctx->count = count;
 288
 289   return ctx;
 290 }
 291
 292 static void
 293 ctx_free (Ctx *ctx)
 294 {
 295   tp_clear_object (&ctx->account);
 296   tp_clear_object (&ctx->entity);
 297   tp_clear_pointer (&ctx->date, g_date_free);
 298
 299   g_slice_free (Ctx, ctx);
 300 }
 301
 302 static void
 303 select_account_once_ready (EmpathyLogWindow *self,
 304     TpAccount *account,
 305     const gchar *chat_id,
 306     gboolean is_chatroom)
 307 {
 308   EmpathyAccountChooser *account_chooser;
 309
 310   account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
 311
 312   tp_clear_object (&self->priv->selected_account);
 313   self->priv->selected_account = g_object_ref (account);
 314
 315   g_free (self->priv->selected_chat_id);
 316   self->priv->selected_chat_id = g_strdup (chat_id);
 317
 318   self->priv->selected_is_chatroom = is_chatroom;
 319
 320   empathy_account_chooser_set_account (account_chooser,
 321       self->priv->selected_account);
 322 }
 323
 324 static void
 325 toolbutton_profile_clicked (GtkToolButton *toolbutton,
 326     EmpathyLogWindow *self)
 327 {
 328   g_return_if_fail (self != NULL);
 329   g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
 330
 331   empathy_contact_information_dialog_show (self->priv->selected_contact,
 332       GTK_WINDOW (self));
 333 }
 334
 335 static void
 336 toolbutton_chat_clicked (GtkToolButton *toolbutton,
 337     EmpathyLogWindow *self)
 338 {
 339   g_return_if_fail (self != NULL);
 340   g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
 341
 342   empathy_chat_with_contact (self->priv->selected_contact,
 343       gtk_get_current_event_time ());
 344 }
 345
 346 static void
 347 toolbutton_av_clicked (GtkToolButton *toolbutton,
 348     EmpathyLogWindow *self)
 349 {
 350   gboolean video;
 351
 352   g_return_if_fail (self != NULL);
 353   g_return_if_fail (EMPATHY_IS_CONTACT (self->priv->selected_contact));
 354
 355   video = (GTK_WIDGET (toolbutton) == self->priv->button_video);
 356
 357   empathy_call_new_with_streams (
 358       empathy_contact_get_id (self->priv->selected_contact),
 359       empathy_contact_get_account (self->priv->selected_contact),
 360       TRUE, video, gtk_get_current_event_time ());
 361 }
 362
 363 static void
 364 insert_or_change_row (EmpathyLogWindow *self,
 365     const char *method,
 366     GtkTreeModel *model,
 367     GtkTreePath *path,
 368     GtkTreeIter *iter)
 369 {
 370   char *str = gtk_tree_path_to_string (path);
 371   char *script, *text, *date, *stock_icon;
 372   char *icon = NULL;
 373
 374   gtk_tree_model_get (model, iter,
 375       COL_EVENTS_TEXT, &text,
 376       COL_EVENTS_PRETTY_DATE, &date,
 377       COL_EVENTS_ICON, &stock_icon,
 378       -1);
 379
 380   if (!tp_str_empty (stock_icon))
 381     {
 382       GtkIconInfo *icon_info = gtk_icon_theme_lookup_icon (
 383           gtk_icon_theme_get_default (),
 384           stock_icon,
 385           GTK_ICON_SIZE_MENU, 0);
 386
 387       if (icon_info != NULL)
 388         icon = g_strdup (gtk_icon_info_get_filename (icon_info));
 389
 390       gtk_icon_info_free (icon_info);
 391     }
 392
 393   script = g_strdup_printf ("javascript:%s([%s], '%s', '%s', '%s');",
 394       method,
 395       g_strdelimit (str, ":", ','),
 396       text,
 397       icon != NULL ? icon : "",
 398       date);
 399
 400   webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
 401       script);
 402
 403   g_free (str);
 404   g_free (text);
 405   g_free (date);
 406   g_free (stock_icon);
 407   g_free (icon);
 408   g_free (script);
 409 }
 410
 411 static void
 412 store_events_row_inserted (GtkTreeModel *model,
 413     GtkTreePath *path,
 414     GtkTreeIter *iter,
 415     EmpathyLogWindow *self)
 416 {
 417   insert_or_change_row (self, "insertRow", model, path, iter);
 418 }
 419
 420 static void
 421 store_events_row_changed (GtkTreeModel *model,
 422     GtkTreePath *path,
 423     GtkTreeIter *iter,
 424     EmpathyLogWindow *self)
 425 {
 426   insert_or_change_row (self, "changeRow", model, path, iter);
 427 }
 428
 429 static void
 430 store_events_row_deleted (GtkTreeModel *model,
 431     GtkTreePath *path,
 432     EmpathyLogWindow *self)
 433 {
 434   char *str = gtk_tree_path_to_string (path);
 435   char *script;
 436
 437   script = g_strdup_printf ("javascript:deleteRow([%s]);",
 438       g_strdelimit (str, ":", ','));
 439
 440   webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
 441       script);
 442
 443   g_free (str);
 444   g_free (script);
 445 }
 446
 447 static void
 448 store_events_has_child_rows (GtkTreeModel *model,
 449     GtkTreePath *path,
 450     GtkTreeIter *iter,
 451     EmpathyLogWindow *self)
 452 {
 453   char *str = gtk_tree_path_to_string (path);
 454   char *script;
 455
 456   script = g_strdup_printf ("javascript:hasChildRows([%s], %u);",
 457       g_strdelimit (str, ":", ','),
 458       gtk_tree_model_iter_has_child (model, iter));
 459
 460   webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
 461       script);
 462
 463   g_free (str);
 464   g_free (script);
 465 }
 466
 467 static void
 468 store_events_rows_reordered (GtkTreeModel *model,
 469     GtkTreePath *path,
 470     GtkTreeIter *iter,
 471     int *new_order,
 472     EmpathyLogWindow *self)
 473 {
 474   char *str = gtk_tree_path_to_string (path);
 475   int i, children = gtk_tree_model_iter_n_children (model, iter);
 476   char **new_order_strv, *new_order_s;
 477   char *script;
 478
 479   new_order_strv = g_new0 (char *, children + 1);
 480
 481   for (i = 0; i < children; i++)
 482     new_order_strv[i] = g_strdup_printf ("%i", new_order[i]);
 483
 484   new_order_s = g_strjoinv (",", new_order_strv);
 485
 486   script = g_strdup_printf ("javascript:reorderRows([%s], [%s]);",
 487       str == NULL ? "" : g_strdelimit (str, ":", ','),
 488       new_order_s);
 489
 490   webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self->priv->webview),
 491       script);
 492
 493   g_free (str);
 494   g_free (script);
 495   g_free (new_order_s);
 496   g_strfreev (new_order_strv);
 497 }
 498
 499 static gboolean
 500 events_webview_handle_navigation (WebKitWebView *webview,
 501     WebKitWebFrame *frame,
 502     WebKitNetworkRequest *request,
 503     WebKitWebNavigationAction *navigation_action,
 504     WebKitWebPolicyDecision *policy_decision,
 505     EmpathyLogWindow *window)
 506 {
 507   empathy_url_show (GTK_WIDGET (webview),
 508       webkit_network_request_get_uri (request));
 509
 510   webkit_web_policy_decision_ignore (policy_decision);
 511   return TRUE;
 512 }
 513
 514 static GObject *
 515 empathy_log_window_constructor (GType type,
 516     guint n_props,
 517     GObjectConstructParam *props)
 518 {
 519   GObject *retval;
 520
 521   if (log_window != NULL)
 522     {
 523       retval = (GObject *) log_window;
 524     }
 525   else
 526     {
 527       retval = G_OBJECT_CLASS (empathy_log_window_parent_class)
 528           ->constructor (type, n_props, props);
 529
 530       log_window = EMPATHY_LOG_WINDOW (retval);
 531       g_object_add_weak_pointer (retval, (gpointer) &log_window);
 532     }
 533
 534   return retval;
 535 }
 536
 537 static void
 538 empathy_log_window_dispose (GObject *object)
 539 {
 540   EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (object);
 541
 542   if (self->priv->source != 0)
 543     {
 544       g_source_remove (self->priv->source);
 545       self->priv->source = 0;
 546     }
 547
 548   if (self->priv->current_dates != NULL)
 549     {
 550       g_list_free_full (self->priv->current_dates,
 551           (GDestroyNotify) g_date_free);
 552       self->priv->current_dates = NULL;
 553     }
 554
 555   tp_clear_pointer (&self->priv->chain, _tpl_action_chain_free);
 556   tp_clear_pointer (&self->priv->channels, g_hash_table_unref);
 557
 558   tp_clear_object (&self->priv->observer);
 559   tp_clear_object (&self->priv->log_manager);
 560   tp_clear_object (&self->priv->selected_account);
 561   tp_clear_object (&self->priv->selected_contact);
 562   tp_clear_object (&self->priv->events_contact);
 563   tp_clear_object (&self->priv->camera_monitor);
 564
 565   tp_clear_object (&self->priv->gsettings_chat);
 566   tp_clear_object (&self->priv->gsettings_desktop);
 567
 568   tp_clear_object (&self->priv->store_events);
 569
 570   G_OBJECT_CLASS (empathy_log_window_parent_class)->dispose (object);
 571 }
 572
 573 static void
 574 empathy_log_window_finalize (GObject *object)
 575 {
 576   EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (object);
 577
 578   g_free (self->priv->last_find);
 579   g_free (self->priv->selected_chat_id);
 580
 581   G_OBJECT_CLASS (empathy_log_window_parent_class)->finalize (object);
 582 }
 583
 584 static void
 585 empathy_log_window_class_init (
 586   EmpathyLogWindowClass *empathy_log_window_class)
 587 {
 588   GObjectClass *object_class = G_OBJECT_CLASS (empathy_log_window_class);
 589
 590   g_type_class_add_private (empathy_log_window_class,
 591       sizeof (EmpathyLogWindowPriv));
 592
 593   object_class->constructor = empathy_log_window_constructor;
 594   object_class->dispose = empathy_log_window_dispose;
 595   object_class->finalize = empathy_log_window_finalize;
 596 }
 597
 598 static void
 599 empathy_log_window_init (EmpathyLogWindow *self)
 600 {
 601   EmpathyAccountChooser *account_chooser;
 602   GtkBuilder *gui;
 603   gchar *filename;
 604   GFile *gfile;
 605   GtkWidget *vbox, *accounts, *search, *label, *closeitem;
 606   GtkWidget *scrolledwindow_events;
 607   gchar *uri;
 608
 609   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 610       EMPATHY_TYPE_LOG_WINDOW, EmpathyLogWindowPriv);
 611
 612   self->priv->chain = _tpl_action_chain_new_async (NULL, NULL, NULL);
 613
 614   self->priv->camera_monitor = empathy_camera_monitor_dup_singleton ();
 615
 616   self->priv->log_manager = tpl_log_manager_dup_singleton ();
 617
 618   self->priv->gsettings_chat = g_settings_new (EMPATHY_PREFS_CHAT_SCHEMA);
 619   self->priv->gsettings_desktop = g_settings_new (
 620       EMPATHY_PREFS_DESKTOP_INTERFACE_SCHEMA);
 621
 622   gtk_window_set_title (GTK_WINDOW (self), _("History"));
 623   gtk_widget_set_can_focus (GTK_WIDGET (self), FALSE);
 624   gtk_window_set_default_size (GTK_WINDOW (self), 800, 600);
 625
 626   filename = empathy_file_lookup ("empathy-log-window.ui", "libempathy-gtk");
 627   gui = empathy_builder_get_file (filename,
 628       "vbox1", &self->priv->vbox,
 629       "toolbutton_profile", &self->priv->button_profile,
 630       "toolbutton_chat", &self->priv->button_chat,
 631       "toolbutton_call", &self->priv->button_call,
 632       "toolbutton_video", &self->priv->button_video,
 633       "toolbutton_accounts", &accounts,
 634       "toolbutton_search", &search,
 635       "imagemenuitem_close", &closeitem,
 636       "treeview_who", &self->priv->treeview_who,
 637       "treeview_what", &self->priv->treeview_what,
 638       "treeview_when", &self->priv->treeview_when,
 639       "scrolledwindow_events", &scrolledwindow_events,
 640       "notebook", &self->priv->notebook,
 641       "spinner", &self->priv->spinner,
 642       NULL);
 643   g_free (filename);
 644
 645   empathy_builder_connect (gui, self,
 646       "toolbutton_profile", "clicked", toolbutton_profile_clicked,
 647       "toolbutton_chat", "clicked", toolbutton_chat_clicked,
 648       "toolbutton_call", "clicked", toolbutton_av_clicked,
 649       "toolbutton_video", "clicked", toolbutton_av_clicked,
 650       "imagemenuitem_delete", "activate", log_window_delete_menu_clicked_cb,
 651       NULL);
 652
 653   gtk_container_add (GTK_CONTAINER (self), self->priv->vbox);
 654
 655   g_object_unref (gui);
 656
 657   g_signal_connect_swapped (closeitem, "activate",
 658       G_CALLBACK (gtk_widget_destroy), self);
 659
 660   /* Account chooser for chats */
 661   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
 662
 663   self->priv->account_chooser = empathy_account_chooser_new ();
 664   account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
 665   empathy_account_chooser_set_has_all_option (account_chooser, TRUE);
 666   empathy_account_chooser_set_filter (account_chooser,
 667       empathy_account_chooser_filter_has_logs, NULL);
 668   empathy_account_chooser_set_all (account_chooser);
 669
 670   gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->account_chooser),
 671                                GTK_STYLE_CLASS_RAISED);
 672
 673   g_signal_connect (self->priv->account_chooser, "changed",
 674       G_CALLBACK (log_window_chats_accounts_changed_cb),
 675       self);
 676
 677   label = gtk_label_new (_("Show"));
 678
 679   gtk_box_pack_start (GTK_BOX (vbox),
 680       self->priv->account_chooser,
 681       FALSE, FALSE, 0);
 682
 683   gtk_box_pack_start (GTK_BOX (vbox),
 684       label,
 685       FALSE, FALSE, 0);
 686
 687   gtk_widget_show_all (vbox);
 688   gtk_container_add (GTK_CONTAINER (accounts), vbox);
 689
 690   /* Search entry */
 691   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
 692
 693   self->priv->search_entry = gtk_entry_new ();
 694   gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
 695       GTK_ENTRY_ICON_SECONDARY, "edit-find-symbolic");
 696   gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
 697                                 GTK_ENTRY_ICON_SECONDARY, FALSE);
 698
 699   label = gtk_label_new (_("Search"));
 700
 701   gtk_box_pack_start (GTK_BOX (vbox),
 702       self->priv->search_entry,
 703       FALSE, FALSE, 0);
 704
 705   gtk_box_pack_start (GTK_BOX (vbox),
 706       label,
 707       FALSE, FALSE, 0);
 708
 709   gtk_widget_show_all (vbox);
 710   gtk_container_add (GTK_CONTAINER (search), vbox);
 711
 712   g_signal_connect (self->priv->search_entry, "changed",
 713       G_CALLBACK (log_window_search_entry_changed_cb),
 714       self);
 715
 716   g_signal_connect (self->priv->search_entry, "activate",
 717       G_CALLBACK (log_window_search_entry_activate_cb),
 718       self);
 719
 720   g_signal_connect (self->priv->search_entry, "icon-press",
 721       G_CALLBACK (log_window_search_entry_icon_pressed_cb),
 722       self);
 723
 724   /* Contacts */
 725   log_window_events_setup (self);
 726   log_window_who_setup (self);
 727   log_window_what_setup (self);
 728   log_window_when_setup (self);
 729
 730   log_window_create_observer (self);
 731
 732   log_window_who_populate (self);
 733
 734   /* events */
 735   self->priv->webview = webkit_web_view_new ();
 736   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow_events),
 737       GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 738   gtk_container_add (GTK_CONTAINER (scrolledwindow_events),
 739       self->priv->webview);
 740   gtk_widget_show (self->priv->webview);
 741
 742   empathy_webkit_bind_font_setting (WEBKIT_WEB_VIEW (self->priv->webview),
 743       self->priv->gsettings_desktop,
 744       EMPATHY_PREFS_DESKTOP_INTERFACE_FONT_NAME);
 745
 746   filename = empathy_file_lookup ("empathy-log-window.html", "data");
 747   gfile = g_file_new_for_path (filename);
 748   g_free (filename);
 749
 750   uri = g_file_get_uri (gfile);
 751   webkit_web_view_load_uri (WEBKIT_WEB_VIEW (self->priv->webview), uri);
 752   g_object_unref (gfile);
 753   g_free (uri);
 754
 755   /* handle all navigation externally */
 756   g_signal_connect (self->priv->webview, "navigation-policy-decision-requested",
 757       G_CALLBACK (events_webview_handle_navigation), self);
 758
 759   /* listen to changes to the treemodel */
 760   g_signal_connect (self->priv->store_events, "row-inserted",
 761       G_CALLBACK (store_events_row_inserted), self);
 762   g_signal_connect (self->priv->store_events, "row-changed",
 763       G_CALLBACK (store_events_row_changed), self);
 764   g_signal_connect (self->priv->store_events, "row-deleted",
 765       G_CALLBACK (store_events_row_deleted), self);
 766   g_signal_connect (self->priv->store_events, "rows-reordered",
 767       G_CALLBACK (store_events_rows_reordered), self);
 768   g_signal_connect (self->priv->store_events, "row-has-child-toggled",
 769       G_CALLBACK (store_events_has_child_rows), self);
 770
 771   /* track clicked row */
 772   g_signal_connect (self->priv->webview, "button-press-event",
 773       G_CALLBACK (log_window_events_button_press_event), self);
 774
 775   log_window_update_buttons_sensitivity (self);
 776   gtk_widget_show (GTK_WIDGET (self));
 777
 778   empathy_geometry_bind (GTK_WINDOW (self), "log-window");
 779 }
 780
 781 GtkWidget *
 782 empathy_log_window_show (TpAccount *account,
 783      const gchar *chat_id,
 784      gboolean is_chatroom,
 785      GtkWindow *parent)
 786 {
 787   log_window = g_object_new (EMPATHY_TYPE_LOG_WINDOW, NULL);
 788
 789   gtk_window_present (GTK_WINDOW (log_window));
 790
 791   if (account != NULL && chat_id != NULL)
 792     select_account_once_ready (log_window, account, chat_id, is_chatroom);
 793
 794   if (parent != NULL)
 795     gtk_window_set_transient_for (GTK_WINDOW (log_window),
 796         GTK_WINDOW (parent));
 797
 798   return GTK_WIDGET (log_window);
 799 }
 800
 801 static gboolean
 802 account_equal (TpAccount *a,
 803     TpAccount *b)
 804 {
 805   return g_str_equal (tp_proxy_get_object_path (a),
 806       tp_proxy_get_object_path (b));
 807 }
 808
 809 static gboolean
 810 entity_equal (TplEntity *a,
 811     TplEntity *b)
 812 {
 813   return g_str_equal (tpl_entity_get_identifier (a),
 814       tpl_entity_get_identifier (b));
 815 }
 816
 817 static gboolean
 818 is_same_confroom (TplEvent *e1,
 819     TplEvent *e2)
 820 {
 821   TplEntity *sender1 = tpl_event_get_sender (e1);
 822   TplEntity *receiver1 = tpl_event_get_receiver (e1);
 823   TplEntity *sender2 = tpl_event_get_sender (e2);
 824   TplEntity *receiver2 = tpl_event_get_receiver (e2);
 825   TplEntity *room1, *room2;
 826
 827   if (receiver1 == NULL || receiver2 == NULL)
 828     return FALSE;
 829
 830   if (tpl_entity_get_entity_type (sender1) == TPL_ENTITY_ROOM)
 831     room1 = sender1;
 832   else if (tpl_entity_get_entity_type (receiver1) == TPL_ENTITY_ROOM)
 833     room1 = receiver1;
 834   else
 835     return FALSE;
 836
 837   if (tpl_entity_get_entity_type (sender2) == TPL_ENTITY_ROOM)
 838     room2 = sender2;
 839   else if (tpl_entity_get_entity_type (receiver2) == TPL_ENTITY_ROOM)
 840     room2 = receiver2;
 841   else
 842     return FALSE;
 843
 844   return g_str_equal (tpl_entity_get_identifier (room1),
 845       tpl_entity_get_identifier (room2));
 846 }
 847
 848 static void
 849 maybe_refresh_logs (TpChannel *channel,
 850     TpAccount *account)
 851 {
 852   GList *accounts = NULL, *entities = NULL, *dates = NULL;
 853   GList *acc, *ent;
 854   TplEventTypeMask event_mask;
 855   GDate *anytime = NULL, *today = NULL;
 856   GDateTime *now = NULL;
 857   gboolean refresh = FALSE;
 858   gboolean anyone;
 859   const gchar *type;
 860
 861   if (!log_window_get_selected (log_window,
 862       &accounts, &entities, &anyone, &dates, &event_mask, NULL))
 863     {
 864       DEBUG ("Could not get selected rows");
 865       return;
 866     }
 867
 868   type = tp_channel_get_channel_type (channel);
 869
 870   /* If the channel type is not in the What pane, whatever has happened
 871    * won't be displayed in the events pane. */
 872   if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_TEXT) &&
 873       !(event_mask & TPL_EVENT_MASK_TEXT))
 874     goto out;
 875   if ((!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA) ||
 876        !tp_strdiff (type, TPY_IFACE_CHANNEL_TYPE_CALL)) &&
 877       !(event_mask & TPL_EVENT_MASK_CALL))
 878     goto out;
 879
 880   anytime = g_date_new_dmy (2, 1, -1);
 881   now = g_date_time_new_now_local ();
 882   today = g_date_new_dmy (g_date_time_get_day_of_month (now),
 883       g_date_time_get_month (now),
 884       g_date_time_get_year (now));
 885
 886   /* If Today (or anytime) isn't selected, anything that has happened now
 887    * won't be displayed. */
 888   if (!g_list_find_custom (dates, anytime, (GCompareFunc) g_date_compare) &&
 889       !g_list_find_custom (dates, today, (GCompareFunc) g_date_compare))
 890     goto out;
 891
 892   if (anyone)
 893     {
 894       refresh = TRUE;
 895       goto out;
 896     }
 897
 898   for (acc = accounts, ent = entities;
 899        acc != NULL && ent != NULL;
 900        acc = g_list_next (acc), ent = g_list_next (ent))
 901     {
 902       if (!account_equal (account, acc->data))
 903         continue;
 904
 905       if (!tp_strdiff (tp_channel_get_identifier (channel),
 906                        tpl_entity_get_identifier (ent->data)))
 907         {
 908           refresh = TRUE;
 909           break;
 910         }
 911     }
 912
 913  out:
 914   tp_clear_pointer (&anytime, g_date_free);
 915   tp_clear_pointer (&today, g_date_free);
 916   tp_clear_pointer (&now, g_date_time_unref);
 917   g_list_free_full (accounts, g_object_unref);
 918   g_list_free_full (entities, g_object_unref);
 919   g_list_free_full (dates, (GFreeFunc) g_date_free);
 920
 921   if (refresh)
 922     {
 923       DEBUG ("Refreshing logs after received event");
 924
 925       /* FIXME:  We need to populate the entities in case we
 926        * didn't have any previous logs with this contact. */
 927       log_window_chats_get_messages (log_window, FALSE);
 928     }
 929 }
 930
 931 static void
 932 on_msg_sent (TpTextChannel *channel,
 933     TpSignalledMessage *message,
 934     guint flags,
 935     gchar *token,
 936     EmpathyLogWindow *self)
 937 {
 938   TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
 939
 940   maybe_refresh_logs (TP_CHANNEL (channel), account);
 941 }
 942
 943 static void
 944 on_msg_received (TpTextChannel *channel,
 945     TpSignalledMessage *message,
 946     EmpathyLogWindow *self)
 947 {
 948   TpMessage *msg = TP_MESSAGE (message);
 949   TpChannelTextMessageType type = tp_message_get_message_type (msg);
 950   TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
 951
 952   if (type != TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL &&
 953       type != TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION)
 954     return;
 955
 956   maybe_refresh_logs (TP_CHANNEL (channel), account);
 957 }
 958
 959 static void
 960 on_channel_ended (TpChannel *channel,
 961     guint domain,
 962     gint code,
 963     gchar *message,
 964     EmpathyLogWindow *self)
 965 {
 966   if (self->priv->channels != NULL)
 967     g_hash_table_remove (self->priv->channels, channel);
 968 }
 969
 970 static void
 971 on_call_ended (TpChannel *channel,
 972     guint domain,
 973     gint code,
 974     gchar *message,
 975     EmpathyLogWindow *self)
 976 {
 977   TpAccount *account = g_hash_table_lookup (self->priv->channels, channel);
 978
 979   maybe_refresh_logs (channel, account);
 980
 981   if (self->priv->channels != NULL)
 982     g_hash_table_remove (self->priv->channels, channel);
 983 }
 984
 985 static void
 986 observe_channels (TpSimpleObserver *observer,
 987     TpAccount *account,
 988     TpConnection *connection,
 989     GList *channels,
 990     TpChannelDispatchOperation *dispatch_operation,
 991     GList *requests,
 992     TpObserveChannelsContext *context,
 993     gpointer user_data)
 994 {
 995   EmpathyLogWindow *self = user_data;
 996
 997   GList *l;
 998
 999   for (l = channels; l != NULL; l = g_list_next (l))
1000     {
1001       TpChannel *channel = l->data;
1002       const gchar *type = tp_channel_get_channel_type (channel);
1003
1004       if (!tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_TEXT))
1005         {
1006           TpTextChannel *text_channel = TP_TEXT_CHANNEL (channel);
1007
1008           g_hash_table_insert (self->priv->channels,
1009               g_object_ref (channel), g_object_ref (account));
1010
1011           tp_g_signal_connect_object (text_channel, "message-sent",
1012               G_CALLBACK (on_msg_sent), self, 0);
1013           tp_g_signal_connect_object (text_channel, "message-received",
1014               G_CALLBACK (on_msg_received), self, 0);
1015           tp_g_signal_connect_object (channel, "invalidated",
1016               G_CALLBACK (on_channel_ended), self, 0);
1017         }
1018       else if (!tp_strdiff (type, TPY_IFACE_CHANNEL_TYPE_CALL) ||
1019           !tp_strdiff (type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA))
1020         {
1021           g_hash_table_insert (self->priv->channels,
1022               g_object_ref (channel), g_object_ref (account));
1023
1024           tp_g_signal_connect_object (channel, "invalidated",
1025               G_CALLBACK (on_call_ended), self, 0);
1026         }
1027       else
1028         {
1029           g_warning ("Unknown channel type: %s", type);
1030         }
1031     }
1032
1033   tp_observe_channels_context_accept (context);
1034 }
1035
1036 static void
1037 log_window_create_observer (EmpathyLogWindow *self)
1038 {
1039   TpAccountManager *am;
1040
1041   am = tp_account_manager_dup ();
1042
1043   self->priv->observer = tp_simple_observer_new_with_am (am, TRUE, "LogWindow",
1044       TRUE, observe_channels,
1045       g_object_ref (self), g_object_unref);
1046
1047   self->priv->channels = g_hash_table_new_full (g_direct_hash, g_direct_equal,
1048       g_object_unref, g_object_unref);
1049
1050   tp_base_client_take_observer_filter (self->priv->observer,
1051       tp_asv_new (
1052           TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1053             TP_IFACE_CHANNEL_TYPE_TEXT,
1054           NULL));
1055   tp_base_client_take_observer_filter (self->priv->observer,
1056       tp_asv_new (
1057           TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1058             TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA,
1059           NULL));
1060   tp_base_client_take_observer_filter (self->priv->observer,
1061       tp_asv_new (
1062           TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
1063             TPY_IFACE_CHANNEL_TYPE_CALL,
1064           NULL));
1065
1066   tp_base_client_register (self->priv->observer, NULL);
1067
1068   g_object_unref (am);
1069 }
1070
1071 static TplEntity *
1072 event_get_target (TplEvent *event)
1073 {
1074   TplEntity *sender = tpl_event_get_sender (event);
1075   TplEntity *receiver = tpl_event_get_receiver (event);
1076
1077   if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
1078     return receiver;
1079
1080   return sender;
1081 }
1082
1083 static gboolean
1084 model_is_parent (GtkTreeModel *model,
1085     GtkTreeIter *iter,
1086     TplEvent *event)
1087 {
1088   TplEvent *stored_event;
1089   TplEntity *target;
1090   TpAccount *account;
1091   gboolean found = FALSE;
1092   GtkTreeIter parent;
1093
1094   if (gtk_tree_model_iter_parent (model, &parent, iter))
1095     return FALSE;
1096
1097   gtk_tree_model_get (model, iter,
1098       COL_EVENTS_ACCOUNT, &account,
1099       COL_EVENTS_TARGET, &target,
1100       COL_EVENTS_EVENT, &stored_event,
1101       -1);
1102
1103   if (G_OBJECT_TYPE (event) == G_OBJECT_TYPE (stored_event) &&
1104       account_equal (account, tpl_event_get_account (event)) &&
1105       (entity_equal (target, event_get_target (event)) ||
1106       is_same_confroom (event, stored_event)))
1107     {
1108       GtkTreeIter child;
1109       gint64 timestamp;
1110
1111       gtk_tree_model_iter_nth_child (model, &child, iter,
1112           gtk_tree_model_iter_n_children (model, iter) - 1);
1113
1114       gtk_tree_model_get (model, &child,
1115           COL_EVENTS_TS, &timestamp,
1116           -1);
1117
1118       if (ABS (tpl_event_get_timestamp (event) - timestamp) < MAX_GAP)
1119         {
1120           /* The gap is smaller than 30 min */
1121           found = TRUE;
1122         }
1123     }
1124
1125   g_object_unref (stored_event);
1126   g_object_unref (account);
1127   g_object_unref (target);
1128
1129   return found;
1130 }
1131
1132 static gchar *
1133 get_display_string_for_chat_message (EmpathyMessage *message,
1134     TplEvent *event)
1135 {
1136   EmpathyContact *sender, *receiver, *target;
1137   TplEntity *ent_sender, *ent_receiver;
1138   const gchar *format;
1139
1140   sender = empathy_message_get_sender (message);
1141   receiver = empathy_message_get_receiver (message);
1142
1143   ent_sender = tpl_event_get_sender (event);
1144   ent_receiver = tpl_event_get_receiver (event);
1145
1146   /* If this is a MUC, we want to show "Chat in <room>". */
1147   if (tpl_entity_get_entity_type (ent_sender) == TPL_ENTITY_ROOM ||
1148       (ent_receiver != NULL &&
1149       tpl_entity_get_entity_type (ent_receiver) == TPL_ENTITY_ROOM))
1150     format = _("Chat in %s");
1151   else
1152     format = _("Chat with %s");
1153
1154   if (tpl_entity_get_entity_type (ent_sender) == TPL_ENTITY_ROOM)
1155     target = sender;
1156   else if (ent_receiver != NULL &&
1157       tpl_entity_get_entity_type (ent_receiver) == TPL_ENTITY_ROOM)
1158     target = receiver;
1159   else if (empathy_contact_is_user (sender))
1160     target = receiver;
1161   else
1162     target = sender;
1163
1164   return g_markup_printf_escaped (format, empathy_contact_get_alias (target));
1165 }
1166
1167 static void
1168 get_parent_iter_for_message (TplEvent *event,
1169     EmpathyMessage *message,
1170     GtkTreeIter *parent)
1171 {
1172   GtkTreeStore *store;
1173   GtkTreeModel *model;
1174   GtkTreeIter iter;
1175   gboolean parent_found = FALSE;
1176   gboolean next;
1177
1178   store = log_window->priv->store_events;
1179   model = GTK_TREE_MODEL (store);
1180
1181   for (next = gtk_tree_model_get_iter_first (model, &iter);
1182        next;
1183        next = gtk_tree_model_iter_next (model, &iter))
1184     {
1185       if ((parent_found = model_is_parent (model, &iter, event)))
1186         break;
1187     }
1188
1189   if (parent_found)
1190     {
1191       *parent = iter;
1192     }
1193   else
1194     {
1195       GDateTime *date;
1196       gchar *body, *pretty_date;
1197
1198       date = g_date_time_new_from_unix_local (
1199           tpl_event_get_timestamp (event));
1200
1201       pretty_date = g_date_time_format (date,
1202           C_("A date with the time", "%A, %e %B %Y %X"));
1203
1204       body = get_display_string_for_chat_message (message, event);
1205
1206       gtk_tree_store_append (store, &iter, NULL);
1207       gtk_tree_store_set (store, &iter,
1208           COL_EVENTS_TS, tpl_event_get_timestamp (event),
1209           COL_EVENTS_PRETTY_DATE, pretty_date,
1210           COL_EVENTS_TEXT, body,
1211           COL_EVENTS_ICON, "format-justify-fill",
1212           COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1213           COL_EVENTS_TARGET, event_get_target (event),
1214           COL_EVENTS_EVENT, event,
1215           -1);
1216
1217       *parent = iter;
1218
1219       g_free (body);
1220       g_free (pretty_date);
1221       g_date_time_unref (date);
1222     }
1223 }
1224
1225 static const gchar *
1226 get_icon_for_event (TplEvent *event)
1227 {
1228   const gchar *icon = NULL;
1229
1230   if (TPL_IS_TEXT_EVENT (event))
1231     {
1232       TplTextEvent *text = TPL_TEXT_EVENT (event);
1233
1234       if (!tp_str_empty (tpl_text_event_get_supersedes_token (text)))
1235         icon = EMPATHY_IMAGE_EDIT_MESSAGE;
1236     }
1237 #ifdef HAVE_CALL_LOGS
1238   else if (TPL_IS_CALL_EVENT (event))
1239     {
1240       TplCallEvent *call = TPL_CALL_EVENT (event);
1241       TplCallEndReason reason = tpl_call_event_get_end_reason (call);
1242       TplEntity *sender = tpl_event_get_sender (event);
1243       TplEntity *receiver = tpl_event_get_receiver (event);
1244
1245       if (reason == TPL_CALL_END_REASON_NO_ANSWER)
1246         icon = EMPATHY_IMAGE_CALL_MISSED;
1247       else if (tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
1248         icon = EMPATHY_IMAGE_CALL_OUTGOING;
1249       else if (tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF)
1250         icon = EMPATHY_IMAGE_CALL_INCOMING;
1251     }
1252 #endif
1253
1254   return icon;
1255 }
1256
1257 static void
1258 log_window_append_chat_message (TplEvent *event,
1259     EmpathyMessage *message)
1260 {
1261   GtkTreeStore *store = log_window->priv->store_events;
1262   GtkTreeIter iter, parent;
1263   gchar *pretty_date, *alias, *body;
1264   GDateTime *date;
1265   EmpathyStringParser *parsers;
1266   GString *msg;
1267
1268   date = g_date_time_new_from_unix_local (
1269       tpl_event_get_timestamp (event));
1270
1271   pretty_date = g_date_time_format (date, "%X");
1272
1273   get_parent_iter_for_message (event, message, &parent);
1274
1275   alias = g_markup_escape_text (
1276       tpl_entity_get_alias (tpl_event_get_sender (event)), -1);
1277
1278   /* escape the text */
1279   parsers = empathy_webkit_get_string_parser (
1280       g_settings_get_boolean (log_window->priv->gsettings_chat,
1281         EMPATHY_PREFS_CHAT_SHOW_SMILEYS));
1282   msg = g_string_new ("");
1283
1284   empathy_string_parser_substr (empathy_message_get_body (message), -1,
1285       parsers, msg);
1286
1287   if (tpl_text_event_get_message_type (TPL_TEXT_EVENT (event))
1288       == TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION)
1289     {
1290       /* Translators: this is an emote: '* Danielle waves' */
1291       body = g_strdup_printf (_("<i>* %s %s</i>"), alias, msg->str);
1292     }
1293   else
1294     {
1295       /* Translators: this is a message: 'Danielle: hello'
1296        * The string in bold is the sender's name */
1297       body = g_strdup_printf (_("<b>%s:</b> %s"), alias, msg->str);
1298     }
1299
1300   gtk_tree_store_append (store, &iter, &parent);
1301   gtk_tree_store_set (store, &iter,
1302       COL_EVENTS_TS, tpl_event_get_timestamp (event),
1303       COL_EVENTS_PRETTY_DATE, pretty_date,
1304       COL_EVENTS_TEXT, body,
1305       COL_EVENTS_ICON, get_icon_for_event (event),
1306       COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1307       COL_EVENTS_TARGET, event_get_target (event),
1308       COL_EVENTS_EVENT, event,
1309       -1);
1310
1311   g_string_free (msg, TRUE);
1312   g_free (body);
1313   g_free (alias);
1314   g_free (pretty_date);
1315   g_date_time_unref (date);
1316 }
1317
1318 #ifdef HAVE_CALL_LOGS
1319 static void
1320 log_window_append_call (TplEvent *event,
1321     EmpathyMessage *message)
1322 {
1323   TplCallEvent *call = TPL_CALL_EVENT (event);
1324   GtkTreeStore *store = log_window->priv->store_events;
1325   GtkTreeIter iter, child;
1326   gchar *pretty_date, *duration, *finished;
1327   GDateTime *started_date, *finished_date;
1328   GTimeSpan span;
1329
1330   /* If searching, only add the call if the search string appears anywhere */
1331   if (!EMP_STR_EMPTY (log_window->priv->last_find))
1332     {
1333       if (strstr (tpl_entity_get_identifier (tpl_event_get_sender (event)),
1334               log_window->priv->last_find) == NULL &&
1335           strstr (tpl_entity_get_identifier (tpl_event_get_receiver (event)),
1336               log_window->priv->last_find) == NULL &&
1337           strstr (tpl_call_event_get_detailed_end_reason (call),
1338               log_window->priv->last_find) == NULL)
1339         {
1340           DEBUG ("TplCallEvent doesn't match search string, ignoring");
1341           return;
1342         }
1343     }
1344
1345   started_date = g_date_time_new_from_unix_local (
1346       tpl_event_get_timestamp (event));
1347
1348   pretty_date = g_date_time_format (started_date,
1349       C_("A date with the time", "%A, %e %B %Y %X"));
1350
1351   gtk_tree_store_append (store, &iter, NULL);
1352   gtk_tree_store_set (store, &iter,
1353       COL_EVENTS_TS, tpl_event_get_timestamp (event),
1354       COL_EVENTS_PRETTY_DATE, pretty_date,
1355       COL_EVENTS_TEXT, empathy_message_get_body (message),
1356       COL_EVENTS_ICON, get_icon_for_event (event),
1357       COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1358       COL_EVENTS_TARGET, event_get_target (event),
1359       COL_EVENTS_EVENT, event,
1360       -1);
1361
1362   if (tpl_call_event_get_end_reason (call) != TPL_CALL_END_REASON_NO_ANSWER)
1363     {
1364       gchar *body;
1365       gchar *tmp;
1366
1367       span = tpl_call_event_get_duration (TPL_CALL_EVENT (event));
1368
1369       if (span < 60)
1370         {
1371           tmp = g_strdup_printf ("%" G_GINT64_FORMAT, span);
1372           duration = g_strdup_printf (
1373               ngettext ("%s second", "%s seconds", span), tmp);
1374           g_free (tmp);
1375         }
1376       else
1377         {
1378           tmp = g_strdup_printf ("%" G_GINT64_FORMAT, span / 60);
1379           duration = g_strdup_printf (
1380               ngettext ("%s minute", "%s minutes", span / 60), tmp);
1381           g_free (tmp);
1382         }
1383
1384       finished_date = g_date_time_add (started_date, -span);
1385       finished = g_date_time_format (finished_date, "%X");
1386       g_date_time_unref (finished_date);
1387
1388       body = g_strdup_printf (_("Call took %s, ended at %s"),
1389           duration, finished);
1390
1391       g_free (duration);
1392       g_free (finished);
1393
1394       gtk_tree_store_append (store, &child, &iter);
1395       gtk_tree_store_set (store, &child,
1396           COL_EVENTS_TS, tpl_event_get_timestamp (event),
1397           COL_EVENTS_TEXT, body,
1398           COL_EVENTS_ACCOUNT, tpl_event_get_account (event),
1399           COL_EVENTS_TARGET, event_get_target (event),
1400           COL_EVENTS_EVENT, event,
1401           -1);
1402
1403       g_free (body);
1404     }
1405
1406   g_free (pretty_date);
1407   g_date_time_unref (started_date);
1408 }
1409 #endif
1410
1411 static void
1412 log_window_append_message (TplEvent *event,
1413     EmpathyMessage *message)
1414 {
1415   if (TPL_IS_TEXT_EVENT (event))
1416     log_window_append_chat_message (event, message);
1417 #ifdef HAVE_CALL_LOGS
1418   else if (TPL_IS_CALL_EVENT (event))
1419     log_window_append_call (event, message);
1420 #endif
1421   else
1422     DEBUG ("Message type not handled");
1423 }
1424
1425 static void
1426 add_all_accounts_and_entities (GList **accounts,
1427     GList **entities)
1428 {
1429   GtkTreeView      *view;
1430   GtkTreeModel     *model;
1431   GtkTreeIter       iter;
1432
1433   view = GTK_TREE_VIEW (log_window->priv->treeview_who);
1434   model = gtk_tree_view_get_model (view);
1435
1436   if (!gtk_tree_model_get_iter_first (model, &iter))
1437     return;
1438
1439   do
1440     {
1441       TpAccount *account;
1442       TplEntity *entity;
1443       gint type;
1444
1445       gtk_tree_model_get (model, &iter,
1446           COL_WHO_ACCOUNT, &account,
1447           COL_WHO_TARGET, &entity,
1448           COL_WHO_TYPE, &type,
1449           -1);
1450
1451       if (type != COL_TYPE_NORMAL)
1452         continue;
1453
1454       if (accounts != NULL)
1455         *accounts = g_list_append (*accounts, account);
1456
1457       if (entities != NULL)
1458         *entities = g_list_append (*entities, entity);
1459     }
1460   while (gtk_tree_model_iter_next (model, &iter));
1461 }
1462
1463 static gboolean
1464 log_window_get_selected (EmpathyLogWindow *self,
1465     GList **accounts,
1466     GList **entities,
1467     gboolean *anyone,
1468     GList **dates,
1469     TplEventTypeMask *event_mask,
1470     EventSubtype *subtype)
1471 {
1472   GtkTreeView      *view;
1473   GtkTreeModel     *model;
1474   GtkTreeSelection *selection;
1475   GtkTreeIter       iter;
1476   TplEventTypeMask  ev = 0;
1477   EventSubtype      st = 0;
1478   GList            *paths, *l;
1479   gint              type;
1480
1481   view = GTK_TREE_VIEW (self->priv->treeview_who);
1482   model = gtk_tree_view_get_model (view);
1483   selection = gtk_tree_view_get_selection (view);
1484
1485   paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1486   if (paths == NULL)
1487     return FALSE;
1488
1489   if (accounts != NULL)
1490     *accounts = NULL;
1491   if (entities != NULL)
1492     *entities = NULL;
1493   if (anyone != NULL)
1494     *anyone = FALSE;
1495
1496   for (l = paths; l != NULL; l = l->next)
1497     {
1498       GtkTreePath *path = l->data;
1499       TpAccount *account;
1500       TplEntity *entity;
1501
1502       gtk_tree_model_get_iter (model, &iter, path);
1503       gtk_tree_model_get (model, &iter,
1504           COL_WHO_ACCOUNT, &account,
1505           COL_WHO_TARGET, &entity,
1506           COL_WHO_TYPE, &type,
1507           -1);
1508
1509       if (type == COL_TYPE_ANY)
1510         {
1511           if (accounts != NULL || entities != NULL)
1512             add_all_accounts_and_entities (accounts, entities);
1513           if (anyone != NULL)
1514             *anyone = TRUE;
1515           break;
1516         }
1517
1518       if (accounts != NULL)
1519         *accounts = g_list_append (*accounts, g_object_ref (account));
1520
1521       if (entities != NULL)
1522         *entities = g_list_append (*entities, g_object_ref (entity));
1523
1524       g_object_unref (account);
1525       g_object_unref (entity);
1526     }
1527   g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1528
1529   view = GTK_TREE_VIEW (self->priv->treeview_what);
1530   model = gtk_tree_view_get_model (view);
1531   selection = gtk_tree_view_get_selection (view);
1532
1533   paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1534   for (l = paths; l != NULL; l = l->next)
1535     {
1536       GtkTreePath *path = l->data;
1537       TplEventTypeMask mask;
1538       EventSubtype submask;
1539
1540       gtk_tree_model_get_iter (model, &iter, path);
1541       gtk_tree_model_get (model, &iter,
1542           COL_WHAT_TYPE, &mask,
1543           COL_WHAT_SUBTYPE, &submask,
1544           -1);
1545
1546       ev |= mask;
1547       st |= submask;
1548     }
1549   g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1550
1551   view = GTK_TREE_VIEW (self->priv->treeview_when);
1552   model = gtk_tree_view_get_model (view);
1553   selection = gtk_tree_view_get_selection (view);
1554
1555   if (dates != NULL)
1556     {
1557       *dates = NULL;
1558
1559       paths = gtk_tree_selection_get_selected_rows (selection, NULL);
1560       for (l = paths; l != NULL; l = l->next)
1561         {
1562           GtkTreePath *path = l->data;
1563           GDate *date;
1564
1565           gtk_tree_model_get_iter (model, &iter, path);
1566           gtk_tree_model_get (model, &iter,
1567               COL_WHEN_DATE, &date,
1568               -1);
1569
1570           *dates = g_list_append (*dates, date);
1571         }
1572       g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
1573     }
1574
1575   if (event_mask != NULL)
1576     *event_mask = ev;
1577
1578   if (subtype != NULL)
1579     *subtype = st;
1580
1581   return TRUE;
1582 }
1583
1584 static gboolean
1585 model_has_entity (GtkTreeModel *model,
1586     GtkTreePath *path,
1587     GtkTreeIter *iter,
1588     gpointer data)
1589 {
1590   TplLogSearchHit *hit = data;
1591   TplEntity *e;
1592   TpAccount *a;
1593   gboolean ret = FALSE;
1594
1595   gtk_tree_model_get (model, iter,
1596       COL_WHO_TARGET, &e,
1597       COL_WHO_ACCOUNT, &a,
1598       -1);
1599
1600   if (e != NULL && entity_equal (hit->target, e) &&
1601       a != NULL && account_equal (hit->account, a))
1602     {
1603       ret = has_element = TRUE;
1604     }
1605
1606   tp_clear_object (&e);
1607   tp_clear_object (&a);
1608
1609   return ret;
1610 }
1611
1612 static gboolean
1613 model_has_date (GtkTreeModel *model,
1614     GtkTreePath *path,
1615     GtkTreeIter *iter,
1616     gpointer data)
1617 {
1618   GDate *date = data;
1619   GDate *d;
1620
1621   gtk_tree_model_get (model, iter,
1622       COL_WHEN_DATE, &d,
1623       -1);
1624
1625   if (!g_date_compare (date, d))
1626     {
1627       has_element = TRUE;
1628       g_date_free (d);
1629       return TRUE;
1630     }
1631
1632   g_date_free (d);
1633   return FALSE;
1634 }
1635
1636 static void
1637 get_events_for_date (TplActionChain *chain, gpointer user_data);
1638
1639 static void
1640 populate_events_from_search_hits (GList *accounts,
1641     GList *targets,
1642     GList *dates)
1643 {
1644   TplEventTypeMask event_mask;
1645   EventSubtype subtype;
1646   GDate *anytime;
1647   GList *l;
1648   gboolean is_anytime = FALSE;
1649
1650   if (!log_window_get_selected (log_window,
1651       NULL, NULL, NULL, NULL, &event_mask, &subtype))
1652     return;
1653
1654   anytime = g_date_new_dmy (2, 1, -1);
1655   if (g_list_find_custom (dates, anytime, (GCompareFunc) g_date_compare))
1656     is_anytime = TRUE;
1657
1658   for (l = log_window->priv->hits; l != NULL; l = l->next)
1659     {
1660       TplLogSearchHit *hit = l->data;
1661       GList *acc, *targ;
1662       gboolean found = FALSE;
1663
1664       /* Protect against invalid data (corrupt or old log files). */
1665       if (hit->account == NULL || hit->target == NULL)
1666         continue;
1667
1668       for (acc = accounts, targ = targets;
1669            acc != NULL && targ != NULL && !found;
1670            acc = acc->next, targ = targ->next)
1671         {
1672           TpAccount *account = acc->data;
1673           TplEntity *target = targ->data;
1674
1675           if (account_equal (hit->account, account) &&
1676               entity_equal (hit->target, target))
1677             found = TRUE;
1678         }
1679
1680         if (!found)
1681           continue;
1682
1683       if (is_anytime ||
1684           g_list_find_custom (dates, hit->date, (GCompareFunc) g_date_compare)
1685               != NULL)
1686         {
1687           Ctx *ctx;
1688
1689           ctx = ctx_new (log_window, hit->account, hit->target, hit->date,
1690               event_mask, subtype, log_window->priv->count);
1691           _tpl_action_chain_append (log_window->priv->chain,
1692               get_events_for_date, ctx);
1693         }
1694     }
1695
1696   start_spinner ();
1697   _tpl_action_chain_start (log_window->priv->chain);
1698
1699   g_date_free (anytime);
1700 }
1701
1702 static gchar *
1703 format_date_for_display (GDate *date)
1704 {
1705   gchar *text;
1706   GDate *now = NULL;
1707   gint days_elapsed;
1708
1709   /* g_date_strftime sucks */
1710
1711   now = g_date_new ();
1712   g_date_set_time_t (now, time (NULL));
1713
1714   days_elapsed = g_date_days_between (date, now);
1715
1716   if (days_elapsed < 0)
1717     {
1718       text = NULL;
1719     }
1720   else if (days_elapsed == 0)
1721     {
1722       text = g_strdup (_("Today"));
1723     }
1724   else if (days_elapsed == 1)
1725     {
1726       text = g_strdup (_("Yesterday"));
1727     }
1728   else
1729     {
1730       GDateTime *dt;
1731
1732       dt = g_date_time_new_utc (g_date_get_year (date),
1733           g_date_get_month (date), g_date_get_day (date),
1734           0, 0, 0);
1735
1736       if (days_elapsed <= 7)
1737         text = g_date_time_format (dt, "%A");
1738       else
1739         text = g_date_time_format (dt,
1740             /* Translators: A date such as '23 May 2010' (strftime format) */
1741             _("%e %B %Y"));
1742
1743       g_date_time_unref (dt);
1744     }
1745
1746   g_date_free (now);
1747
1748   return text;
1749 }
1750
1751 static void
1752 populate_dates_from_search_hits (GList *accounts,
1753     GList *targets)
1754 {
1755   GList *l;
1756   GtkTreeView *view;
1757   GtkTreeModel *model;
1758   GtkListStore *store;
1759   GtkTreeSelection *selection;
1760   GtkTreeIter iter;
1761
1762   if (log_window == NULL)
1763     return;
1764
1765   view = GTK_TREE_VIEW (log_window->priv->treeview_when);
1766   model = gtk_tree_view_get_model (view);
1767   store = GTK_LIST_STORE (model);
1768   selection = gtk_tree_view_get_selection (view);
1769
1770   for (l = log_window->priv->hits; l != NULL; l = l->next)
1771     {
1772       TplLogSearchHit *hit = l->data;
1773       GList *acc, *targ;
1774       gboolean found = FALSE;
1775
1776       /* Protect against invalid data (corrupt or old log files). */
1777       if (hit->account == NULL || hit->target == NULL)
1778         continue;
1779
1780       for (acc = accounts, targ = targets;
1781            acc != NULL && targ != NULL && !found;
1782            acc = acc->next, targ = targ->next)
1783         {
1784           TpAccount *account = acc->data;
1785           TplEntity *target = targ->data;
1786
1787           if (account_equal (hit->account, account) &&
1788               entity_equal (hit->target, target))
1789             found = TRUE;
1790         }
1791
1792         if (!found)
1793           continue;
1794
1795       /* Add the date if it's not already there */
1796       has_element = FALSE;
1797       gtk_tree_model_foreach (model, model_has_date, hit->date);
1798       if (!has_element)
1799         {
1800           gchar *text = format_date_for_display (hit->date);
1801
1802           gtk_list_store_append (store, &iter);
1803           gtk_list_store_set (store, &iter,
1804               COL_WHEN_DATE, hit->date,
1805               COL_WHEN_TEXT, text,
1806               COL_WHEN_ICON, CALENDAR_ICON,
1807               -1);
1808         }
1809     }
1810
1811   if (gtk_tree_model_get_iter_first (model, &iter))
1812     {
1813       GDate *date;
1814
1815       date = g_date_new_dmy (1, 1, -1),
1816
1817       gtk_list_store_prepend (store, &iter);
1818       gtk_list_store_set (store, &iter,
1819           COL_WHEN_DATE, date,
1820           COL_WHEN_TEXT, "separator",
1821           -1);
1822
1823       g_date_free (date);
1824
1825       date = g_date_new_dmy (2, 1, -1),
1826       gtk_list_store_prepend (store, &iter);
1827       gtk_list_store_set (store, &iter,
1828           COL_WHEN_DATE, date,
1829           COL_WHEN_TEXT, _("Anytime"),
1830           -1);
1831
1832       g_date_free (date);
1833
1834       if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 2))
1835         gtk_tree_selection_select_iter (selection, &iter);
1836     }
1837 }
1838
1839 static void
1840 populate_entities_from_search_hits (void)
1841 {
1842   EmpathyAccountChooser *account_chooser;
1843   TpAccount *account;
1844   GtkTreeView *view;
1845   GtkTreeModel *model;
1846   GtkTreeSelection *selection;
1847   GtkTreeIter iter;
1848   GtkListStore *store;
1849   GList *l;
1850
1851   view = GTK_TREE_VIEW (log_window->priv->treeview_who);
1852   model = gtk_tree_view_get_model (view);
1853   store = GTK_LIST_STORE (model);
1854   selection = gtk_tree_view_get_selection (view);
1855
1856   gtk_list_store_clear (store);
1857
1858   account_chooser = EMPATHY_ACCOUNT_CHOOSER (log_window->priv->account_chooser);
1859   account = empathy_account_chooser_get_account (account_chooser);
1860
1861   for (l = log_window->priv->hits; l; l = l->next)
1862     {
1863       TplLogSearchHit *hit = l->data;
1864
1865       /* Protect against invalid data (corrupt or old log files). */
1866       if (hit->account == NULL || hit->target == NULL)
1867         continue;
1868
1869       /* Filter based on the selected account */
1870       if (account != NULL && !account_equal (account, hit->account))
1871         continue;
1872
1873       /* Add the entity if it's not already there */
1874       has_element = FALSE;
1875       gtk_tree_model_foreach (model, model_has_entity, hit);
1876       if (!has_element)
1877         {
1878           TplEntityType type = tpl_entity_get_entity_type (hit->target);
1879           EmpathyContact *contact;
1880           const gchar *name;
1881           gchar *sort_key;
1882           gboolean room = type == TPL_ENTITY_ROOM;
1883
1884           contact = empathy_contact_from_tpl_contact (hit->account,
1885               hit->target);
1886
1887           name = empathy_contact_get_alias (contact);
1888           sort_key = g_utf8_collate_key (name, -1);
1889
1890           gtk_list_store_append (store, &iter);
1891           gtk_list_store_set (store, &iter,
1892               COL_WHO_TYPE, COL_TYPE_NORMAL,
1893               COL_WHO_ICON, room ? EMPATHY_IMAGE_GROUP_MESSAGE
1894                                  : EMPATHY_IMAGE_AVATAR_DEFAULT,
1895               COL_WHO_NAME, name,
1896               COL_WHO_NAME_SORT_KEY, sort_key,
1897               COL_WHO_ID, tpl_entity_get_identifier (hit->target),
1898               COL_WHO_ACCOUNT, hit->account,
1899               COL_WHO_TARGET, hit->target,
1900               -1);
1901
1902           g_free (sort_key);
1903           g_object_unref (contact);
1904         }
1905     }
1906
1907   if (gtk_tree_model_get_iter_first (model, &iter))
1908     {
1909       gtk_list_store_prepend (store, &iter);
1910       gtk_list_store_set (store, &iter,
1911           COL_WHO_TYPE, COL_TYPE_SEPARATOR,
1912           COL_WHO_NAME, "separator",
1913           -1);
1914
1915       gtk_list_store_prepend (store, &iter);
1916       gtk_list_store_set (store, &iter,
1917           COL_WHO_TYPE, COL_TYPE_ANY,
1918           COL_WHO_NAME, _("Anyone"),
1919           -1);
1920     }
1921
1922   /* Select 'Anyone' */
1923   if (gtk_tree_model_get_iter_first (model, &iter))
1924     gtk_tree_selection_select_iter (selection, &iter);
1925 }
1926
1927 static void
1928 log_manager_searched_new_cb (GObject *manager,
1929     GAsyncResult *result,
1930     gpointer user_data)
1931 {
1932   GList *hits;
1933   GtkTreeView *view;
1934   GtkTreeSelection *selection;
1935   GError *error = NULL;
1936
1937   if (log_window == NULL)
1938     return;
1939
1940   if (!tpl_log_manager_search_finish (TPL_LOG_MANAGER (manager),
1941       result, &hits, &error))
1942     {
1943       DEBUG ("%s. Aborting", error->message);
1944       g_error_free (error);
1945       return;
1946     }
1947
1948   tp_clear_pointer (&log_window->priv->hits, tpl_log_manager_search_free);
1949   log_window->priv->hits = hits;
1950
1951   view = GTK_TREE_VIEW (log_window->priv->treeview_when);
1952   selection = gtk_tree_view_get_selection (view);
1953
1954   g_signal_handlers_unblock_by_func (selection,
1955       log_window_when_changed_cb,
1956       log_window);
1957
1958   populate_entities_from_search_hits ();
1959 }
1960
1961 static void
1962 log_window_find_populate (EmpathyLogWindow *self,
1963     const gchar *search_criteria)
1964 {
1965   GtkTreeView *view;
1966   GtkTreeModel *model;
1967   GtkTreeSelection *selection;
1968   GtkListStore *store;
1969
1970   gtk_tree_store_clear (self->priv->store_events);
1971
1972   view = GTK_TREE_VIEW (self->priv->treeview_who);
1973   model = gtk_tree_view_get_model (view);
1974   store = GTK_LIST_STORE (model);
1975
1976   gtk_list_store_clear (store);
1977
1978   view = GTK_TREE_VIEW (self->priv->treeview_when);
1979   model = gtk_tree_view_get_model (view);
1980   store = GTK_LIST_STORE (model);
1981   selection = gtk_tree_view_get_selection (view);
1982
1983   gtk_list_store_clear (store);
1984
1985   if (EMP_STR_EMPTY (search_criteria))
1986     {
1987       tp_clear_pointer (&self->priv->hits, tpl_log_manager_search_free);
1988       webkit_web_view_set_highlight_text_matches (
1989           WEBKIT_WEB_VIEW (self->priv->webview), FALSE);
1990       log_window_who_populate (self);
1991       return;
1992     }
1993
1994   g_signal_handlers_block_by_func (selection,
1995       log_window_when_changed_cb,
1996       self);
1997
1998   /* highlight the search text */
1999   webkit_web_view_mark_text_matches (WEBKIT_WEB_VIEW (self->priv->webview),
2000       search_criteria, FALSE, 0);
2001
2002   tpl_log_manager_search_async (self->priv->log_manager,
2003       search_criteria, TPL_EVENT_MASK_ANY,
2004       log_manager_searched_new_cb, NULL);
2005 }
2006
2007 static gboolean
2008 start_find_search (EmpathyLogWindow *self)
2009 {
2010   const gchar *str;
2011
2012   str = gtk_entry_get_text (GTK_ENTRY (self->priv->search_entry));
2013
2014   /* Don't find the same crap again */
2015   if (self->priv->last_find && !tp_strdiff (self->priv->last_find, str))
2016     return FALSE;
2017
2018   g_free (self->priv->last_find);
2019   self->priv->last_find = g_strdup (str);
2020
2021   log_window_find_populate (self, str);
2022
2023   return FALSE;
2024 }
2025
2026 static void
2027 log_window_search_entry_changed_cb (GtkWidget *entry,
2028     EmpathyLogWindow *self)
2029 {
2030   const gchar *str;
2031
2032   str = gtk_entry_get_text (GTK_ENTRY (self->priv->search_entry));
2033
2034   if (!tp_str_empty (str))
2035     {
2036       gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
2037           GTK_ENTRY_ICON_SECONDARY, "edit-clear-symbolic");
2038       gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
2039           GTK_ENTRY_ICON_SECONDARY, TRUE);
2040     }
2041   else
2042     {
2043       gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->search_entry),
2044           GTK_ENTRY_ICON_SECONDARY, "edit-find-symbolic");
2045       gtk_entry_set_icon_sensitive (GTK_ENTRY (self->priv->search_entry),
2046           GTK_ENTRY_ICON_SECONDARY, FALSE);
2047     }
2048
2049   if (self->priv->source != 0)
2050     g_source_remove (self->priv->source);
2051   self->priv->source = g_timeout_add (500, (GSourceFunc) start_find_search,
2052       self);
2053 }
2054
2055 static void
2056 log_window_search_entry_activate_cb (GtkWidget *entry,
2057     EmpathyLogWindow *self)
2058 {
2059   start_find_search (self);
2060 }
2061
2062 static void
2063 log_window_search_entry_icon_pressed_cb (GtkEntry *entry,
2064     GtkEntryIconPosition icon_pos,
2065     GdkEvent *event,
2066     gpointer user_data)
2067 {
2068   if (icon_pos != GTK_ENTRY_ICON_SECONDARY)
2069     return;
2070
2071   gtk_entry_buffer_set_text (gtk_entry_get_buffer (entry),
2072     "", -1);
2073 }
2074
2075 static void
2076 do_update_buttons_sensitivity (EmpathyLogWindow *self)
2077 {
2078   EmpathyCapabilities capabilities;
2079   gboolean profile, chat, call, video;
2080
2081   tp_clear_object (&self->priv->button_video_binding);
2082
2083   if (self->priv->selected_contact != NULL)
2084     {
2085       capabilities = empathy_contact_get_capabilities (
2086           self->priv->selected_contact);
2087
2088       profile = chat = TRUE;
2089       call = capabilities & EMPATHY_CAPABILITIES_AUDIO;
2090       video = capabilities & EMPATHY_CAPABILITIES_VIDEO;
2091     }
2092   else
2093     {
2094       profile = chat = call = video = FALSE;
2095     }
2096
2097   gtk_widget_set_sensitive (self->priv->button_profile, profile);
2098   gtk_widget_set_sensitive (self->priv->button_chat, chat);
2099   gtk_widget_set_sensitive (self->priv->button_call, call);
2100
2101   if (video)
2102     {
2103       self->priv->button_video_binding = g_object_bind_property (
2104           self->priv->camera_monitor, "available",
2105           self->priv->button_video, "sensitive",
2106           G_BINDING_SYNC_CREATE);
2107     }
2108   else
2109     {
2110       /* Don't override the binding */
2111       gtk_widget_set_sensitive (self->priv->button_video, video);
2112     }
2113 }
2114
2115 static void
2116 contact_capabilities_changed_cb (EmpathyContact *contact,
2117     GParamSpec *spec,
2118     EmpathyLogWindow *self)
2119 {
2120   do_update_buttons_sensitivity (self);
2121 }
2122
2123 static void
2124 log_window_update_buttons_sensitivity (EmpathyLogWindow *self)
2125 {
2126   GtkTreeView *view;
2127   GtkTreeModel *model;
2128   GtkTreeSelection *selection;
2129   TpAccount *account;
2130   TplEntity *target;
2131   GtkTreeIter iter;
2132   GList *paths;
2133   GtkTreePath *path;
2134
2135   if (self->priv->selected_contact != NULL)
2136     {
2137       g_signal_handlers_disconnect_by_func (self->priv->selected_contact,
2138           contact_capabilities_changed_cb, self);
2139
2140       tp_clear_object (&self->priv->selected_contact);
2141     }
2142
2143   view = GTK_TREE_VIEW (self->priv->treeview_who);
2144   model = gtk_tree_view_get_model (view);
2145   selection = gtk_tree_view_get_selection (view);
2146
2147   if (!gtk_tree_model_get_iter_first (model, &iter))
2148     goto events;
2149
2150   if (gtk_tree_selection_count_selected_rows (selection) != 1)
2151     goto events;
2152
2153   if (gtk_tree_selection_iter_is_selected (selection, &iter))
2154     goto events;
2155
2156   paths = gtk_tree_selection_get_selected_rows (selection, &model);
2157   g_return_if_fail (paths != NULL);
2158
2159   path = paths->data;
2160   gtk_tree_model_get_iter (model, &iter, path);
2161   gtk_tree_model_get (model, &iter,
2162       COL_WHO_ACCOUNT, &account,
2163       COL_WHO_TARGET, &target,
2164       -1);
2165
2166   g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
2167
2168   self->priv->selected_contact = empathy_contact_from_tpl_contact (account,
2169       target);
2170
2171   g_object_unref (account);
2172   g_object_unref (target);
2173
2174   goto out;
2175
2176  events:
2177   /* If the Who pane doesn't contain a contact (e.g. it has many
2178    * selected, or has 'Anyone', let's try to get the contact from
2179    * the selected event. */
2180
2181   if (self->priv->events_contact != NULL)
2182     self->priv->selected_contact = g_object_ref (self->priv->events_contact);
2183
2184  out:
2185   if (self->priv->selected_contact != NULL)
2186     {
2187       tp_g_signal_connect_object (self->priv->selected_contact,
2188           "notify::capabilities", G_CALLBACK (contact_capabilities_changed_cb),
2189           self, 0);
2190     }
2191
2192   do_update_buttons_sensitivity (self);
2193 }
2194
2195 static void
2196 log_window_update_what_iter_sensitivity (GtkTreeModel *model,
2197     GtkTreeIter *iter,
2198     gboolean sensitive)
2199 {
2200   GtkTreeStore *store = GTK_TREE_STORE (model);
2201   GtkTreeIter child;
2202   gboolean next;
2203
2204   gtk_tree_store_set (store, iter,
2205       COL_WHAT_SENSITIVE, sensitive,
2206       -1);
2207
2208   for (next = gtk_tree_model_iter_children (model, &child, iter);
2209        next;
2210        next = gtk_tree_model_iter_next (model, &child))
2211     {
2212       gtk_tree_store_set (store, &child,
2213           COL_WHAT_SENSITIVE, sensitive,
2214           -1);
2215     }
2216 }
2217
2218 static void
2219 log_window_update_what_sensitivity (EmpathyLogWindow *self)
2220 {
2221   GtkTreeView *view;
2222   GtkTreeModel *model;
2223   GtkTreeIter iter;
2224   GList *accounts, *targets, *acc, *targ;
2225   gboolean next;
2226
2227   if (!log_window_get_selected (self, &accounts, &targets, NULL, NULL,
2228       NULL, NULL))
2229     return;
2230
2231   view = GTK_TREE_VIEW (self->priv->treeview_what);
2232   model = gtk_tree_view_get_model (view);
2233
2234   /* For each event type... */
2235   for (next = gtk_tree_model_get_iter_first (model, &iter);
2236        next;
2237        next = gtk_tree_model_iter_next (model, &iter))
2238     {
2239       TplEventTypeMask type;
2240
2241       gtk_tree_model_get (model, &iter,
2242           COL_WHAT_TYPE, &type,
2243           -1);
2244
2245       /* ...we set the type and its subtypes (if any) unsensitive... */
2246       log_window_update_what_iter_sensitivity (model, &iter, FALSE);
2247
2248       for (acc = accounts, targ = targets;
2249            acc != NULL && targ != NULL;
2250            acc = acc->next, targ = targ->next)
2251         {
2252           TpAccount *account = acc->data;
2253           TplEntity *target = targ->data;
2254
2255           if (tpl_log_manager_exists (self->priv->log_manager,
2256                   account, target, type))
2257             {
2258               /* And then we set it (and its subtypes, again, if any)
2259                * as sensitive if there are logs of that type. */
2260               log_window_update_what_iter_sensitivity (model, &iter, TRUE);
2261               break;
2262             }
2263         }
2264     }
2265
2266   g_list_free_full (accounts, g_object_unref);
2267   g_list_free_full (targets, g_object_unref);
2268 }
2269
2270 static void
2271 log_window_who_changed_cb (GtkTreeSelection *selection,
2272     EmpathyLogWindow *self)
2273 {
2274   GtkTreeView *view;
2275   GtkTreeModel *model;
2276   GtkTreeIter iter;
2277
2278   DEBUG ("log_window_who_changed_cb");
2279
2280   view = gtk_tree_selection_get_tree_view (selection);
2281   model = gtk_tree_view_get_model (view);
2282
2283   if (gtk_tree_model_get_iter_first (model, &iter))
2284     {
2285       /* If 'Anyone' is selected, everything else should be deselected */
2286       if (gtk_tree_selection_iter_is_selected (selection, &iter))
2287         {
2288           g_signal_handlers_block_by_func (selection,
2289               log_window_who_changed_cb,
2290               self);
2291
2292           gtk_tree_selection_unselect_all (selection);
2293           gtk_tree_selection_select_iter (selection, &iter);
2294
2295           g_signal_handlers_unblock_by_func (selection,
2296               log_window_who_changed_cb,
2297               self);
2298         }
2299     }
2300
2301   log_window_update_what_sensitivity (self);
2302   log_window_update_buttons_sensitivity (self);
2303
2304   /* The contact changed, so the dates need to be updated */
2305   log_window_chats_get_messages (self, TRUE);
2306 }
2307
2308 static void
2309 log_manager_got_entities_cb (GObject *manager,
2310     GAsyncResult *result,
2311     gpointer user_data)
2312 {
2313   Ctx                   *ctx = user_data;
2314   GList                 *entities;
2315   GList                 *l;
2316   GtkTreeView           *view;
2317   GtkTreeModel          *model;
2318   GtkTreeSelection      *selection;
2319   GtkListStore          *store;
2320   GtkTreeIter            iter;
2321   GError                *error = NULL;
2322   gboolean               select_account = FALSE;
2323
2324   if (log_window == NULL)
2325     goto out;
2326
2327   if (log_window->priv->count != ctx->count)
2328     goto out;
2329
2330   if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager),
2331       result, &entities, &error))
2332     {
2333       DEBUG ("%s. Aborting", error->message);
2334       g_error_free (error);
2335       goto out;
2336     }
2337
2338   view = GTK_TREE_VIEW (ctx->self->priv->treeview_who);
2339   model = gtk_tree_view_get_model (view);
2340   selection = gtk_tree_view_get_selection (view);
2341   store = GTK_LIST_STORE (model);
2342
2343   /* Block signals to stop the logs being retrieved prematurely  */
2344   g_signal_handlers_block_by_func (selection,
2345       log_window_who_changed_cb, ctx->self);
2346
2347   for (l = entities; l; l = l->next)
2348     {
2349       TplEntity *entity = TPL_ENTITY (l->data);
2350       TplEntityType type = tpl_entity_get_entity_type (entity);
2351       EmpathyContact *contact;
2352       const gchar *name;
2353       gchar *sort_key;
2354       gboolean room = type == TPL_ENTITY_ROOM;
2355
2356       contact = empathy_contact_from_tpl_contact (ctx->account, entity);
2357
2358       name = empathy_contact_get_alias (contact);
2359       sort_key = g_utf8_collate_key (name, -1);
2360
2361       gtk_list_store_append (store, &iter);
2362       gtk_list_store_set (store, &iter,
2363           COL_WHO_TYPE, COL_TYPE_NORMAL,
2364           COL_WHO_ICON, room ? EMPATHY_IMAGE_GROUP_MESSAGE
2365                              : EMPATHY_IMAGE_AVATAR_DEFAULT,
2366           COL_WHO_NAME, name,
2367           COL_WHO_NAME_SORT_KEY, sort_key,
2368           COL_WHO_ID, tpl_entity_get_identifier (entity),
2369           COL_WHO_ACCOUNT, ctx->account,
2370           COL_WHO_TARGET, entity,
2371           -1);
2372
2373       g_free (sort_key);
2374       g_object_unref (contact);
2375
2376       if (ctx->self->priv->selected_account != NULL &&
2377           !tp_strdiff (tp_proxy_get_object_path (ctx->account),
2378           tp_proxy_get_object_path (ctx->self->priv->selected_account)))
2379         select_account = TRUE;
2380     }
2381   g_list_free_full (entities, g_object_unref);
2382
2383   if (gtk_tree_model_get_iter_first (model, &iter))
2384     {
2385       gint type;
2386
2387       gtk_tree_model_get (model, &iter,
2388           COL_WHO_TYPE, &type,
2389           -1);
2390
2391       if (type != COL_TYPE_ANY)
2392         {
2393           gtk_list_store_prepend (store, &iter);
2394           gtk_list_store_set (store, &iter,
2395               COL_WHO_TYPE, COL_TYPE_SEPARATOR,
2396               COL_WHO_NAME, "separator",
2397               -1);
2398
2399           gtk_list_store_prepend (store, &iter);
2400           gtk_list_store_set (store, &iter,
2401               COL_WHO_TYPE, COL_TYPE_ANY,
2402               COL_WHO_NAME, _("Anyone"),
2403               -1);
2404         }
2405     }
2406
2407   /* Unblock signals */
2408   g_signal_handlers_unblock_by_func (selection,
2409       log_window_who_changed_cb,
2410       ctx->self);
2411
2412   /* We display the selected account if we populate the model with chats from
2413    * this account. */
2414   if (select_account)
2415     log_window_chats_set_selected (ctx->self);
2416
2417 out:
2418   _tpl_action_chain_continue (log_window->priv->chain);
2419   ctx_free (ctx);
2420 }
2421
2422 static void
2423 get_entities_for_account (TplActionChain *chain, gpointer user_data)
2424 {
2425   Ctx *ctx = user_data;
2426
2427   tpl_log_manager_get_entities_async (ctx->self->priv->log_manager, ctx->account,
2428       log_manager_got_entities_cb, ctx);
2429 }
2430
2431 static void
2432 select_first_entity (TplActionChain *chain, gpointer user_data)
2433 {
2434   EmpathyLogWindow *self = user_data;
2435   GtkTreeView *view;
2436   GtkTreeModel *model;
2437   GtkTreeSelection *selection;
2438   GtkTreeIter iter;
2439
2440   view = GTK_TREE_VIEW (self->priv->treeview_who);
2441   model = gtk_tree_view_get_model (view);
2442   selection = gtk_tree_view_get_selection (view);
2443
2444   if (gtk_tree_model_get_iter_first (model, &iter))
2445     gtk_tree_selection_select_iter (selection, &iter);
2446
2447   _tpl_action_chain_continue (self->priv->chain);
2448 }
2449
2450 static void
2451 log_window_who_populate (EmpathyLogWindow *self)
2452 {
2453   EmpathyAccountChooser *account_chooser;
2454   TpAccount *account;
2455   gboolean all_accounts;
2456   GtkTreeView *view;
2457   GtkTreeModel *model;
2458   GtkTreeSelection *selection;
2459   GtkListStore *store;
2460   Ctx *ctx;
2461
2462   if (self->priv->hits != NULL)
2463     {
2464       populate_entities_from_search_hits ();
2465       return;
2466     }
2467
2468   account_chooser = EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser);
2469   account = empathy_account_chooser_dup_account (account_chooser);
2470   all_accounts = empathy_account_chooser_has_all_selected (account_chooser);
2471
2472   view = GTK_TREE_VIEW (self->priv->treeview_who);
2473   model = gtk_tree_view_get_model (view);
2474   selection = gtk_tree_view_get_selection (view);
2475   store = GTK_LIST_STORE (model);
2476
2477   /* Block signals to stop the logs being retrieved prematurely  */
2478   g_signal_handlers_block_by_func (selection,
2479       log_window_who_changed_cb,
2480       self);
2481
2482   gtk_list_store_clear (store);
2483
2484   /* Unblock signals */
2485   g_signal_handlers_unblock_by_func (selection,
2486       log_window_who_changed_cb,
2487       self);
2488
2489   _tpl_action_chain_clear (self->priv->chain);
2490   self->priv->count++;
2491
2492   if (!all_accounts && account == NULL)
2493     {
2494       return;
2495     }
2496   else if (!all_accounts)
2497     {
2498       ctx = ctx_new (self, account, NULL, NULL, 0, 0, self->priv->count);
2499       _tpl_action_chain_append (self->priv->chain, get_entities_for_account, ctx);
2500     }
2501   else
2502     {
2503       TpAccountManager *manager;
2504       GList *accounts, *l;
2505
2506       manager = empathy_account_chooser_get_account_manager (account_chooser);
2507       accounts = tp_account_manager_get_valid_accounts (manager);
2508
2509       for (l = accounts; l != NULL; l = l->next)
2510         {
2511           account = l->data;
2512
2513           ctx = ctx_new (self, account, NULL, NULL, 0, 0, self->priv->count);
2514           _tpl_action_chain_append (self->priv->chain,
2515               get_entities_for_account, ctx);
2516         }
2517
2518       g_list_free (accounts);
2519     }
2520   _tpl_action_chain_append (self->priv->chain, select_first_entity, self);
2521   _tpl_action_chain_start (self->priv->chain);
2522 }
2523
2524 static gint
2525 sort_by_name_key (GtkTreeModel *model,
2526     GtkTreeIter *a,
2527     GtkTreeIter *b,
2528     gpointer user_data)
2529 {
2530   gchar *key1, *key2;
2531   gint type1, type2;
2532   gint ret;
2533
2534   gtk_tree_model_get (model, a,
2535       COL_WHO_TYPE, &type1,
2536       COL_WHO_NAME_SORT_KEY, &key1,
2537       -1);
2538
2539   gtk_tree_model_get (model, b,
2540       COL_WHO_TYPE, &type2,
2541       COL_WHO_NAME_SORT_KEY, &key2,
2542       -1);
2543
2544   if (type1 == COL_TYPE_ANY)
2545     ret = -1;
2546   else if (type2 == COL_TYPE_ANY)
2547     ret = 1;
2548   else if (type1 == COL_TYPE_SEPARATOR)
2549     ret = -1;
2550   else if (type2 == COL_TYPE_SEPARATOR)
2551     ret = 1;
2552   else
2553     ret = g_strcmp0 (key1, key2);
2554
2555   g_free (key1);
2556   g_free (key2);
2557
2558   return ret;
2559 }
2560
2561 static gboolean
2562 who_row_is_separator (GtkTreeModel *model,
2563     GtkTreeIter *iter,
2564     gpointer data)
2565 {
2566   gint type;
2567
2568   gtk_tree_model_get (model, iter,
2569       COL_WHO_TYPE, &type,
2570       -1);
2571
2572   return (type == COL_TYPE_SEPARATOR);
2573 }
2574
2575 static void
2576 log_window_find_row (EmpathyLogWindow *self,
2577     GdkEventButton *event)
2578 {
2579   WebKitHitTestResult *hit = webkit_web_view_get_hit_test_result (
2580       WEBKIT_WEB_VIEW (self->priv->webview), event);
2581   WebKitDOMNode *inner_node;
2582
2583   tp_clear_object (&self->priv->events_contact);
2584
2585   g_object_get (hit,
2586       "inner-node", &inner_node,
2587       NULL);
2588
2589   if (inner_node != NULL)
2590     {
2591       GtkTreeModel *model = GTK_TREE_MODEL (self->priv->store_events);
2592       WebKitDOMNode *node;
2593       const char *path = NULL;
2594       GtkTreeIter iter;
2595
2596       /* walk back up the DOM tree looking for a node with empathy:path set */
2597       for (node = inner_node; node != NULL;
2598            node = webkit_dom_node_get_parent_node (node))
2599         {
2600           if (!WEBKIT_DOM_IS_ELEMENT (node))
2601             continue;
2602
2603           path = webkit_dom_element_get_attribute_ns (
2604               WEBKIT_DOM_ELEMENT (node), EMPATHY_NS, "path");
2605
2606           if (!tp_str_empty (path))
2607             break;
2608         }
2609
2610       /* look up the contact for this path */
2611       if (!tp_str_empty (path) &&
2612           gtk_tree_model_get_iter_from_string (model, &iter, path))
2613         {
2614           TpAccount *account;
2615           TplEntity *target;
2616
2617           gtk_tree_model_get (model, &iter,
2618               COL_EVENTS_ACCOUNT, &account,
2619               COL_EVENTS_TARGET, &target,
2620               -1);
2621
2622           self->priv->events_contact = empathy_contact_from_tpl_contact (
2623               account, target);
2624
2625           g_object_unref (account);
2626           g_object_unref (target);
2627         }
2628
2629       g_object_unref (inner_node);
2630     }
2631
2632   g_object_unref (hit);
2633
2634   log_window_update_buttons_sensitivity (self);
2635 }
2636
2637 static gboolean
2638 log_window_events_button_press_event (GtkWidget *webview,
2639     GdkEventButton *event,
2640     EmpathyLogWindow *self)
2641 {
2642   switch (event->button)
2643     {
2644       case 1:
2645         log_window_find_row (self, event);
2646         break;
2647
2648       case 3:
2649         empathy_webkit_context_menu_for_event (
2650             WEBKIT_WEB_VIEW (webview), event, 0);
2651         return TRUE;
2652
2653       default:
2654         break;
2655     }
2656
2657   return FALSE;
2658 }
2659
2660 static void
2661 log_window_events_setup (EmpathyLogWindow *self)
2662 {
2663   GtkTreeSortable   *sortable;
2664   GtkTreeStore      *store;
2665
2666   /* new store */
2667   self->priv->store_events = store = gtk_tree_store_new (COL_EVENTS_COUNT,
2668       G_TYPE_INT,           /* type */
2669       G_TYPE_INT64,         /* timestamp */
2670       G_TYPE_STRING,        /* stringified date */
2671       G_TYPE_STRING,        /* icon */
2672       G_TYPE_STRING,        /* name */
2673       TP_TYPE_ACCOUNT,      /* account */
2674       TPL_TYPE_ENTITY,      /* target */
2675       TPL_TYPE_EVENT);      /* event */
2676
2677   sortable = GTK_TREE_SORTABLE (store);
2678
2679   gtk_tree_sortable_set_sort_column_id (sortable,
2680       COL_EVENTS_TS,
2681       GTK_SORT_ASCENDING);
2682 }
2683
2684 static void
2685 log_window_who_setup (EmpathyLogWindow *self)
2686 {
2687   GtkTreeView       *view;
2688   GtkTreeModel      *model;
2689   GtkTreeSelection  *selection;
2690   GtkTreeSortable   *sortable;
2691   GtkTreeViewColumn *column;
2692   GtkListStore      *store;
2693   GtkCellRenderer   *cell;
2694
2695   view = GTK_TREE_VIEW (self->priv->treeview_who);
2696   selection = gtk_tree_view_get_selection (view);
2697
2698   /* new store */
2699   store = gtk_list_store_new (COL_WHO_COUNT,
2700       G_TYPE_INT,           /* type */
2701       G_TYPE_STRING,        /* icon */
2702       G_TYPE_STRING,        /* name */
2703       G_TYPE_STRING,        /* name sort key */
2704       G_TYPE_STRING,        /* id */
2705       TP_TYPE_ACCOUNT,      /* account */
2706       TPL_TYPE_ENTITY);     /* target */
2707
2708   model = GTK_TREE_MODEL (store);
2709   sortable = GTK_TREE_SORTABLE (store);
2710
2711   gtk_tree_view_set_model (view, model);
2712
2713   /* new column */
2714   column = gtk_tree_view_column_new ();
2715   gtk_tree_view_column_set_title (column, _("Who"));
2716
2717   cell = gtk_cell_renderer_pixbuf_new ();
2718   gtk_tree_view_column_pack_start (column, cell, FALSE);
2719   gtk_tree_view_column_add_attribute (column, cell,
2720       "icon-name",
2721       COL_WHO_ICON);
2722
2723   cell = gtk_cell_renderer_text_new ();
2724   g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2725   gtk_tree_view_column_pack_start (column, cell, TRUE);
2726   gtk_tree_view_column_add_attribute (column, cell,
2727       "text",
2728       COL_WHO_NAME);
2729
2730   gtk_tree_view_append_column (view, column);
2731
2732   /* set up treeview properties */
2733   gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
2734   gtk_tree_view_set_row_separator_func (view, who_row_is_separator,
2735       NULL, NULL);
2736
2737   gtk_tree_sortable_set_sort_column_id (sortable,
2738       COL_WHO_NAME_SORT_KEY,
2739       GTK_SORT_ASCENDING);
2740   gtk_tree_sortable_set_sort_func (sortable,
2741       COL_WHO_NAME_SORT_KEY, sort_by_name_key,
2742       NULL, NULL);
2743
2744   gtk_tree_view_set_search_column (view, COL_WHO_NAME);
2745   gtk_tree_view_set_tooltip_column (view, COL_WHO_ID);
2746
2747   /* set up signals */
2748   g_signal_connect (selection, "changed",
2749       G_CALLBACK (log_window_who_changed_cb), self);
2750
2751   g_object_unref (store);
2752 }
2753
2754 static void
2755 log_window_chats_accounts_changed_cb (GtkWidget *combobox,
2756     EmpathyLogWindow *self)
2757 {
2758   /* Clear all current messages shown in the textview */
2759   gtk_tree_store_clear (self->priv->store_events);
2760
2761   log_window_who_populate (self);
2762 }
2763
2764 static void
2765 log_window_chats_set_selected (EmpathyLogWindow *self)
2766 {
2767   GtkTreeView          *view;
2768   GtkTreeModel         *model;
2769   GtkTreeSelection     *selection;
2770   GtkTreeIter           iter;
2771   GtkTreePath          *path;
2772   gboolean              next;
2773
2774   view = GTK_TREE_VIEW (self->priv->treeview_who);
2775   model = gtk_tree_view_get_model (view);
2776   selection = gtk_tree_view_get_selection (view);
2777
2778   for (next = gtk_tree_model_get_iter_first (model, &iter);
2779        next;
2780        next = gtk_tree_model_iter_next (model, &iter))
2781     {
2782       TpAccount   *this_account;
2783       TplEntity   *this_target;
2784       const gchar *this_chat_id;
2785       gboolean     this_is_chatroom;
2786       gint         this_type;
2787
2788       gtk_tree_model_get (model, &iter,
2789           COL_WHO_TYPE, &this_type,
2790           COL_WHO_ACCOUNT, &this_account,
2791           COL_WHO_TARGET, &this_target,
2792           -1);
2793
2794       if (this_type != COL_TYPE_NORMAL)
2795         continue;
2796
2797       this_chat_id = tpl_entity_get_identifier (this_target);
2798       this_is_chatroom = tpl_entity_get_entity_type (this_target)
2799           == TPL_ENTITY_ROOM;
2800
2801       if (this_account == self->priv->selected_account &&
2802           !tp_strdiff (this_chat_id, self->priv->selected_chat_id) &&
2803           this_is_chatroom == self->priv->selected_is_chatroom)
2804         {
2805           gtk_tree_selection_select_iter (selection, &iter);
2806           path = gtk_tree_model_get_path (model, &iter);
2807           gtk_tree_view_scroll_to_cell (view, path, NULL, TRUE, 0.5, 0.0);
2808           gtk_tree_path_free (path);
2809           g_object_unref (this_account);
2810           g_object_unref (this_target);
2811           break;
2812         }
2813
2814       g_object_unref (this_account);
2815       g_object_unref (this_target);
2816     }
2817
2818   tp_clear_object (&self->priv->selected_account);
2819   tp_clear_pointer (&self->priv->selected_chat_id, g_free);
2820 }
2821
2822 static gint
2823 sort_by_date (GtkTreeModel *model,
2824     GtkTreeIter *a,
2825     GtkTreeIter *b,
2826     gpointer user_data)
2827 {
2828   GDate *date1, *date2;
2829   gint result;
2830
2831   gtk_tree_model_get (model, a,
2832       COL_WHEN_DATE, &date1,
2833       -1);
2834
2835   gtk_tree_model_get (model, b,
2836       COL_WHEN_DATE, &date2,
2837       -1);
2838
2839   result =  g_date_compare (date1, date2);
2840
2841   g_date_free (date1);
2842   g_date_free (date2);
2843   return result;
2844 }
2845
2846 static gboolean
2847 when_row_is_separator (GtkTreeModel *model,
2848     GtkTreeIter *iter,
2849     gpointer data)
2850 {
2851   gchar *when;
2852   gboolean ret;
2853
2854   gtk_tree_model_get (model, iter,
2855       COL_WHEN_TEXT, &when,
2856       -1);
2857
2858   ret = !tp_strdiff (when, "separator");
2859   g_free (when);
2860   return ret;
2861 }
2862
2863 static void
2864 log_window_when_changed_cb (GtkTreeSelection *selection,
2865     EmpathyLogWindow *self)
2866 {
2867   GtkTreeView *view;
2868   GtkTreeModel *model;
2869   GtkTreeIter iter;
2870
2871   DEBUG ("log_window_when_changed_cb");
2872
2873   view = gtk_tree_selection_get_tree_view (selection);
2874   model = gtk_tree_view_get_model (view);
2875
2876   /* If 'Anytime' is selected, everything else should be deselected */
2877   if (gtk_tree_model_get_iter_first (model, &iter))
2878     {
2879       if (gtk_tree_selection_iter_is_selected (selection, &iter))
2880         {
2881           g_signal_handlers_block_by_func (selection,
2882               log_window_when_changed_cb,
2883               self);
2884
2885           gtk_tree_selection_unselect_all (selection);
2886           gtk_tree_selection_select_iter (selection, &iter);
2887
2888           g_signal_handlers_unblock_by_func (selection,
2889               log_window_when_changed_cb,
2890               self);
2891         }
2892     }
2893
2894   log_window_chats_get_messages (self, FALSE);
2895 }
2896
2897 static void
2898 log_window_when_setup (EmpathyLogWindow *self)
2899 {
2900   GtkTreeView       *view;
2901   GtkTreeModel      *model;
2902   GtkTreeSelection  *selection;
2903   GtkTreeSortable   *sortable;
2904   GtkTreeViewColumn *column;
2905   GtkListStore      *store;
2906   GtkCellRenderer   *cell;
2907
2908   view = GTK_TREE_VIEW (self->priv->treeview_when);
2909   selection = gtk_tree_view_get_selection (view);
2910
2911   /* new store */
2912   store = gtk_list_store_new (COL_WHEN_COUNT,
2913       G_TYPE_DATE,        /* date */
2914       G_TYPE_STRING,      /* stringified date */
2915       G_TYPE_STRING);     /* icon */
2916
2917   model = GTK_TREE_MODEL (store);
2918   sortable = GTK_TREE_SORTABLE (store);
2919
2920   gtk_tree_view_set_model (view, model);
2921
2922   /* new column */
2923   column = gtk_tree_view_column_new ();
2924   gtk_tree_view_column_set_title (column, _("When"));
2925
2926   cell = gtk_cell_renderer_pixbuf_new ();
2927   gtk_tree_view_column_pack_start (column, cell, FALSE);
2928   gtk_tree_view_column_add_attribute (column, cell,
2929       "icon-name", COL_WHEN_ICON);
2930
2931   cell = gtk_cell_renderer_text_new ();
2932   g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2933   gtk_tree_view_column_pack_start (column, cell, TRUE);
2934   gtk_tree_view_column_add_attribute (column, cell,
2935       "text",
2936       COL_WHEN_TEXT);
2937
2938   gtk_tree_view_append_column (view, column);
2939
2940   /* set up treeview properties */
2941   gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
2942   gtk_tree_view_set_row_separator_func (view, when_row_is_separator,
2943       NULL, NULL);
2944   gtk_tree_sortable_set_sort_column_id (sortable,
2945       COL_WHEN_DATE,
2946       GTK_SORT_DESCENDING);
2947   gtk_tree_sortable_set_sort_func (sortable,
2948       COL_WHEN_DATE, sort_by_date,
2949       NULL, NULL);
2950
2951   gtk_tree_view_set_search_column (view, COL_WHEN_TEXT);
2952
2953   /* set up signals */
2954   g_signal_connect (selection, "changed",
2955       G_CALLBACK (log_window_when_changed_cb),
2956       self);
2957
2958   g_object_unref (store);
2959 }
2960
2961 static gboolean
2962 what_row_is_separator (GtkTreeModel *model,
2963     GtkTreeIter *iter,
2964     gpointer data)
2965 {
2966   gint type;
2967
2968   gtk_tree_model_get (model, iter,
2969       COL_WHAT_TYPE, &type,
2970       -1);
2971
2972   return (type == WHAT_TYPE_SEPARATOR);
2973 }
2974
2975 static void
2976 log_window_what_changed_cb (GtkTreeSelection *selection,
2977     EmpathyLogWindow *self)
2978 {
2979   GtkTreeView *view;
2980   GtkTreeModel *model;
2981   GtkTreeIter iter;
2982
2983   DEBUG ("log_window_what_changed_cb");
2984
2985   view = gtk_tree_selection_get_tree_view (selection);
2986   model = gtk_tree_view_get_model (view);
2987
2988   /* If 'Anything' is selected, everything else should be deselected */
2989   if (gtk_tree_model_get_iter_first (model, &iter))
2990     {
2991       if (gtk_tree_selection_iter_is_selected (selection, &iter))
2992         {
2993           g_signal_handlers_block_by_func (selection,
2994               log_window_what_changed_cb,
2995               self);
2996
2997           gtk_tree_selection_unselect_all (selection);
2998           gtk_tree_selection_select_iter (selection, &iter);
2999
3000           g_signal_handlers_unblock_by_func (selection,
3001               log_window_what_changed_cb,
3002               self);
3003         }
3004     }
3005
3006   /* The dates need to be updated if we're not searching */
3007   log_window_chats_get_messages (self, self->priv->hits == NULL);
3008 }
3009
3010 static gboolean
3011 log_window_what_collapse_row_cb (GtkTreeView *tree_view,
3012     GtkTreeIter *iter,
3013     GtkTreePath *path,
3014     gpointer user_data)
3015 {
3016   /* Reject collapsing */
3017   return TRUE;
3018 }
3019
3020 struct event
3021 {
3022   gint type;
3023   EventSubtype subtype;
3024   const gchar *icon;
3025   const gchar *text;
3026 };
3027
3028 static void
3029 log_window_what_setup (EmpathyLogWindow *self)
3030 {
3031   GtkTreeView       *view;
3032   GtkTreeModel      *model;
3033   GtkTreeSelection  *selection;
3034   GtkTreeViewColumn *column;
3035   GtkTreeIter        iter;
3036   GtkTreeStore      *store;
3037   GtkCellRenderer   *cell;
3038   guint i;
3039   struct event events [] = {
3040     { TPL_EVENT_MASK_ANY, 0, NULL, _("Anything") },
3041     { WHAT_TYPE_SEPARATOR, 0, NULL, "separator" },
3042     { TPL_EVENT_MASK_TEXT, 0, "format-justify-fill", _("Text chats") },
3043 #ifdef HAVE_CALL_LOGS
3044     { TPL_EVENT_MASK_CALL, EVENT_CALL_ALL, EMPATHY_IMAGE_CALL, _("Calls") },
3045 #endif
3046   };
3047 #ifdef HAVE_CALL_LOGS
3048   struct event call_events [] = {
3049     { TPL_EVENT_MASK_CALL, EVENT_CALL_INCOMING, EMPATHY_IMAGE_CALL_INCOMING, _("Incoming calls") },
3050     { TPL_EVENT_MASK_CALL, EVENT_CALL_OUTGOING, EMPATHY_IMAGE_CALL_OUTGOING, _("Outgoing calls") },
3051     { TPL_EVENT_MASK_CALL, EVENT_CALL_MISSED, EMPATHY_IMAGE_CALL_MISSED, _("Missed calls") }
3052   };
3053   GtkTreeIter parent;
3054 #endif
3055
3056   view = GTK_TREE_VIEW (self->priv->treeview_what);
3057   selection = gtk_tree_view_get_selection (view);
3058
3059   /* new store */
3060   store = gtk_tree_store_new (COL_WHAT_COUNT,
3061       G_TYPE_INT,         /* history type */
3062       G_TYPE_INT,         /* history subtype */
3063       G_TYPE_BOOLEAN,     /* sensitive */
3064       G_TYPE_STRING,      /* stringified history type */
3065       G_TYPE_STRING);     /* icon */
3066
3067   model = GTK_TREE_MODEL (store);
3068
3069   gtk_tree_view_set_model (view, model);
3070
3071   /* new column */
3072   column = gtk_tree_view_column_new ();
3073   gtk_tree_view_column_set_title (column, _("What"));
3074
3075   cell = gtk_cell_renderer_pixbuf_new ();
3076   gtk_tree_view_column_pack_start (column, cell, FALSE);
3077   gtk_tree_view_column_add_attribute (column, cell,
3078       "icon-name", COL_WHAT_ICON);
3079
3080   cell = gtk_cell_renderer_text_new ();
3081   g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
3082   gtk_tree_view_column_pack_start (column, cell, TRUE);
3083   gtk_tree_view_column_add_attribute (column, cell,
3084       "text", COL_WHAT_TEXT);
3085   gtk_tree_view_column_add_attribute (column, cell,
3086       "sensitive", COL_WHAT_SENSITIVE);
3087
3088   gtk_tree_view_append_column (view, column);
3089   gtk_tree_view_set_search_column (view, COL_WHAT_TEXT);
3090
3091   /* set up treeview properties */
3092   gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
3093   gtk_tree_view_set_show_expanders (view, FALSE);
3094   gtk_tree_view_set_level_indentation (view, 12);
3095   gtk_tree_view_expand_all (view);
3096   gtk_tree_view_set_row_separator_func (view, what_row_is_separator,
3097       NULL, NULL);
3098
3099   /* populate */
3100   for (i = 0; i < G_N_ELEMENTS (events); i++)
3101     {
3102       gtk_tree_store_append (store, &iter, NULL);
3103       gtk_tree_store_set (store, &iter,
3104           COL_WHAT_TYPE, events[i].type,
3105           COL_WHAT_SUBTYPE, events[i].subtype,
3106           COL_WHAT_SENSITIVE, TRUE,
3107           COL_WHAT_TEXT, events[i].text,
3108           COL_WHAT_ICON, events[i].icon,
3109           -1);
3110     }
3111
3112 #ifdef HAVE_CALL_LOGS
3113   gtk_tree_model_iter_nth_child (model, &parent, NULL, 3);
3114   for (i = 0; i < G_N_ELEMENTS (call_events); i++)
3115     {
3116       gtk_tree_store_append (store, &iter, &parent);
3117       gtk_tree_store_set (store, &iter,
3118           COL_WHAT_TYPE, call_events[i].type,
3119           COL_WHAT_SUBTYPE, call_events[i].subtype,
3120           COL_WHAT_SENSITIVE, TRUE,
3121           COL_WHAT_TEXT, call_events[i].text,
3122           COL_WHAT_ICON, call_events[i].icon,
3123           -1);
3124     }
3125 #endif
3126
3127   gtk_tree_view_expand_all (view);
3128
3129   /* select 'Anything' */
3130   if (gtk_tree_model_get_iter_first (model, &iter))
3131     gtk_tree_selection_select_iter (selection, &iter);
3132
3133   /* set up signals */
3134   g_signal_connect (view, "test-collapse-row",
3135       G_CALLBACK (log_window_what_collapse_row_cb),
3136       NULL);
3137   g_signal_connect (selection, "changed",
3138       G_CALLBACK (log_window_what_changed_cb),
3139       self);
3140
3141   g_object_unref (store);
3142 }
3143
3144 static void
3145 log_window_maybe_expand_events (void)
3146 {
3147   GtkTreeModel      *model = GTK_TREE_MODEL (log_window->priv->store_events);
3148
3149   /* If there's only one result, expand it */
3150   if (gtk_tree_model_iter_n_children (model, NULL) == 1)
3151     webkit_web_view_execute_script (
3152         WEBKIT_WEB_VIEW (log_window->priv->webview),
3153         "javascript:expandAll()");
3154 }
3155
3156 static gboolean
3157 show_spinner (gpointer data)
3158 {
3159   gboolean active;
3160
3161   if (log_window == NULL)
3162     return FALSE;
3163
3164   g_object_get (log_window->priv->spinner, "active", &active, NULL);
3165
3166   if (active)
3167     gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3168         PAGE_SPINNER);
3169
3170   return FALSE;
3171 }
3172
3173 static void
3174 show_events (TplActionChain *chain,
3175     gpointer user_data)
3176 {
3177   log_window_maybe_expand_events ();
3178   gtk_spinner_stop (GTK_SPINNER (log_window->priv->spinner));
3179   gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3180       PAGE_EVENTS);
3181
3182   _tpl_action_chain_continue (chain);
3183 }
3184
3185 static void
3186 start_spinner (void)
3187 {
3188   gtk_spinner_start (GTK_SPINNER (log_window->priv->spinner));
3189   gtk_notebook_set_current_page (GTK_NOTEBOOK (log_window->priv->notebook),
3190       PAGE_EMPTY);
3191
3192   g_timeout_add (1000, show_spinner, NULL);
3193   _tpl_action_chain_append (log_window->priv->chain, show_events, NULL);
3194 }
3195
3196 static void
3197 log_window_got_messages_for_date_cb (GObject *manager,
3198     GAsyncResult *result,
3199     gpointer user_data)
3200 {
3201   Ctx *ctx = user_data;
3202   GtkTreeModel *model;
3203   GtkTreeIter iter;
3204   GList *events;
3205   GList *l;
3206   GError *error = NULL;
3207   gint n;
3208
3209   if (log_window == NULL)
3210     {
3211       ctx_free (ctx);
3212       return;
3213     }
3214
3215   if (log_window->priv->count != ctx->count)
3216     goto out;
3217
3218   if (!tpl_log_manager_get_events_for_date_finish (TPL_LOG_MANAGER (manager),
3219       result, &events, &error))
3220     {
3221       DEBUG ("Unable to retrieve messages for the selected date: %s. Aborting",
3222           error->message);
3223       g_error_free (error);
3224       goto out;
3225     }
3226
3227   for (l = events; l; l = l->next)
3228     {
3229       TplEvent *event = l->data;
3230       gboolean append = TRUE;
3231
3232 #ifdef HAVE_CALL_LOGS
3233       if (TPL_IS_CALL_EVENT (l->data)
3234           && ctx->event_mask & TPL_EVENT_MASK_CALL
3235           && ctx->event_mask != TPL_EVENT_MASK_ANY)
3236         {
3237           TplCallEvent *call = l->data;
3238
3239           append = FALSE;
3240
3241           if (ctx->subtype & EVENT_CALL_ALL)
3242             {
3243               append = TRUE;
3244             }
3245           else
3246             {
3247               TplCallEndReason reason = tpl_call_event_get_end_reason (call);
3248               TplEntity *sender = tpl_event_get_sender (event);
3249               TplEntity *receiver = tpl_event_get_receiver (event);
3250
3251               if (reason == TPL_CALL_END_REASON_NO_ANSWER)
3252                 {
3253                   if (ctx->subtype & EVENT_CALL_MISSED)
3254                     append = TRUE;
3255                 }
3256               else if (ctx->subtype & EVENT_CALL_OUTGOING
3257                   && tpl_entity_get_entity_type (sender) == TPL_ENTITY_SELF)
3258                 {
3259                   append = TRUE;
3260                 }
3261               else if (ctx->subtype & EVENT_CALL_INCOMING
3262                   && tpl_entity_get_entity_type (receiver) == TPL_ENTITY_SELF)
3263                 {
3264                   append = TRUE;
3265                 }
3266             }
3267         }
3268 #endif
3269
3270       if (append)
3271         {
3272           EmpathyMessage *msg = empathy_message_from_tpl_log_event (event);
3273           log_window_append_message (event, msg);
3274           tp_clear_object (&msg);
3275         }
3276
3277       g_object_unref (event);
3278     }
3279   g_list_free (events);
3280
3281   model = GTK_TREE_MODEL (log_window->priv->store_events);
3282   n = gtk_tree_model_iter_n_children (model, NULL) - 1;
3283
3284   if (n >= 0 && gtk_tree_model_iter_nth_child (model, &iter, NULL, n))
3285     {
3286       GtkTreePath *path;
3287       char *str, *script;
3288
3289       path = gtk_tree_model_get_path (model, &iter);
3290       str = gtk_tree_path_to_string (path);
3291
3292       script = g_strdup_printf ("javascript:scrollToRow([%s]);",
3293           g_strdelimit (str, ":", ','));
3294
3295       webkit_web_view_execute_script (
3296           WEBKIT_WEB_VIEW (log_window->priv->webview),
3297           script);
3298
3299       gtk_tree_path_free (path);
3300       g_free (str);
3301       g_free (script);
3302     }
3303
3304  out:
3305   ctx_free (ctx);
3306
3307   _tpl_action_chain_continue (log_window->priv->chain);
3308 }
3309
3310 static void
3311 get_events_for_date (TplActionChain *chain, gpointer user_data)
3312 {
3313   Ctx *ctx = user_data;
3314
3315   tpl_log_manager_get_events_for_date_async (ctx->self->priv->log_manager,
3316       ctx->account, ctx->entity, ctx->event_mask,
3317       ctx->date,
3318       log_window_got_messages_for_date_cb,
3319       ctx);
3320 }
3321
3322 static void
3323 log_window_get_messages_for_dates (EmpathyLogWindow *self,
3324     GList *dates)
3325 {
3326   GList *accounts, *targets, *acc, *targ, *l;
3327   TplEventTypeMask event_mask;
3328   EventSubtype subtype;
3329   GDate *date, *anytime, *separator;
3330
3331   if (!log_window_get_selected (self,
3332       &accounts, &targets, NULL, NULL, &event_mask, &subtype))
3333     return;
3334
3335   anytime = g_date_new_dmy (2, 1, -1);
3336   separator = g_date_new_dmy (1, 1, -1);
3337
3338   _tpl_action_chain_clear (self->priv->chain);
3339   self->priv->count++;
3340
3341   for (acc = accounts, targ = targets;
3342        acc != NULL && targ != NULL;
3343        acc = acc->next, targ = targ->next)
3344     {
3345       TpAccount *account = acc->data;
3346       TplEntity *target = targ->data;
3347
3348       for (l = dates; l != NULL; l = l->next)
3349         {
3350           date = l->data;
3351
3352           /* Get events */
3353           if (g_date_compare (date, anytime) != 0)
3354             {
3355               Ctx *ctx;
3356
3357               ctx = ctx_new (self, account, target, date, event_mask, subtype,
3358                   self->priv->count);
3359               _tpl_action_chain_append (self->priv->chain, get_events_for_date, ctx);
3360             }
3361           else
3362             {
3363               GtkTreeView *view = GTK_TREE_VIEW (self->priv->treeview_when);
3364               GtkTreeModel *model = gtk_tree_view_get_model (view);
3365               GtkTreeIter iter;
3366               gboolean next;
3367               GDate *d;
3368
3369               for (next = gtk_tree_model_get_iter_first (model, &iter);
3370                    next;
3371                    next = gtk_tree_model_iter_next (model, &iter))
3372                 {
3373                   Ctx *ctx;
3374
3375                   gtk_tree_model_get (model, &iter,
3376                       COL_WHEN_DATE, &d,
3377                       -1);
3378
3379                   if (g_date_compare (d, anytime) != 0 &&
3380                       g_date_compare (d, separator) != 0)
3381                     {
3382                       ctx = ctx_new (self, account, target, d,
3383                           event_mask, subtype, self->priv->count);
3384                       _tpl_action_chain_append (self->priv->chain, get_events_for_date, ctx);
3385                     }
3386
3387                   g_date_free (d);
3388                 }
3389             }
3390         }
3391     }
3392
3393   start_spinner ();
3394   _tpl_action_chain_start (self->priv->chain);
3395
3396   g_list_free_full (accounts, g_object_unref);
3397   g_list_free_full (targets, g_object_unref);
3398   g_date_free (separator);
3399   g_date_free (anytime);
3400 }
3401
3402 static void
3403 log_manager_got_dates_cb (GObject *manager,
3404     GAsyncResult *result,
3405     gpointer user_data)
3406 {
3407   Ctx *ctx = user_data;
3408   GtkTreeView *view;
3409   GtkTreeModel *model;
3410   GtkListStore *store;
3411   GtkTreeIter iter;
3412   GList *dates;
3413   GList *l;
3414   GError *error = NULL;
3415
3416   if (log_window == NULL)
3417     {
3418       ctx_free (ctx);
3419       return;
3420     }
3421
3422   if (log_window->priv->count != ctx->count)
3423     goto out;
3424
3425   if (!tpl_log_manager_get_dates_finish (TPL_LOG_MANAGER (manager),
3426        result, &dates, &error))
3427     {
3428       DEBUG ("Unable to retrieve messages' dates: %s. Aborting",
3429           error->message);
3430       goto out;
3431     }
3432
3433   view = GTK_TREE_VIEW (log_window->priv->treeview_when);
3434   model = gtk_tree_view_get_model (view);
3435   store = GTK_LIST_STORE (model);
3436
3437   for (l = dates; l != NULL; l = l->next)
3438     {
3439       GDate *date = l->data;
3440
3441       /* Add the date if it's not already there */
3442       has_element = FALSE;
3443       gtk_tree_model_foreach (model, model_has_date, date);
3444       if (!has_element)
3445         {
3446           gchar *text = format_date_for_display (date);
3447
3448           gtk_list_store_append (store, &iter);
3449           gtk_list_store_set (store, &iter,
3450               COL_WHEN_DATE, date,
3451               COL_WHEN_TEXT, text,
3452               COL_WHEN_ICON, CALENDAR_ICON,
3453               -1);
3454
3455           g_free (text);
3456         }
3457     }
3458
3459   if (gtk_tree_model_get_iter_first (model, &iter))
3460     {
3461       gchar *separator = NULL;
3462
3463       if (gtk_tree_model_iter_next (model, &iter))
3464         {
3465           gtk_tree_model_get (model, &iter,
3466               COL_WHEN_TEXT, &separator,
3467               -1);
3468         }
3469
3470       if (g_strcmp0 (separator, "separator") != 0)
3471         {
3472           GDate *date;
3473
3474           date = g_date_new_dmy (1, 1, -1);
3475
3476           gtk_list_store_prepend (store, &iter);
3477           gtk_list_store_set (store, &iter,
3478               COL_WHEN_DATE, date,
3479               COL_WHEN_TEXT, "separator",
3480               -1);
3481
3482           g_date_free (date);
3483
3484           date = g_date_new_dmy (2, 1, -1);
3485
3486           gtk_list_store_prepend (store, &iter);
3487           gtk_list_store_set (store, &iter,
3488               COL_WHEN_DATE, date,
3489               COL_WHEN_TEXT, _("Anytime"),
3490               -1);
3491
3492           g_date_free (date);
3493         }
3494
3495       g_free (separator);
3496     }
3497
3498   g_list_free_full (dates, g_free);
3499  out:
3500   ctx_free (ctx);
3501   _tpl_action_chain_continue (log_window->priv->chain);
3502 }
3503
3504 static void
3505 select_date (TplActionChain *chain, gpointer user_data)
3506 {
3507   GtkTreeView *view;
3508   GtkTreeModel *model;
3509   GtkTreeSelection *selection;
3510   GtkTreeIter iter;
3511   gboolean next;
3512   gboolean selected = FALSE;
3513
3514   view = GTK_TREE_VIEW (log_window->priv->treeview_when);
3515   model = gtk_tree_view_get_model (view);
3516   selection = gtk_tree_view_get_selection (view);
3517
3518   if (log_window->priv->current_dates != NULL)
3519     {
3520       for (next = gtk_tree_model_get_iter_first (model, &iter);
3521            next;
3522            next = gtk_tree_model_iter_next (model, &iter))
3523         {
3524           GDate *date;
3525
3526           gtk_tree_model_get (model, &iter,
3527               COL_WHEN_DATE, &date,
3528               -1);
3529
3530           if (g_list_find_custom (log_window->priv->current_dates, date,
3531                   (GCompareFunc) g_date_compare) != NULL)
3532             {
3533               GtkTreePath *path;
3534
3535               gtk_tree_selection_select_iter (selection, &iter);
3536               path = gtk_tree_model_get_path (model, &iter);
3537               gtk_tree_view_scroll_to_cell (view, path, NULL, FALSE, 0, 0);
3538               selected = TRUE;
3539
3540               gtk_tree_path_free (path);
3541             }
3542
3543           g_date_free (date);
3544         }
3545     }
3546
3547   if (!selected)
3548     {
3549       /* Show messages of the most recent date */
3550       if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 2))
3551         gtk_tree_selection_select_iter (selection, &iter);
3552     }
3553
3554   _tpl_action_chain_continue (log_window->priv->chain);
3555 }
3556
3557 static void
3558 get_dates_for_entity (TplActionChain *chain, gpointer user_data)
3559 {
3560   Ctx *ctx = user_data;
3561
3562   tpl_log_manager_get_dates_async (ctx->self->priv->log_manager,
3563       ctx->account, ctx->entity, ctx->event_mask,
3564       log_manager_got_dates_cb, ctx);
3565 }
3566
3567 static void
3568 log_window_chats_get_messages (EmpathyLogWindow *self,
3569     gboolean force_get_dates)
3570 {
3571   GList *accounts, *targets, *dates;
3572   TplEventTypeMask event_mask;
3573   GtkTreeView *view;
3574   GtkTreeModel *model;
3575   GtkListStore *store;
3576   GtkTreeSelection *selection;
3577
3578   if (!log_window_get_selected (self, &accounts, &targets, NULL,
3579       &dates, &event_mask, NULL))
3580     return;
3581
3582   view = GTK_TREE_VIEW (self->priv->treeview_when);
3583   selection = gtk_tree_view_get_selection (view);
3584   model = gtk_tree_view_get_model (view);
3585   store = GTK_LIST_STORE (model);
3586
3587   /* Clear all current messages shown in the textview */
3588   gtk_tree_store_clear (self->priv->store_events);
3589
3590   _tpl_action_chain_clear (self->priv->chain);
3591   self->priv->count++;
3592
3593   /* If there's a search use the returned hits */
3594   if (self->priv->hits != NULL)
3595     {
3596       if (force_get_dates)
3597         {
3598           g_signal_handlers_block_by_func (selection,
3599               log_window_when_changed_cb,
3600               self);
3601
3602           gtk_list_store_clear (store);
3603
3604           g_signal_handlers_unblock_by_func (selection,
3605               log_window_when_changed_cb,
3606               self);
3607
3608           populate_dates_from_search_hits (accounts, targets);
3609         }
3610       else
3611         {
3612           populate_events_from_search_hits (accounts, targets, dates);
3613         }
3614     }
3615   /* Either use the supplied date or get the last */
3616   else if (force_get_dates || dates == NULL)
3617     {
3618       GList *acc, *targ;
3619
3620       if (self->priv->current_dates != NULL)
3621         {
3622           g_list_free_full (self->priv->current_dates,
3623               (GDestroyNotify) g_date_free);
3624           self->priv->current_dates = NULL;
3625         }
3626
3627       if (gtk_tree_selection_count_selected_rows (selection) > 0)
3628         {
3629           GList *paths, *l;
3630           GtkTreeIter iter;
3631
3632           paths = gtk_tree_selection_get_selected_rows (selection, NULL);
3633
3634           for (l = paths; l != NULL; l = l->next)
3635             {
3636               GtkTreePath *path = l->data;
3637               GDate *date;
3638
3639               gtk_tree_model_get_iter (model, &iter, path);
3640               gtk_tree_model_get (model, &iter,
3641                   COL_WHEN_DATE, &date,
3642                   -1);
3643
3644               /* The list takes ownership of the date. */
3645               self->priv->current_dates =
3646                   g_list_prepend (self->priv->current_dates, date);
3647             }
3648
3649           g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
3650         }
3651
3652       g_signal_handlers_block_by_func (selection,
3653           log_window_when_changed_cb,
3654           self);
3655
3656       gtk_list_store_clear (store);
3657
3658       g_signal_handlers_unblock_by_func (selection,
3659           log_window_when_changed_cb,
3660           self);
3661
3662       /* Get a list of dates and show them on the treeview */
3663       for (targ = targets, acc = accounts;
3664            targ != NULL && acc != NULL;
3665            targ = targ->next, acc = acc->next)
3666         {
3667           TpAccount *account = acc->data;
3668           TplEntity *target = targ->data;
3669           Ctx *ctx = ctx_new (self, account, target, NULL, event_mask, 0,
3670               self->priv->count);
3671
3672           _tpl_action_chain_append (self->priv->chain, get_dates_for_entity, ctx);
3673         }
3674       _tpl_action_chain_append (self->priv->chain, select_date, NULL);
3675       _tpl_action_chain_start (self->priv->chain);
3676     }
3677   else
3678     {
3679       /* Show messages of the selected date */
3680       log_window_get_messages_for_dates (self, dates);
3681     }
3682
3683   g_list_free_full (accounts, g_object_unref);
3684   g_list_free_full (targets, g_object_unref);
3685   g_list_free_full (dates, (GFreeFunc) g_date_free);
3686 }
3687
3688 typedef struct {
3689   EmpathyAccountChooserFilterResultCallback callback;
3690   gpointer user_data;
3691 } FilterCallbackData;
3692
3693 static void
3694 got_entities (GObject *manager,
3695     GAsyncResult *result,
3696     gpointer user_data)
3697 {
3698   FilterCallbackData *data = user_data;
3699   GList *entities;
3700   GError *error = NULL;
3701
3702   if (!tpl_log_manager_get_entities_finish (TPL_LOG_MANAGER (manager),
3703       result, &entities, &error))
3704     {
3705       DEBUG ("Could not get entities: %s", error->message);
3706       g_error_free (error);
3707       data->callback (FALSE, data->user_data);
3708     }
3709   else
3710     {
3711       data->callback (entities != NULL, data->user_data);
3712
3713       g_list_free_full (entities, g_object_unref);
3714     }
3715
3716   g_slice_free (FilterCallbackData, data);
3717 }
3718
3719 static void
3720 empathy_account_chooser_filter_has_logs (TpAccount *account,
3721     EmpathyAccountChooserFilterResultCallback callback,
3722     gpointer callback_data,
3723     gpointer user_data)
3724 {
3725   TplLogManager *manager = tpl_log_manager_dup_singleton ();
3726   FilterCallbackData *cb_data = g_slice_new0 (FilterCallbackData);
3727
3728   cb_data->callback = callback;
3729   cb_data->user_data = callback_data;
3730
3731   tpl_log_manager_get_entities_async (manager, account, got_entities, cb_data);
3732
3733   g_object_unref (manager);
3734 }
3735
3736 static void
3737 log_window_logger_clear_account_cb (TpProxy *proxy,
3738     const GError *error,
3739     gpointer user_data,
3740     GObject *weak_object)
3741 {
3742   EmpathyLogWindow *self = EMPATHY_LOG_WINDOW (user_data);
3743
3744   if (error != NULL)
3745     g_warning ("Error when clearing logs: %s", error->message);
3746
3747   /* Refresh the log viewer so the logs are cleared if the account
3748    * has been deleted */
3749   gtk_tree_store_clear (self->priv->store_events);
3750   log_window_who_populate (self);
3751
3752   /* Re-filter the account chooser so the accounts without logs get
3753    * greyed out */
3754   empathy_account_chooser_refilter (
3755       EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser));
3756 }
3757
3758 static void
3759 log_window_delete_menu_clicked_cb (GtkMenuItem *menuitem,
3760     EmpathyLogWindow *self)
3761 {
3762   GtkWidget *dialog, *content_area, *hbox, *label;
3763   EmpathyAccountChooser *account_chooser;
3764   gint response_id;
3765   TpDBusDaemon *bus;
3766   TpProxy *logger;
3767   GError *error = NULL;
3768
3769   account_chooser = (EmpathyAccountChooser *) empathy_account_chooser_new ();
3770   empathy_account_chooser_set_has_all_option (account_chooser, TRUE);
3771
3772   empathy_account_chooser_refilter (account_chooser);
3773
3774   /* Select the same account as in the history window */
3775   empathy_account_chooser_set_account (account_chooser,
3776       empathy_account_chooser_get_account (
3777         EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser)));
3778
3779   dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (self),
3780       GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING,
3781       GTK_BUTTONS_NONE,
3782       _("Are you sure you want to delete all logs of previous conversations?"));
3783
3784   gtk_dialog_add_buttons (GTK_DIALOG (dialog),
3785       GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
3786       _("Clear All"), GTK_RESPONSE_APPLY,
3787       NULL);
3788
3789   content_area = gtk_message_dialog_get_message_area (
3790       GTK_MESSAGE_DIALOG (dialog));
3791
3792   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
3793   label = gtk_label_new (_("Delete from:"));
3794   gtk_box_pack_start (GTK_BOX (hbox), label,
3795       FALSE, FALSE, 0);
3796   gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (account_chooser),
3797       FALSE, FALSE, 0);
3798   gtk_box_pack_start (GTK_BOX (content_area), hbox,
3799       FALSE, FALSE, 0);
3800
3801   gtk_widget_show_all (hbox);
3802
3803   response_id = gtk_dialog_run (GTK_DIALOG (dialog));
3804
3805   if (response_id != GTK_RESPONSE_APPLY)
3806     goto out;
3807
3808   bus = tp_dbus_daemon_dup (&error);
3809   if (error != NULL)
3810     {
3811       g_warning ("Could not delete logs: %s", error->message);
3812       g_error_free (error);
3813       goto out;
3814     }
3815
3816   logger = g_object_new (TP_TYPE_PROXY,
3817       "bus-name", "org.freedesktop.Telepathy.Logger",
3818       "object-path", "/org/freedesktop/Telepathy/Logger",
3819       "dbus-daemon", bus,
3820       NULL);
3821   g_object_unref (bus);
3822
3823   tp_proxy_add_interface_by_id (logger, EMP_IFACE_QUARK_LOGGER);
3824
3825   if (empathy_account_chooser_has_all_selected (account_chooser))
3826     {
3827       DEBUG ("Deleting logs for all the accounts");
3828
3829       emp_cli_logger_call_clear (logger, -1,
3830           log_window_logger_clear_account_cb,
3831           self, NULL, G_OBJECT (self));
3832     }
3833   else
3834     {
3835       TpAccount *account;
3836
3837       account = empathy_account_chooser_get_account (account_chooser);
3838
3839       DEBUG ("Deleting logs for %s", tp_proxy_get_object_path (account));
3840
3841       emp_cli_logger_call_clear_account (logger, -1,
3842           tp_proxy_get_object_path (account),
3843           log_window_logger_clear_account_cb,
3844           self, NULL, G_OBJECT (self));
3845     }
3846
3847   g_object_unref (logger);
3848  out:
3849   gtk_widget_destroy (dialog);
3850 }