libempathy-gtk/empathy-log-window.c

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