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