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