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