src/empathy-ft-manager.c

   1 /*
   2  * Copyright (C) 2003, 2004 Xan Lopez
   3  * Copyright (C) 2007 Marco Barisione <marco@barisione.org>
   4  * Copyright (C) 2008-2009 Collabora Ltd.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public
  17  * License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  19  * Boston, MA  02110-1301  USA
  20  *
  21  * Authors: Xan Lopez
  22  *          Marco Barisione <marco@barisione.org>
  23  *          Jonny Lamb <jonny.lamb@collabora.co.uk>
  24  *          Xavier Claessens <xclaesse@gmail.com>
  25  *          Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
  26  */
  27
  28 /* The original file transfer manager code was copied from Epiphany */
  29
  30 #include "config.h"
  31
  32 #include <string.h>
  33
  34 #include <glib/gi18n.h>
  35 #include <gtk/gtk.h>
  36 #include <gdk/gdkkeysyms.h>
  37
  38 #define DEBUG_FLAG EMPATHY_DEBUG_FT
  39 #include <libempathy/empathy-debug.h>
  40 #include <libempathy/empathy-utils.h>
  41
  42 #include <libempathy-gtk/empathy-ui-utils.h>
  43 #include <libempathy-gtk/empathy-geometry.h>
  44 #include <libempathy-gtk/empathy-images.h>
  45
  46 #include "empathy-ft-manager.h"
  47
  48 enum
  49 {
  50   COL_PERCENT,
  51   COL_ICON,
  52   COL_MESSAGE,
  53   COL_REMAINING,
  54   COL_FT_OBJECT
  55 };
  56
  57 typedef struct {
  58   GtkTreeModel *model;
  59   GHashTable *ft_handler_to_row_ref;
  60
  61   /* Widgets */
  62   GtkWidget *window;
  63   GtkWidget *treeview;
  64   GtkWidget *open_button;
  65   GtkWidget *abort_button;
  66   GtkWidget *clear_button;
  67 } EmpathyFTManagerPriv;
  68
  69 enum
  70 {
  71   RESPONSE_OPEN  = 1,
  72   RESPONSE_STOP  = 2,
  73   RESPONSE_CLEAR = 3,
  74   RESPONSE_CLOSE = 4
  75 };
  76
  77 G_DEFINE_TYPE (EmpathyFTManager, empathy_ft_manager, G_TYPE_OBJECT);
  78
  79 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyFTManager)
  80
  81 static EmpathyFTManager *manager_singleton = NULL;
  82
  83 static void ft_handler_hashing_started_cb (EmpathyFTHandler *handler,
  84     EmpathyFTManager *manager);
  85
  86 static gchar *
  87 ft_manager_format_interval (guint interval)
  88 {
  89   gint hours, mins, secs;
  90
  91   hours = interval / 3600;
  92   interval -= hours * 3600;
  93   mins = interval / 60;
  94   interval -= mins * 60;
  95   secs = interval;
  96
  97   if (hours > 0)
  98     /* Translators: time left, when it is more than one hour */
  99     return g_strdup_printf (_("%u:%02u.%02u"), hours, mins, secs);
 100   else
 101     /* Translators: time left, when is is less than one hour */
 102     return g_strdup_printf (_("%02u.%02u"), mins, secs);
 103 }
 104
 105 static void
 106 ft_manager_update_buttons (EmpathyFTManager *manager)
 107 {
 108   GtkTreeSelection *selection;
 109   GtkTreeModel *model;
 110   GtkTreeIter iter;
 111   EmpathyFTHandler *handler;
 112   gboolean open_enabled = FALSE;
 113   gboolean abort_enabled = FALSE;
 114   gboolean clear_enabled = FALSE;
 115   gboolean is_completed, is_cancelled;
 116   GHashTableIter hash_iter;
 117   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 118
 119   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
 120
 121   if (gtk_tree_selection_get_selected (selection, &model, &iter))
 122     {
 123       gtk_tree_model_get (model, &iter, COL_FT_OBJECT, &handler, -1);
 124
 125       is_completed = empathy_ft_handler_is_completed (handler);
 126       is_cancelled = empathy_ft_handler_is_cancelled (handler);
 127
 128       /* I can open the file if the transfer is completed and was incoming */
 129       open_enabled = (is_completed && empathy_ft_handler_is_incoming (handler));
 130
 131       /* I can abort if the transfer is not already finished */
 132       abort_enabled = (is_cancelled == FALSE && is_completed == FALSE);
 133
 134       g_object_unref (handler);
 135     }
 136
 137   g_hash_table_iter_init (&hash_iter, priv->ft_handler_to_row_ref);
 138
 139   while (g_hash_table_iter_next (&hash_iter, (gpointer *) &handler, NULL))
 140     {
 141       if (empathy_ft_handler_is_completed (handler) ||
 142           empathy_ft_handler_is_cancelled (handler))
 143           clear_enabled = TRUE;
 144
 145       if (clear_enabled)
 146         break;
 147     }
 148
 149   gtk_widget_set_sensitive (priv->open_button, open_enabled);
 150   gtk_widget_set_sensitive (priv->abort_button, abort_enabled);
 151
 152   if (clear_enabled)
 153     gtk_widget_set_sensitive (priv->clear_button, TRUE);
 154 }
 155
 156 static void
 157 ft_manager_selection_changed (GtkTreeSelection *selection,
 158                               EmpathyFTManager *manager)
 159 {
 160   ft_manager_update_buttons (manager);
 161 }
 162
 163 static void
 164 ft_manager_progress_cell_data_func (GtkTreeViewColumn *col,
 165                                     GtkCellRenderer *renderer,
 166                                     GtkTreeModel *model,
 167                                     GtkTreeIter *iter,
 168                                     gpointer user_data)
 169 {
 170   const gchar *text = NULL;
 171   gint percent;
 172
 173   gtk_tree_model_get (model, iter, COL_PERCENT, &percent, -1);
 174
 175   if (percent < 0)
 176     {
 177       percent = 0;
 178       text = C_("file transfer percent", "Unknown");
 179     }
 180
 181   g_object_set (renderer, "text", text, "value", percent, NULL);
 182 }
 183
 184 static GtkTreeRowReference *
 185 ft_manager_get_row_from_handler (EmpathyFTManager *manager,
 186                                  EmpathyFTHandler *handler)
 187 {
 188   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 189
 190   return g_hash_table_lookup (priv->ft_handler_to_row_ref, handler);
 191 }
 192
 193 static void
 194 ft_manager_remove_file_from_model (EmpathyFTManager *manager,
 195                                    EmpathyFTHandler *handler)
 196 {
 197   GtkTreeRowReference *row_ref;
 198   GtkTreeSelection *selection;
 199   GtkTreePath *path = NULL;
 200   GtkTreeIter iter;
 201   gboolean update_selection;
 202   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 203
 204   row_ref = ft_manager_get_row_from_handler (manager, handler);
 205   g_return_if_fail (row_ref);
 206
 207   DEBUG ("Removing file transfer from window: contact=%s, filename=%s",
 208       empathy_contact_get_alias (empathy_ft_handler_get_contact (handler)),
 209       empathy_ft_handler_get_filename (handler));
 210
 211   /* Get the iter from the row_ref */
 212   path = gtk_tree_row_reference_get_path (row_ref);
 213   gtk_tree_model_get_iter (priv->model, &iter, path);
 214   gtk_tree_path_free (path);
 215
 216   /* We have to update the selection only if we are removing the selected row */
 217   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
 218   update_selection = gtk_tree_selection_iter_is_selected (selection, &iter);
 219
 220   /* Remove tp_file's row. After that iter points to the next row */
 221   if (!gtk_list_store_remove (GTK_LIST_STORE (priv->model), &iter))
 222     {
 223       gint n_row;
 224
 225       /* There is no next row, set iter to the last row */
 226       n_row = gtk_tree_model_iter_n_children (priv->model, NULL);
 227       if (n_row > 0)
 228         gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, n_row - 1);
 229       else
 230         update_selection = FALSE;
 231     }
 232
 233   if (update_selection)
 234     gtk_tree_selection_select_iter (selection, &iter);
 235 }
 236
 237 static gboolean
 238 remove_finished_transfer_foreach (gpointer key,
 239                                   gpointer value,
 240                                   gpointer user_data)
 241 {
 242   EmpathyFTHandler *handler = key;
 243   EmpathyFTManager *manager = user_data;
 244
 245   if (empathy_ft_handler_is_completed (handler) ||
 246       empathy_ft_handler_is_cancelled (handler))
 247     {
 248       ft_manager_remove_file_from_model (manager, handler);
 249       return TRUE;
 250     }
 251
 252   return FALSE;
 253 }
 254
 255 static gchar *
 256 ft_manager_format_progress_bytes_and_percentage (guint64 current,
 257                                                  guint64 total,
 258                                                  gdouble speed,
 259                                                  int *percentage)
 260 {
 261   char *total_str, *current_str, *retval;
 262   char *speed_str = NULL;
 263
 264   total_str = g_format_size (total);
 265   current_str = g_format_size (current);
 266
 267   if (speed > 0)
 268     speed_str = g_format_size ((goffset) speed);
 269
 270   /* translators: first %s is the currently processed size, second %s is
 271    * the total file size */
 272   retval = speed_str ?
 273     g_strdup_printf (_("%s of %s at %s/s"), current_str, total_str, speed_str) :
 274     g_strdup_printf (_("%s of %s"), current_str, total_str);
 275
 276   g_free (total_str);
 277   g_free (current_str);
 278   g_free (speed_str);
 279
 280   if (percentage != NULL)
 281     {
 282       if (total != 0)
 283         *percentage = current * 100 / total;
 284       else
 285         *percentage = -1;
 286     }
 287
 288   return retval;
 289 }
 290
 291 static gchar *
 292 ft_manager_format_contact_info (EmpathyFTHandler *handler)
 293 {
 294   gboolean incoming;
 295   const char *filename, *contact_name, *first_line_format;
 296   char *retval;
 297
 298   incoming = empathy_ft_handler_is_incoming (handler);
 299   contact_name = empathy_contact_get_alias
 300     (empathy_ft_handler_get_contact (handler));
 301   filename = empathy_ft_handler_get_filename (handler);
 302
 303   if (incoming)
 304     /* translators: first %s is filename, second %s is the contact name */
 305     first_line_format = _("Receiving \"%s\" from %s");
 306   else
 307     /* translators: first %s is filename, second %s is the contact name */
 308     first_line_format = _("Sending \"%s\" to %s");
 309
 310   retval = g_strdup_printf (first_line_format, filename, contact_name);
 311
 312   return retval;
 313 }
 314
 315 static gchar *
 316 ft_manager_format_error_message (EmpathyFTHandler *handler,
 317                                  const GError *error)
 318 {
 319   const char *contact_name, *filename;
 320   EmpathyContact *contact;
 321   char *first_line, *message;
 322   gboolean incoming;
 323
 324   contact_name = NULL;
 325   incoming = empathy_ft_handler_is_incoming (handler);
 326
 327   contact = empathy_ft_handler_get_contact (handler);
 328   if (contact)
 329     contact_name = empathy_contact_get_alias (contact);
 330
 331   filename = empathy_ft_handler_get_filename (handler);
 332
 333   if (incoming)
 334     /* filename/contact_name here are either both NULL or both valid */
 335     if (filename && contact_name)
 336       /* translators: first %s is filename, second %s
 337        * is the contact name */
 338       first_line = g_strdup_printf (_("Error receiving \"%s\" from %s"), filename,
 339           contact_name);
 340     else
 341       first_line = g_strdup (_("Error receiving a file"));
 342   else
 343     /* translators: first %s is filename, second %s
 344      * is the contact name */
 345     if (filename && contact_name)
 346       first_line = g_strdup_printf (_("Error sending \"%s\" to %s"), filename,
 347           contact_name);
 348     else
 349       first_line = g_strdup (_("Error sending a file"));
 350
 351   message = g_strdup_printf ("%s\n%s", first_line, error->message);
 352
 353   g_free (first_line);
 354
 355   return message;
 356 }
 357
 358 static void
 359 ft_manager_update_handler_message (EmpathyFTManager *manager,
 360                                    GtkTreeRowReference *row_ref,
 361                                    const char *message)
 362 {
 363   GtkTreePath *path;
 364   GtkTreeIter iter;
 365   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 366
 367   /* Set new value in the store */
 368   path = gtk_tree_row_reference_get_path (row_ref);
 369   gtk_tree_model_get_iter (priv->model, &iter, path);
 370   gtk_list_store_set (GTK_LIST_STORE (priv->model),
 371       &iter,
 372       COL_MESSAGE, message ? message : "",
 373       -1);
 374
 375   gtk_tree_path_free (path);
 376 }
 377
 378 static void
 379 ft_manager_update_handler_progress (EmpathyFTManager *manager,
 380                                     GtkTreeRowReference *row_ref,
 381                                     int percentage)
 382 {
 383   GtkTreePath *path;
 384   GtkTreeIter iter;
 385   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 386
 387   /* Set new value in the store */
 388   path = gtk_tree_row_reference_get_path (row_ref);
 389   gtk_tree_model_get_iter (priv->model, &iter, path);
 390   gtk_list_store_set (GTK_LIST_STORE (priv->model),
 391       &iter,
 392       COL_PERCENT, percentage,
 393       -1);
 394
 395   gtk_tree_path_free (path);
 396
 397 }
 398
 399 static void
 400 ft_manager_update_handler_time (EmpathyFTManager *manager,
 401                                 GtkTreeRowReference *row_ref,
 402                                 guint remaining_time)
 403 {
 404   GtkTreePath *path;
 405   GtkTreeIter iter;
 406   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 407   char *remaining_str;
 408
 409   remaining_str = ft_manager_format_interval (remaining_time);
 410
 411   /* Set new value in the store */
 412   path = gtk_tree_row_reference_get_path (row_ref);
 413   gtk_tree_model_get_iter (priv->model, &iter, path);
 414   gtk_list_store_set (GTK_LIST_STORE (priv->model),
 415       &iter,
 416       COL_REMAINING, remaining_str,
 417       -1);
 418
 419   gtk_tree_path_free (path);
 420   g_free (remaining_str);
 421 }
 422
 423 static void
 424 ft_manager_clear_handler_time (EmpathyFTManager *manager,
 425                                GtkTreeRowReference *row_ref)
 426 {
 427   GtkTreePath *path;
 428   GtkTreeIter iter;
 429   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 430
 431   /* Set new value in the store */
 432   path = gtk_tree_row_reference_get_path (row_ref);
 433   gtk_tree_model_get_iter (priv->model, &iter, path);
 434   gtk_list_store_set (GTK_LIST_STORE (priv->model),
 435       &iter,
 436       COL_REMAINING, NULL,
 437       -1);
 438
 439   gtk_tree_path_free (path);
 440 }
 441
 442 static void
 443 ft_handler_transfer_error_cb (EmpathyFTHandler *handler,
 444                               GError *error,
 445                               EmpathyFTManager *manager)
 446 {
 447   char *message;
 448   GtkTreeRowReference *row_ref;
 449
 450   DEBUG ("Transfer error %s", error->message);
 451
 452   row_ref = ft_manager_get_row_from_handler (manager, handler);
 453   g_return_if_fail (row_ref != NULL);
 454
 455   message = ft_manager_format_error_message (handler, error);
 456
 457   ft_manager_update_handler_message (manager, row_ref, message);
 458   ft_manager_clear_handler_time (manager, row_ref);
 459   ft_manager_update_buttons (manager);
 460
 461   g_free (message);
 462 }
 463
 464 static void
 465 do_real_transfer_done (EmpathyFTManager *manager,
 466                        EmpathyFTHandler *handler)
 467 {
 468   const char *contact_name;
 469   const char *filename;
 470   char *first_line, *second_line, *message;
 471   char *uri;
 472   gboolean incoming;
 473   GtkTreeRowReference *row_ref;
 474   GtkRecentManager *recent_manager;
 475   GFile *file;
 476
 477   row_ref = ft_manager_get_row_from_handler (manager, handler);
 478   g_return_if_fail (row_ref != NULL);
 479
 480   incoming = empathy_ft_handler_is_incoming (handler);
 481   contact_name = empathy_contact_get_alias
 482     (empathy_ft_handler_get_contact (handler));
 483   filename = empathy_ft_handler_get_filename (handler);
 484
 485   if (incoming)
 486     /* translators: first %s is filename, second %s
 487      * is the contact name */
 488     first_line = g_strdup_printf (_("\"%s\" received from %s"), filename,
 489         contact_name);
 490   else
 491     /* translators: first %s is filename, second %s
 492      * is the contact name */
 493     first_line = g_strdup_printf (_("\"%s\" sent to %s"), filename,
 494         contact_name);
 495
 496   second_line = g_strdup (_("File transfer completed"));
 497
 498   message = g_strdup_printf ("%s\n%s", first_line, second_line);
 499   ft_manager_update_handler_message (manager, row_ref, message);
 500   ft_manager_clear_handler_time (manager, row_ref);
 501
 502   /* update buttons */
 503   ft_manager_update_buttons (manager);
 504
 505   g_free (message);
 506   g_free (first_line);
 507   g_free (second_line);
 508
 509   recent_manager = gtk_recent_manager_get_default ();
 510   file = empathy_ft_handler_get_gfile (handler);
 511   uri = g_file_get_uri (file);
 512
 513   gtk_recent_manager_add_item (recent_manager, uri);
 514
 515   g_free (uri);
 516 }
 517
 518 static void
 519 ft_handler_transfer_done_cb (EmpathyFTHandler *handler,
 520                              TpFileTransferChannel *channel,
 521                              EmpathyFTManager *manager)
 522 {
 523   if (empathy_ft_handler_is_incoming (handler) &&
 524       empathy_ft_handler_get_use_hash (handler))
 525     {
 526       DEBUG ("Transfer done, waiting for hashing-started");
 527
 528       /* connect to the signal and return early */
 529       g_signal_connect (handler, "hashing-started",
 530           G_CALLBACK (ft_handler_hashing_started_cb), manager);
 531
 532       return;
 533     }
 534
 535   DEBUG ("Transfer done, no hashing");
 536
 537   do_real_transfer_done (manager, handler);
 538 }
 539
 540 static void
 541 ft_handler_transfer_progress_cb (EmpathyFTHandler *handler,
 542                                  guint64 current_bytes,
 543                                  guint64 total_bytes,
 544                                  guint remaining_time,
 545                                  gdouble speed,
 546                                  EmpathyFTManager *manager)
 547 {
 548   char *first_line, *second_line, *message;
 549   int percentage;
 550   GtkTreeRowReference *row_ref;
 551
 552   DEBUG ("Transfer progress");
 553
 554   row_ref = ft_manager_get_row_from_handler (manager, handler);
 555   g_return_if_fail (row_ref != NULL);
 556
 557   first_line = ft_manager_format_contact_info (handler);
 558   second_line = ft_manager_format_progress_bytes_and_percentage
 559     (current_bytes, total_bytes, speed, &percentage);
 560
 561   message = g_strdup_printf ("%s\n%s", first_line, second_line);
 562
 563   ft_manager_update_handler_message (manager, row_ref, message);
 564   ft_manager_update_handler_progress (manager, row_ref, percentage);
 565
 566   if (remaining_time > 0)
 567     ft_manager_update_handler_time (manager, row_ref, remaining_time);
 568
 569   g_free (message);
 570   g_free (first_line);
 571   g_free (second_line);
 572 }
 573
 574 static void
 575 ft_handler_transfer_started_cb (EmpathyFTHandler *handler,
 576                                 TpFileTransferChannel *channel,
 577                                 EmpathyFTManager *manager)
 578 {
 579   guint64 transferred_bytes, total_bytes;
 580
 581   DEBUG ("Transfer started");
 582
 583   g_signal_connect (handler, "transfer-progress",
 584       G_CALLBACK (ft_handler_transfer_progress_cb), manager);
 585   g_signal_connect (handler, "transfer-done",
 586       G_CALLBACK (ft_handler_transfer_done_cb), manager);
 587
 588   transferred_bytes = empathy_ft_handler_get_transferred_bytes (handler);
 589   total_bytes = empathy_ft_handler_get_total_bytes (handler);
 590
 591   ft_handler_transfer_progress_cb (handler, transferred_bytes, total_bytes,
 592       0, -1, manager);
 593 }
 594
 595 static void
 596 ft_handler_hashing_done_cb (EmpathyFTHandler *handler,
 597                             EmpathyFTManager *manager)
 598 {
 599   GtkTreeRowReference *row_ref;
 600   char *first_line, *second_line, *message;
 601
 602   DEBUG ("Hashing done");
 603
 604   /* update the message */
 605   if (empathy_ft_handler_is_incoming (handler))
 606     {
 607       do_real_transfer_done (manager, handler);
 608       return;
 609     }
 610
 611   row_ref = ft_manager_get_row_from_handler (manager, handler);
 612   g_return_if_fail (row_ref != NULL);
 613
 614   first_line = ft_manager_format_contact_info (handler);
 615   second_line = g_strdup (_("Waiting for the other participant's response"));
 616   message = g_strdup_printf ("%s\n%s", first_line, second_line);
 617
 618   ft_manager_update_handler_message (manager, row_ref, message);
 619
 620   g_free (message);
 621   g_free (first_line);
 622   g_free (second_line);
 623
 624   g_signal_connect (handler, "transfer-started",
 625       G_CALLBACK (ft_handler_transfer_started_cb), manager);
 626 }
 627
 628 static void
 629 ft_handler_hashing_progress_cb (EmpathyFTHandler *handler,
 630                                 guint64 current_bytes,
 631                                 guint64 total_bytes,
 632                                 EmpathyFTManager *manager)
 633 {
 634   char *first_line, *second_line, *message;
 635   GtkTreeRowReference *row_ref;
 636
 637   row_ref = ft_manager_get_row_from_handler (manager, handler);
 638   g_return_if_fail (row_ref != NULL);
 639
 640   if (empathy_ft_handler_is_incoming (handler))
 641       first_line = g_strdup_printf (_("Checking integrity of \"%s\""),
 642           empathy_ft_handler_get_filename (handler));
 643   else
 644       first_line =  g_strdup_printf (_("Hashing \"%s\""),
 645           empathy_ft_handler_get_filename (handler));
 646
 647   second_line = ft_manager_format_progress_bytes_and_percentage
 648     (current_bytes, total_bytes, -1, NULL);
 649
 650   message = g_strdup_printf ("%s\n%s", first_line, second_line);
 651
 652   ft_manager_update_handler_message (manager, row_ref, message);
 653
 654   g_free (message);
 655   g_free (first_line);
 656   g_free (second_line);
 657 }
 658
 659 static void
 660 ft_handler_hashing_started_cb (EmpathyFTHandler *handler,
 661                                EmpathyFTManager *manager)
 662 {
 663   char *message, *first_line, *second_line;
 664   GtkTreeRowReference *row_ref;
 665
 666   DEBUG ("Hashing started");
 667
 668   g_signal_connect (handler, "hashing-progress",
 669      G_CALLBACK (ft_handler_hashing_progress_cb), manager);
 670   g_signal_connect (handler, "hashing-done",
 671      G_CALLBACK (ft_handler_hashing_done_cb), manager);
 672
 673   row_ref = ft_manager_get_row_from_handler (manager, handler);
 674   g_return_if_fail (row_ref != NULL);
 675
 676   first_line = ft_manager_format_contact_info (handler);
 677
 678   if (empathy_ft_handler_is_incoming (handler))
 679       second_line = g_strdup_printf (_("Checking integrity of \"%s\""),
 680           empathy_ft_handler_get_filename (handler));
 681   else
 682       second_line = g_strdup_printf (_("Hashing \"%s\""),
 683           empathy_ft_handler_get_filename (handler));
 684
 685   message = g_strdup_printf ("%s\n%s", first_line, second_line);
 686
 687   ft_manager_update_handler_message (manager, row_ref, message);
 688
 689   g_free (first_line);
 690   g_free (second_line);
 691   g_free (message);
 692 }
 693
 694 static void
 695 ft_manager_start_transfer (EmpathyFTManager *manager,
 696                            EmpathyFTHandler *handler)
 697 {
 698   gboolean is_outgoing;
 699
 700   is_outgoing = !empathy_ft_handler_is_incoming (handler);
 701
 702   DEBUG ("Start transfer, is outgoing %s",
 703       is_outgoing ? "True" : "False");
 704
 705   /* now connect the signals */
 706   g_signal_connect (handler, "transfer-error",
 707       G_CALLBACK (ft_handler_transfer_error_cb), manager);
 708
 709   if (is_outgoing && empathy_ft_handler_get_use_hash (handler)) {
 710     g_signal_connect (handler, "hashing-started",
 711         G_CALLBACK (ft_handler_hashing_started_cb), manager);
 712   } else {
 713     /* either incoming or outgoing without hash */
 714     g_signal_connect (handler, "transfer-started",
 715         G_CALLBACK (ft_handler_transfer_started_cb), manager);
 716   }
 717
 718   empathy_ft_handler_start_transfer (handler);
 719 }
 720
 721 static void
 722 ft_manager_add_handler_to_list (EmpathyFTManager *manager,
 723                                 EmpathyFTHandler *handler,
 724                                 const GError *error)
 725 {
 726   GtkTreeRowReference *row_ref;
 727   GtkTreeIter iter;
 728   GtkTreeSelection *selection;
 729   GtkTreePath *path;
 730   GIcon *icon;
 731   const char *content_type, *second_line;
 732   char *first_line, *message;
 733   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 734
 735   icon = NULL;
 736
 737   /* get the icon name from the mime-type of the file. */
 738   content_type = empathy_ft_handler_get_content_type (handler);
 739
 740   if (content_type != NULL)
 741     icon = g_content_type_get_icon (content_type);
 742
 743   /* append the handler in the store */
 744   gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->model),
 745       &iter, G_MAXINT, COL_FT_OBJECT, handler,
 746       COL_ICON, icon, -1);
 747
 748   if (icon != NULL)
 749     g_object_unref (icon);
 750
 751   /* insert the new row_ref in the hash table  */
 752   path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->model), &iter);
 753   row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (priv->model), path);
 754   gtk_tree_path_free (path);
 755   g_hash_table_insert (priv->ft_handler_to_row_ref, g_object_ref (handler),
 756       row_ref);
 757
 758   /* select the new row */
 759   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
 760   gtk_tree_selection_select_iter (selection, &iter);
 761
 762   if (error != NULL)
 763     {
 764       message = ft_manager_format_error_message (handler, error);
 765       ft_manager_update_handler_message (manager, row_ref, message);
 766
 767       g_free (message);
 768       return;
 769     }
 770
 771   /* update the row with the initial values.
 772    * the only case where we postpone this is in case we're managing
 773    * an outgoing+hashing transfer, as the hashing started signal will
 774    * take care of updating the information.
 775    */
 776   if (empathy_ft_handler_is_incoming (handler) ||
 777       !empathy_ft_handler_get_use_hash (handler)) {
 778     first_line = ft_manager_format_contact_info (handler);
 779     second_line = _("Waiting for the other participant's response");
 780     message = g_strdup_printf ("%s\n%s", first_line, second_line);
 781
 782     ft_manager_update_handler_message (manager, row_ref, message);
 783
 784     g_free (first_line);
 785     g_free (message);
 786   }
 787
 788   /* hook up the signals and start the transfer */
 789   ft_manager_start_transfer (manager, handler);
 790 }
 791
 792 static void
 793 ft_manager_clear (EmpathyFTManager *manager)
 794 {
 795   EmpathyFTManagerPriv *priv;
 796
 797   DEBUG ("Clearing file transfer list");
 798
 799   priv = GET_PRIV (manager);
 800
 801   /* Remove completed and cancelled transfers */
 802   g_hash_table_foreach_remove (priv->ft_handler_to_row_ref,
 803       remove_finished_transfer_foreach, manager);
 804
 805   /* set the clear button back to insensitive */
 806   gtk_widget_set_sensitive (priv->clear_button, FALSE);
 807 }
 808
 809 static void
 810 ft_manager_open (EmpathyFTManager *manager)
 811 {
 812   GtkTreeSelection *selection;
 813   GtkTreeIter iter;
 814   GtkTreeModel *model;
 815   EmpathyFTHandler *handler;
 816   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 817
 818   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
 819
 820   if (!gtk_tree_selection_get_selected (selection, &model, &iter))
 821     return;
 822
 823   gtk_tree_model_get (model, &iter, COL_FT_OBJECT, &handler, -1);
 824
 825   if (empathy_ft_handler_is_completed (handler)){
 826     char *uri;
 827     GFile *file;
 828
 829     file = empathy_ft_handler_get_gfile (handler);
 830     uri = g_file_get_uri (file);
 831
 832     DEBUG ("Opening URI: %s", uri);
 833     empathy_url_show (GTK_WIDGET (priv->window), uri);
 834     g_free (uri);
 835   }
 836
 837   g_object_unref (handler);
 838 }
 839
 840 static void
 841 ft_manager_stop (EmpathyFTManager *manager)
 842 {
 843   GtkTreeSelection *selection;
 844   GtkTreeIter iter;
 845   GtkTreeModel *model;
 846   EmpathyFTHandler *handler;
 847   EmpathyFTManagerPriv *priv;
 848
 849   priv = GET_PRIV (manager);
 850
 851   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
 852
 853   if (!gtk_tree_selection_get_selected (selection, &model, &iter))
 854     return;
 855
 856   gtk_tree_model_get (model, &iter, COL_FT_OBJECT, &handler, -1);
 857   g_return_if_fail (handler != NULL);
 858
 859   DEBUG ("Stopping file transfer: contact=%s, filename=%s",
 860       empathy_contact_get_alias (empathy_ft_handler_get_contact (handler)),
 861       empathy_ft_handler_get_filename (handler));
 862
 863   empathy_ft_handler_cancel_transfer (handler);
 864
 865   g_object_unref (handler);
 866 }
 867
 868 static gboolean
 869 close_window (EmpathyFTManager *manager)
 870 {
 871   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 872
 873   DEBUG ("%p", manager);
 874
 875   /* remove all the completed/cancelled/errored transfers */
 876   ft_manager_clear (manager);
 877
 878   if (g_hash_table_size (priv->ft_handler_to_row_ref) > 0)
 879     {
 880       /* There is still FTs on flight, just hide the window */
 881       DEBUG ("Hiding window");
 882       gtk_widget_hide (priv->window);
 883       return TRUE;
 884     }
 885
 886   return FALSE;
 887 }
 888
 889 static void
 890 ft_manager_response_cb (GtkWidget *widget,
 891                         gint response,
 892                         EmpathyFTManager *manager)
 893 {
 894   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 895
 896   switch (response)
 897     {
 898       case RESPONSE_CLEAR:
 899         ft_manager_clear (manager);
 900         break;
 901       case RESPONSE_OPEN:
 902         ft_manager_open (manager);
 903         break;
 904       case RESPONSE_STOP:
 905         ft_manager_stop (manager);
 906         break;
 907       case RESPONSE_CLOSE:
 908         if (!close_window (manager))
 909           gtk_widget_destroy (priv->window);
 910         break;
 911       case GTK_RESPONSE_NONE:
 912       case GTK_RESPONSE_DELETE_EVENT:
 913         /* Do nothing */
 914         break;
 915       default:
 916         g_assert_not_reached ();
 917     }
 918 }
 919
 920 static gboolean
 921 ft_manager_delete_event_cb (GtkWidget *widget,
 922                             GdkEvent *event,
 923                             EmpathyFTManager *manager)
 924 {
 925   return close_window (manager);
 926 }
 927
 928 static void
 929 ft_manager_destroy_cb (GtkWidget *widget,
 930                        EmpathyFTManager *manager)
 931 {
 932   DEBUG ("%p", manager);
 933
 934   g_object_unref (manager);
 935 }
 936
 937 static gboolean
 938 ft_view_button_press_event_cb (GtkWidget *widget,
 939                                GdkEventKey *event,
 940                                EmpathyFTManager *manager)
 941 {
 942
 943   if (event->type != GDK_2BUTTON_PRESS)
 944       return FALSE;
 945
 946   ft_manager_open (manager);
 947
 948   return FALSE;
 949 }
 950
 951 static gboolean
 952 ft_manager_key_press_event_cb (GtkWidget *widget,
 953                                GdkEventKey *event,
 954                                gpointer user_data)
 955 {
 956   if ((event->state & GDK_CONTROL_MASK && event->keyval == GDK_KEY_w)
 957       || event->keyval == GDK_KEY_Escape)
 958     {
 959       gtk_widget_destroy (widget);
 960       return TRUE;
 961     }
 962
 963   return FALSE;
 964 }
 965
 966 static void
 967 ft_manager_build_ui (EmpathyFTManager *manager)
 968 {
 969   GtkBuilder *gui;
 970   GtkTreeView *view;
 971   GtkListStore *liststore;
 972   GtkTreeViewColumn *column;
 973   GtkCellRenderer *renderer;
 974   GtkTreeSelection *selection;
 975   gchar *filename;
 976   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 977
 978   filename = empathy_file_lookup ("empathy-ft-manager.ui", "src");
 979   gui = empathy_builder_get_file (filename,
 980       "ft_manager_dialog", &priv->window,
 981       "ft_list", &priv->treeview,
 982       "clear_button", &priv->clear_button,
 983       "open_button", &priv->open_button,
 984       "abort_button", &priv->abort_button,
 985       NULL);
 986   g_free (filename);
 987
 988   empathy_builder_connect (gui, manager,
 989       "ft_manager_dialog", "destroy", ft_manager_destroy_cb,
 990       "ft_manager_dialog", "response", ft_manager_response_cb,
 991       "ft_manager_dialog", "delete-event", ft_manager_delete_event_cb,
 992       "ft_manager_dialog", "key-press-event", ft_manager_key_press_event_cb,
 993       NULL);
 994
 995   empathy_builder_unref_and_keep_widget (gui, priv->window);
 996
 997   /* Window geometry. */
 998   empathy_geometry_bind (GTK_WINDOW (priv->window), "ft-manager");
 999
1000   /* Setup the tree view */
1001   view = GTK_TREE_VIEW (priv->treeview);
1002   selection = gtk_tree_view_get_selection (view);
1003   gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
1004   g_signal_connect (selection, "changed",
1005       G_CALLBACK (ft_manager_selection_changed), manager);
1006   g_signal_connect (view, "button-press-event",
1007                     G_CALLBACK (ft_view_button_press_event_cb),
1008                     manager);
1009   gtk_tree_view_set_headers_visible (view, TRUE);
1010   gtk_tree_view_set_enable_search (view, FALSE);
1011
1012   /* Setup the model */
1013   liststore = gtk_list_store_new (5,
1014       G_TYPE_INT,     /* percent */
1015       G_TYPE_ICON,    /* icon */
1016       G_TYPE_STRING,  /* message */
1017       G_TYPE_STRING,  /* remaining */
1018       G_TYPE_OBJECT); /* ft_handler */
1019   gtk_tree_view_set_model (view, GTK_TREE_MODEL (liststore));
1020   priv->model = GTK_TREE_MODEL (liststore);
1021   g_object_unref (liststore);
1022
1023   /* Progress column */
1024   column = gtk_tree_view_column_new ();
1025   gtk_tree_view_column_set_title (column, _("%"));
1026   gtk_tree_view_column_set_sort_column_id (column, COL_PERCENT);
1027   gtk_tree_view_insert_column (view, column, -1);
1028
1029   renderer = gtk_cell_renderer_progress_new ();
1030   g_object_set (renderer, "xalign", 0.5, NULL);
1031   gtk_tree_view_column_pack_start (column, renderer, FALSE);
1032   gtk_tree_view_column_set_cell_data_func (column, renderer,
1033       ft_manager_progress_cell_data_func, NULL, NULL);
1034
1035   /* Icon and filename column*/
1036   column = gtk_tree_view_column_new ();
1037   gtk_tree_view_column_set_title (column, _("File"));
1038   gtk_tree_view_column_set_expand (column, TRUE);
1039   gtk_tree_view_column_set_resizable (column, TRUE);
1040   gtk_tree_view_column_set_sort_column_id (column, COL_MESSAGE);
1041   gtk_tree_view_column_set_spacing (column, 3);
1042   gtk_tree_view_insert_column (view, column, -1);
1043
1044   renderer = gtk_cell_renderer_pixbuf_new ();
1045   g_object_set (renderer, "xpad", 3,
1046       "stock-size", GTK_ICON_SIZE_DND, NULL);
1047   gtk_tree_view_column_pack_start (column, renderer, FALSE);
1048   gtk_tree_view_column_set_attributes (column, renderer,
1049       "gicon", COL_ICON, NULL);
1050
1051   renderer = gtk_cell_renderer_text_new ();
1052   g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
1053   gtk_tree_view_column_pack_start (column, renderer, TRUE);
1054   gtk_tree_view_column_set_attributes (column, renderer,
1055       "text", COL_MESSAGE, NULL);
1056
1057   /* Remaining time column */
1058   column = gtk_tree_view_column_new ();
1059   gtk_tree_view_column_set_title (column, _("Remaining"));
1060   gtk_tree_view_column_set_sort_column_id (column, COL_REMAINING);
1061   gtk_tree_view_insert_column (view, column, -1);
1062
1063   renderer = gtk_cell_renderer_text_new ();
1064   g_object_set (renderer, "xalign", 0.5, NULL);
1065   gtk_tree_view_column_pack_start (column, renderer, FALSE);
1066   gtk_tree_view_column_set_attributes (column, renderer,
1067       "text", COL_REMAINING, NULL);
1068
1069   /* clear button should be sensitive only if there are completed/cancelled
1070    * handlers in the store.
1071    */
1072   gtk_widget_set_sensitive (priv->clear_button, FALSE);
1073 }
1074
1075 /* GObject method overrides */
1076
1077 static void
1078 empathy_ft_manager_finalize (GObject *object)
1079 {
1080   EmpathyFTManagerPriv *priv = GET_PRIV (object);
1081
1082   DEBUG ("FT Manager %p", object);
1083
1084   g_hash_table_unref (priv->ft_handler_to_row_ref);
1085
1086   G_OBJECT_CLASS (empathy_ft_manager_parent_class)->finalize (object);
1087 }
1088
1089 static void
1090 empathy_ft_manager_init (EmpathyFTManager *manager)
1091 {
1092   EmpathyFTManagerPriv *priv;
1093
1094   priv = G_TYPE_INSTANCE_GET_PRIVATE ((manager), EMPATHY_TYPE_FT_MANAGER,
1095       EmpathyFTManagerPriv);
1096
1097   manager->priv = priv;
1098
1099   priv->ft_handler_to_row_ref = g_hash_table_new_full (g_direct_hash,
1100       g_direct_equal, (GDestroyNotify) g_object_unref,
1101       (GDestroyNotify) gtk_tree_row_reference_free);
1102
1103   ft_manager_build_ui (manager);
1104 }
1105
1106 static GObject *
1107 empathy_ft_manager_constructor (GType type,
1108                                 guint n_props,
1109                                 GObjectConstructParam *props)
1110 {
1111   GObject *retval;
1112
1113   if (manager_singleton)
1114     {
1115       retval = G_OBJECT (manager_singleton);
1116     }
1117   else
1118     {
1119       retval = G_OBJECT_CLASS (empathy_ft_manager_parent_class)->constructor
1120           (type, n_props, props);
1121
1122       manager_singleton = EMPATHY_FT_MANAGER (retval);
1123       g_object_add_weak_pointer (retval, (gpointer) &manager_singleton);
1124     }
1125
1126   return retval;
1127 }
1128
1129 static void
1130 empathy_ft_manager_class_init (EmpathyFTManagerClass *klass)
1131 {
1132   GObjectClass *object_class = G_OBJECT_CLASS (klass);
1133
1134   object_class->finalize = empathy_ft_manager_finalize;
1135   object_class->constructor = empathy_ft_manager_constructor;
1136
1137   g_type_class_add_private (object_class, sizeof (EmpathyFTManagerPriv));
1138 }
1139
1140 /* public methods */
1141
1142 void
1143 empathy_ft_manager_add_handler (EmpathyFTHandler *handler)
1144 {
1145   EmpathyFTManager *manager;
1146   EmpathyFTManagerPriv *priv;
1147
1148   DEBUG ("Adding handler");
1149
1150   g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
1151
1152   manager = g_object_new (EMPATHY_TYPE_FT_MANAGER, NULL);
1153   priv = GET_PRIV (manager);
1154
1155   ft_manager_add_handler_to_list (manager, handler, NULL);
1156   gtk_window_present (GTK_WINDOW (priv->window));
1157 }
1158
1159 void
1160 empathy_ft_manager_display_error (EmpathyFTHandler *handler,
1161                                   const GError *error)
1162 {
1163   EmpathyFTManager *manager;
1164   EmpathyFTManagerPriv *priv;
1165
1166   g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
1167   g_return_if_fail (error != NULL);
1168
1169   manager = g_object_new (EMPATHY_TYPE_FT_MANAGER, NULL);
1170   priv = GET_PRIV (manager);
1171
1172   ft_manager_add_handler_to_list (manager, handler, error);
1173   gtk_window_present (GTK_WINDOW (priv->window));
1174 }
1175
1176 void
1177 empathy_ft_manager_show (void)
1178 {
1179   EmpathyFTManager *manager;
1180   EmpathyFTManagerPriv *priv;
1181
1182   manager = g_object_new (EMPATHY_TYPE_FT_MANAGER, NULL);
1183   priv = GET_PRIV (manager);
1184
1185   gtk_window_present (GTK_WINDOW (priv->window));
1186 }