src/empathy-ft-manager.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2003, 2004 Xan Lopez
   4  * Copyright (C) 2007 Marco Barisione <marco@barisione.org>
   5  * Copyright (C) 2008 Collabora Ltd.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public
  18  * License along with this program; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  *
  22  * Authors: Xan Lopez
  23  *          Marco Barisione <marco@barisione.org>
  24  *          Jonny Lamb <jonny.lamb@collabora.co.uk>
  25  *          Xavier Claessens <xclaesse@gmail.com>
  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
  37 #define DEBUG_FLAG EMPATHY_DEBUG_FT
  38 #include <libempathy/empathy-debug.h>
  39 #include <libempathy/empathy-tp-file.h>
  40 #include <libempathy/empathy-utils.h>
  41
  42 #include <libempathy-gtk/empathy-conf.h>
  43 #include <libempathy-gtk/empathy-ui-utils.h>
  44 #include <libempathy-gtk/empathy-geometry.h>
  45 #include <libempathy-gtk/empathy-images.h>
  46
  47 #include "empathy-ft-manager.h"
  48
  49 /**
  50  * SECTION:empathy-ft-manager
  51  * @short_description: File transfer dialog
  52  * @see_also: #EmpathyTpFile, empathy_dispatcher_send_file()
  53  * @include: libempthy-gtk/empathy-ft-manager.h
  54  *
  55  * The #EmpathyFTManager object represents the file transfer dialog,
  56  * it can show multiple file transfers at the same time (added
  57  * with empathy_ft_manager_add_tp_file()).
  58  */
  59
  60 enum
  61 {
  62   COL_PERCENT,
  63   COL_ICON,
  64   COL_MESSAGE,
  65   COL_REMAINING,
  66   COL_FT_OBJECT
  67 };
  68
  69 /**
  70  * EmpathyFTManagerPriv:
  71  *
  72  * Private fields of the #EmpathyFTManager class.
  73  */
  74 struct _EmpathyFTManagerPriv
  75 {
  76   GtkTreeModel *model;
  77   GHashTable *tp_file_to_row_ref;
  78
  79   /* Widgets */
  80   GtkWidget *window;
  81   GtkWidget *treeview;
  82   GtkWidget *open_button;
  83   GtkWidget *abort_button;
  84
  85   guint save_geometry_id;
  86 };
  87
  88 enum
  89 {
  90   RESPONSE_OPEN  = 1,
  91   RESPONSE_STOP  = 2,
  92   RESPONSE_CLEAR = 3
  93 };
  94
  95 G_DEFINE_TYPE (EmpathyFTManager, empathy_ft_manager, G_TYPE_OBJECT);
  96
  97 static gchar *
  98 ft_manager_format_interval (gint interval)
  99 {
 100   gint hours, mins, secs;
 101
 102   hours = interval / 3600;
 103   interval -= hours * 3600;
 104   mins = interval / 60;
 105   interval -= mins * 60;
 106   secs = interval;
 107
 108   if (hours > 0)
 109     return g_strdup_printf (_("%u:%02u.%02u"), hours, mins, secs);
 110   else
 111     return g_strdup_printf (_("%02u.%02u"), mins, secs);
 112 }
 113
 114 static GtkTreeRowReference *
 115 ft_manager_get_row_from_tp_file (EmpathyFTManager *ft_manager,
 116                                  EmpathyTpFile *tp_file)
 117 {
 118   return g_hash_table_lookup (ft_manager->priv->tp_file_to_row_ref, tp_file);
 119 }
 120
 121 static void
 122 ft_manager_update_buttons (EmpathyFTManager *ft_manager)
 123 {
 124   GtkTreeSelection *selection;
 125   GtkTreeModel *model;
 126   GtkTreeIter iter;
 127   EmpathyTpFile *tp_file;
 128   EmpFileTransferState state;
 129   gboolean open_enabled = FALSE;
 130   gboolean abort_enabled = FALSE;
 131
 132   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (
 133       ft_manager->priv->treeview));
 134   if (gtk_tree_selection_get_selected (selection, &model, &iter))
 135     {
 136       gtk_tree_model_get (model, &iter, COL_FT_OBJECT, &tp_file, -1);
 137       state = empathy_tp_file_get_state (tp_file, NULL);
 138
 139       /* I can open the file if the transfer is completed and was incoming */
 140       open_enabled = (state == EMP_FILE_TRANSFER_STATE_COMPLETED &&
 141         empathy_tp_file_is_incoming (tp_file));
 142
 143       /* I can abort if the transfer is not already finished */
 144       abort_enabled = (state != EMP_FILE_TRANSFER_STATE_CANCELLED &&
 145         state != EMP_FILE_TRANSFER_STATE_COMPLETED);
 146
 147       g_object_unref (tp_file);
 148     }
 149
 150   gtk_widget_set_sensitive (ft_manager->priv->open_button, open_enabled);
 151   gtk_widget_set_sensitive (ft_manager->priv->abort_button, abort_enabled);
 152 }
 153
 154 static const gchar *
 155 ft_manager_state_change_reason_to_string (EmpFileTransferStateChangeReason reason)
 156 {
 157   switch (reason)
 158     {
 159       case EMP_FILE_TRANSFER_STATE_CHANGE_REASON_NONE:
 160         return _("No reason was specified");
 161       case EMP_FILE_TRANSFER_STATE_CHANGE_REASON_REQUESTED:
 162         return _("The change in state was requested");
 163       case EMP_FILE_TRANSFER_STATE_CHANGE_REASON_LOCAL_STOPPED:
 164         return _("You canceled the file transfer");
 165       case EMP_FILE_TRANSFER_STATE_CHANGE_REASON_REMOTE_STOPPED:
 166         return _("The other participant canceled the file transfer");
 167       case EMP_FILE_TRANSFER_STATE_CHANGE_REASON_LOCAL_ERROR:
 168         return _("Error while trying to transfer the file");
 169       case EMP_FILE_TRANSFER_STATE_CHANGE_REASON_REMOTE_ERROR:
 170         return _("The other participant is unable to transfer the file");
 171     }
 172   return _("Unknown reason");
 173 }
 174
 175 static void
 176 ft_manager_update_ft_row (EmpathyFTManager *ft_manager,
 177                           EmpathyTpFile *tp_file)
 178 {
 179   GtkTreeRowReference  *row_ref;
 180   GtkTreePath *path;
 181   GtkTreeIter iter;
 182   const gchar *filename;
 183   const gchar *contact_name;
 184   const gchar *msg;
 185   gchar *msg_dup = NULL;
 186   gchar *remaining_str = NULL;
 187   gchar *first_line_format;
 188   gchar *first_line = NULL;
 189   gchar *second_line = NULL;
 190   guint64 transferred_bytes;
 191   guint64 total_size;
 192   gint remaining = -1;
 193   gint percent;
 194   EmpFileTransferState state;
 195   EmpFileTransferStateChangeReason reason;
 196   gboolean incoming;
 197
 198   row_ref = ft_manager_get_row_from_tp_file (ft_manager, tp_file);
 199   g_return_if_fail (row_ref != NULL);
 200
 201   filename = empathy_tp_file_get_filename (tp_file);
 202   contact_name = empathy_contact_get_name (empathy_tp_file_get_contact (tp_file));
 203   transferred_bytes = empathy_tp_file_get_transferred_bytes (tp_file);
 204   total_size = empathy_tp_file_get_size (tp_file);
 205   state = empathy_tp_file_get_state (tp_file, &reason);
 206   incoming = empathy_tp_file_is_incoming (tp_file);
 207
 208   switch (state)
 209     {
 210       case EMP_FILE_TRANSFER_STATE_NONE:
 211         /* This should never happen, the CM is broken. But we avoid warning
 212          * because it's not our fault. */
 213         DEBUG ("State is NONE, probably a broken CM");
 214         break;
 215       case EMP_FILE_TRANSFER_STATE_PENDING:
 216       case EMP_FILE_TRANSFER_STATE_OPEN:
 217       case EMP_FILE_TRANSFER_STATE_ACCEPTED:
 218         if (incoming)
 219           /* translators: first %s is filename, second %s is the contact name */
 220           first_line_format = _("Receiving \"%s\" from %s");
 221         else
 222           /* translators: first %s is filename, second %s is the contact name */
 223           first_line_format = _("Sending \"%s\" to %s");
 224
 225         first_line = g_strdup_printf (first_line_format, filename, contact_name);
 226
 227         if (state == EMP_FILE_TRANSFER_STATE_OPEN || incoming)
 228           {
 229             gchar *total_size_str;
 230             gchar *transferred_bytes_str;
 231
 232             if (total_size == EMPATHY_TP_FILE_UNKNOWN_SIZE)
 233               total_size_str = g_strdup (C_("file size", "Unknown"));
 234             else
 235               total_size_str = g_format_size_for_display (total_size);
 236
 237             transferred_bytes_str = g_format_size_for_display (transferred_bytes);
 238
 239             /* translators: first %s is the transferred size, second %s is
 240              * the total file size */
 241             second_line = g_strdup_printf (_("%s of %s"), transferred_bytes_str,
 242                 total_size_str);
 243             g_free (transferred_bytes_str);
 244             g_free (total_size_str);
 245
 246           }
 247         else
 248           second_line = g_strdup (_("Waiting the other participant's response"));
 249
 250       remaining = empathy_tp_file_get_remaining_time (tp_file);
 251       break;
 252
 253     case EMP_FILE_TRANSFER_STATE_COMPLETED:
 254       if (incoming)
 255         /* translators: first %s is filename, second %s
 256          * is the contact name */
 257         first_line = g_strdup_printf (
 258             _("\"%s\" received from %s"), filename,
 259             contact_name);
 260       else
 261         /* translators: first %s is filename, second %s
 262          * is the contact name */
 263         first_line = g_strdup_printf (
 264             _("\"%s\" sent to %s"), filename,
 265             contact_name);
 266
 267       second_line = g_strdup (_("File transfer completed"));
 268
 269       break;
 270
 271     case EMP_FILE_TRANSFER_STATE_CANCELLED:
 272       if (incoming)
 273         /* translators: first %s is filename, second %s
 274          * is the contact name */
 275         first_line = g_strdup_printf (
 276             _("\"%s\" receiving from %s"), filename,
 277             contact_name);
 278       else
 279         /* translators: first %s is filename, second %s
 280          * is the contact name */
 281         first_line = g_strdup_printf (
 282             _("\"%s\" sending to %s"), filename,
 283             contact_name);
 284
 285       second_line = g_strdup_printf (_("File transfer canceled: %s"),
 286           ft_manager_state_change_reason_to_string (reason));
 287
 288       break;
 289     }
 290
 291   if (total_size != EMPATHY_TP_FILE_UNKNOWN_SIZE && total_size != 0)
 292     percent = transferred_bytes * 100 / total_size;
 293   else
 294     percent = -1;
 295
 296   if (remaining < 0)
 297     {
 298       if (state != EMP_FILE_TRANSFER_STATE_COMPLETED &&
 299           state != EMP_FILE_TRANSFER_STATE_CANCELLED)
 300         remaining_str = g_strdup (C_("remaining time", "Unknown"));
 301     }
 302   else
 303     remaining_str = ft_manager_format_interval (remaining);
 304
 305   if (first_line != NULL && second_line != NULL)
 306     msg = msg_dup = g_strdup_printf ("%s\n%s", first_line, second_line);
 307   else
 308     msg = first_line ? first_line : second_line;
 309
 310   /* Set new values in the store */
 311   path = gtk_tree_row_reference_get_path (row_ref);
 312   gtk_tree_model_get_iter (ft_manager->priv->model, &iter, path);
 313   gtk_list_store_set (GTK_LIST_STORE (ft_manager->priv->model),
 314       &iter,
 315       COL_PERCENT, percent,
 316       COL_MESSAGE, msg ? msg : "",
 317       COL_REMAINING, remaining_str ? remaining_str : "",
 318       -1);
 319
 320   gtk_tree_path_free (path);
 321
 322   g_free (msg_dup);
 323   g_free (first_line);
 324   g_free (second_line);
 325   g_free (remaining_str);
 326
 327   ft_manager_update_buttons (ft_manager);
 328 }
 329
 330 static void
 331 ft_manager_transferred_bytes_changed_cb (EmpathyTpFile *tp_file,
 332                                          GParamSpec *pspec,
 333                                          EmpathyFTManager *ft_manager)
 334 {
 335   ft_manager_update_ft_row (ft_manager, tp_file);
 336 }
 337
 338 static void
 339 ft_manager_selection_changed (GtkTreeSelection *selection,
 340                               EmpathyFTManager *ft_manager)
 341 {
 342   ft_manager_update_buttons (ft_manager);
 343 }
 344
 345 static void
 346 ft_manager_progress_cell_data_func (GtkTreeViewColumn *col,
 347                                     GtkCellRenderer *renderer,
 348                                     GtkTreeModel *model,
 349                                     GtkTreeIter *iter,
 350                                     gpointer user_data)
 351 {
 352   const gchar *text = NULL;
 353   gint percent;
 354
 355   gtk_tree_model_get (model, iter, COL_PERCENT, &percent, -1);
 356
 357   if (percent < 0)
 358     {
 359       percent = 0;
 360       text = C_("file transfer percent", "Unknown");
 361     }
 362
 363   g_object_set (renderer, "text", text, "value", percent, NULL);
 364 }
 365
 366 static gboolean
 367 ft_manager_save_geometry_timeout_cb (EmpathyFTManager *ft_manager)
 368 {
 369   gint x, y, w, h;
 370
 371   gtk_window_get_size (GTK_WINDOW (ft_manager->priv->window), &w, &h);
 372   gtk_window_get_position (GTK_WINDOW (ft_manager->priv->window), &x, &y);
 373
 374   empathy_geometry_save ("ft-manager", x, y, w, h);
 375
 376   ft_manager->priv->save_geometry_id = 0;
 377
 378   return FALSE;
 379 }
 380
 381 static gboolean
 382 ft_manager_configure_event_cb (GtkWidget *widget,
 383                                GdkEventConfigure *event,
 384                                EmpathyFTManager *ft_manager)
 385 {
 386   if (ft_manager->priv->save_geometry_id != 0)
 387     g_source_remove (ft_manager->priv->save_geometry_id);
 388
 389   ft_manager->priv->save_geometry_id = g_timeout_add (500,
 390       (GSourceFunc) ft_manager_save_geometry_timeout_cb, ft_manager);
 391
 392   return FALSE;
 393 }
 394
 395 static void
 396 ft_manager_remove_file_from_model (EmpathyFTManager *ft_manager,
 397                                   EmpathyTpFile *tp_file)
 398 {
 399   GtkTreeRowReference *row_ref;
 400   GtkTreeSelection *selection;
 401   GtkTreePath *path = NULL;
 402   GtkTreeIter iter;
 403   gboolean update_selection;
 404
 405   row_ref = ft_manager_get_row_from_tp_file (ft_manager, tp_file);
 406   g_return_if_fail (row_ref);
 407
 408   DEBUG ("Removing file transfer from window: contact=%s, filename=%s",
 409       empathy_contact_get_name (empathy_tp_file_get_contact (tp_file)),
 410       empathy_tp_file_get_filename (tp_file));
 411
 412   /* Get the iter from the row_ref */
 413   path = gtk_tree_row_reference_get_path (row_ref);
 414   gtk_tree_model_get_iter (ft_manager->priv->model, &iter, path);
 415   gtk_tree_path_free (path);
 416
 417   /* We have to update the selection only if we are removing the selected row */
 418   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ft_manager->priv->treeview));
 419   update_selection = gtk_tree_selection_iter_is_selected (selection, &iter);
 420
 421   /* Remove tp_file's row. After that iter points to the next row */
 422   if (!gtk_list_store_remove (GTK_LIST_STORE (ft_manager->priv->model), &iter))
 423     {
 424       gint n_row;
 425
 426       /* There is no next row, set iter to the last row */
 427       n_row = gtk_tree_model_iter_n_children (ft_manager->priv->model, NULL);
 428       if (n_row > 0)
 429         gtk_tree_model_iter_nth_child (ft_manager->priv->model, &iter, NULL,
 430           n_row - 1);
 431       else
 432         update_selection = FALSE;
 433     }
 434
 435   if (update_selection)
 436     gtk_tree_selection_select_iter (selection, &iter);
 437 }
 438
 439 static gboolean
 440 remove_finished_transfer_foreach (gpointer key,
 441                                   gpointer value,
 442                                   gpointer user_data)
 443 {
 444   EmpathyTpFile *tp_file = EMPATHY_TP_FILE (key);
 445   EmpathyFTManager *self = EMPATHY_FT_MANAGER (user_data);
 446   EmpFileTransferState state;
 447
 448   state = empathy_tp_file_get_state (tp_file, NULL);
 449   if (state == EMP_FILE_TRANSFER_STATE_COMPLETED ||
 450       state == EMP_FILE_TRANSFER_STATE_CANCELLED)
 451     {
 452       ft_manager_remove_file_from_model (self, tp_file);
 453       return TRUE;
 454     }
 455
 456   return FALSE;
 457 }
 458
 459 static void
 460 ft_manager_state_changed_cb (EmpathyTpFile *tp_file,
 461                              GParamSpec *pspec,
 462                              EmpathyFTManager *ft_manager)
 463 {
 464   if (empathy_tp_file_get_state (tp_file, NULL) ==
 465       EMP_FILE_TRANSFER_STATE_COMPLETED)
 466     {
 467       GtkRecentManager *manager;
 468       const gchar *uri;
 469
 470       manager = gtk_recent_manager_get_default ();
 471       uri = g_object_get_data (G_OBJECT (tp_file), "uri");
 472       if (uri != NULL)
 473         gtk_recent_manager_add_item (manager, uri);
 474     }
 475
 476     ft_manager_update_ft_row (ft_manager, tp_file);
 477 }
 478
 479 static void
 480 ft_manager_add_tp_file_to_list (EmpathyFTManager *ft_manager,
 481                                 EmpathyTpFile *tp_file)
 482 {
 483   GtkTreeRowReference *row_ref;
 484   GtkTreeIter iter;
 485   GtkTreeSelection *selection;
 486   GtkTreePath *path;
 487   GIcon *icon;
 488   const gchar *content_type;
 489
 490   /* Get the icon name from the mime-type of the file. */
 491   content_type = empathy_tp_file_get_content_type (tp_file);
 492   icon = g_content_type_get_icon (content_type);
 493
 494   /* Append the ft in the store */
 495   gtk_list_store_insert_with_values (GTK_LIST_STORE (ft_manager->priv->model),
 496       &iter, G_MAXINT, COL_FT_OBJECT, tp_file, COL_ICON, icon, -1);
 497
 498   g_object_unref (icon);
 499
 500   /* Insert the new row_ref in the hash table  */
 501   path = gtk_tree_model_get_path (GTK_TREE_MODEL (ft_manager->priv->model),
 502       &iter);
 503   row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (
 504       ft_manager->priv->model), path);
 505   gtk_tree_path_free (path);
 506   g_hash_table_insert (ft_manager->priv->tp_file_to_row_ref,
 507       g_object_ref (tp_file), row_ref);
 508
 509   /* Select the new row */
 510   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (
 511       ft_manager->priv->treeview));
 512   gtk_tree_selection_select_iter (selection, &iter);
 513
 514   /* Update the row with the initial values, and keep track of changes */
 515   ft_manager_update_ft_row (ft_manager, tp_file);
 516   g_signal_connect (tp_file, "notify::state",
 517       G_CALLBACK (ft_manager_state_changed_cb), ft_manager);
 518   g_signal_connect (tp_file, "notify::transferred-bytes",
 519       G_CALLBACK (ft_manager_transferred_bytes_changed_cb), ft_manager);
 520
 521   gtk_window_present (GTK_WINDOW (ft_manager->priv->window));
 522 }
 523
 524 static void
 525 ft_manager_clear (EmpathyFTManager *ft_manager)
 526 {
 527   DEBUG ("Clearing file transfer list");
 528
 529   /* Remove completed and cancelled transfers */
 530   g_hash_table_foreach_remove (ft_manager->priv->tp_file_to_row_ref,
 531       remove_finished_transfer_foreach, ft_manager);
 532 }
 533
 534 static void
 535 ft_manager_open (EmpathyFTManager *ft_manager)
 536 {
 537   GtkTreeSelection *selection;
 538   GtkTreeIter iter;
 539   GtkTreeModel *model;
 540   EmpathyTpFile *tp_file;
 541   const gchar *uri;
 542
 543   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ft_manager->priv->treeview));
 544
 545   if (!gtk_tree_selection_get_selected (selection, &model, &iter))
 546     return;
 547
 548   gtk_tree_model_get (model, &iter, COL_FT_OBJECT, &tp_file, -1);
 549   g_return_if_fail (tp_file != NULL);
 550
 551   uri = g_object_get_data (G_OBJECT (tp_file), "uri");
 552   DEBUG ("Opening URI: %s", uri);
 553   empathy_url_show (GTK_WIDGET (ft_manager->priv->window), uri);
 554   g_object_unref (tp_file);
 555 }
 556
 557 static void
 558 ft_manager_stop (EmpathyFTManager *ft_manager)
 559 {
 560   GtkTreeSelection *selection;
 561   GtkTreeIter iter;
 562   GtkTreeModel *model;
 563   EmpathyTpFile *tp_file;
 564
 565   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ft_manager->priv->treeview));
 566
 567   if (!gtk_tree_selection_get_selected (selection, &model, &iter))
 568     return;
 569
 570   gtk_tree_model_get (model, &iter, COL_FT_OBJECT, &tp_file, -1);
 571   g_return_if_fail (tp_file != NULL);
 572
 573   DEBUG ("Stopping file transfer: contact=%s, filename=%s",
 574       empathy_contact_get_name (empathy_tp_file_get_contact (tp_file)),
 575       empathy_tp_file_get_filename (tp_file));
 576
 577   empathy_tp_file_cancel (tp_file);
 578   g_object_unref (tp_file);
 579 }
 580
 581 static void
 582 ft_manager_response_cb (GtkWidget *widget,
 583                         gint response,
 584                         EmpathyFTManager *ft_manager)
 585 {
 586   switch (response)
 587     {
 588       case RESPONSE_CLEAR:
 589         ft_manager_clear (ft_manager);
 590         break;
 591       case RESPONSE_OPEN:
 592         ft_manager_open (ft_manager);
 593         break;
 594       case RESPONSE_STOP:
 595         ft_manager_stop (ft_manager);
 596         break;
 597     }
 598 }
 599
 600 static gboolean
 601 ft_manager_delete_event_cb (GtkWidget *widget,
 602                             GdkEvent *event,
 603                             EmpathyFTManager *ft_manager)
 604 {
 605   ft_manager_clear (ft_manager);
 606   if (g_hash_table_size (ft_manager->priv->tp_file_to_row_ref) > 0)
 607     {
 608       /* There is still FTs on flight, just hide the window */
 609       DEBUG ("Hiding window");
 610       gtk_widget_hide (widget);
 611       return TRUE;
 612     }
 613
 614   return FALSE;
 615 }
 616
 617 static void
 618 ft_manager_destroy_cb (GtkWidget *widget,
 619                        EmpathyFTManager *ft_manager)
 620 {
 621   g_object_unref (ft_manager);
 622 }
 623
 624 static void
 625 ft_manager_build_ui (EmpathyFTManager *ft_manager)
 626 {
 627   GladeXML *glade;
 628   gint x, y, w, h;
 629   GtkTreeView *view;
 630   GtkListStore *liststore;
 631   GtkTreeViewColumn *column;
 632   GtkCellRenderer *renderer;
 633   GtkTreeSelection *selection;
 634   gchar *filename;
 635
 636   filename = empathy_file_lookup ("empathy-ft-manager.glade", "src");
 637   glade = empathy_glade_get_file (filename,
 638       "ft_manager_dialog", NULL,
 639       "ft_manager_dialog", &ft_manager->priv->window,
 640       "ft_list", &ft_manager->priv->treeview,
 641       "open_button", &ft_manager->priv->open_button,
 642       "abort_button", &ft_manager->priv->abort_button,
 643       NULL);
 644   g_free (filename);
 645
 646   empathy_glade_connect (glade, ft_manager,
 647       "ft_manager_dialog", "destroy", ft_manager_destroy_cb,
 648       "ft_manager_dialog", "response", ft_manager_response_cb,
 649       "ft_manager_dialog", "delete-event", ft_manager_delete_event_cb,
 650       "ft_manager_dialog", "configure-event", ft_manager_configure_event_cb,
 651       NULL);
 652
 653   g_object_unref (glade);
 654
 655   /* Window geometry. */
 656   empathy_geometry_load ("ft-manager", &x, &y, &w, &h);
 657
 658   if (x >= 0 && y >= 0)
 659     {
 660       /* Let the window manager position it if we don't have
 661        * good x, y coordinates. */
 662       gtk_window_move (GTK_WINDOW (ft_manager->priv->window), x, y);
 663     }
 664
 665   if (w > 0 && h > 0)
 666     {
 667       /* Use the defaults from the glade file if we don't have
 668        * good w, h geometry. */
 669       gtk_window_resize (GTK_WINDOW (ft_manager->priv->window), w, h);
 670     }
 671
 672   /* Setup the tree view */
 673   view = GTK_TREE_VIEW (ft_manager->priv->treeview);
 674   selection = gtk_tree_view_get_selection (view);
 675   gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
 676   g_signal_connect (selection, "changed",
 677       G_CALLBACK (ft_manager_selection_changed), ft_manager);
 678   gtk_tree_view_set_headers_visible (view, TRUE);
 679   gtk_tree_view_set_enable_search (view, FALSE);
 680
 681   /* Setup the model */
 682   liststore = gtk_list_store_new (5,
 683       G_TYPE_INT,     /* percent */
 684       G_TYPE_ICON,    /* icon */
 685       G_TYPE_STRING,  /* message */
 686       G_TYPE_STRING,  /* remaining */
 687       G_TYPE_OBJECT); /* ft_file */
 688   gtk_tree_view_set_model (view, GTK_TREE_MODEL (liststore));
 689   ft_manager->priv->model = GTK_TREE_MODEL (liststore);
 690   g_object_unref (liststore);
 691
 692   /* Progress column */
 693   column = gtk_tree_view_column_new ();
 694   gtk_tree_view_column_set_title (column, _("%"));
 695   gtk_tree_view_column_set_sort_column_id (column, COL_PERCENT);
 696   gtk_tree_view_insert_column (view, column, -1);
 697
 698   renderer = gtk_cell_renderer_progress_new ();
 699   g_object_set (renderer, "xalign", 0.5, NULL);
 700   gtk_tree_view_column_pack_start (column, renderer, FALSE);
 701   gtk_tree_view_column_set_cell_data_func (column, renderer,
 702       ft_manager_progress_cell_data_func, NULL, NULL);
 703
 704   /* Icon and filename column*/
 705   column = gtk_tree_view_column_new ();
 706   gtk_tree_view_column_set_title (column, _("File"));
 707   gtk_tree_view_column_set_expand (column, TRUE);
 708   gtk_tree_view_column_set_resizable (column, TRUE);
 709   gtk_tree_view_column_set_sort_column_id (column, COL_MESSAGE);
 710   gtk_tree_view_column_set_spacing (column, 3);
 711   gtk_tree_view_insert_column (view, column, -1);
 712
 713   renderer = gtk_cell_renderer_pixbuf_new ();
 714   g_object_set (renderer, "xpad", 3,
 715       "stock-size", GTK_ICON_SIZE_DND, NULL);
 716   gtk_tree_view_column_pack_start (column, renderer, FALSE);
 717   gtk_tree_view_column_set_attributes (column, renderer,
 718       "gicon", COL_ICON, NULL);
 719
 720   renderer = gtk_cell_renderer_text_new ();
 721   g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 722   gtk_tree_view_column_pack_start (column, renderer, TRUE);
 723   gtk_tree_view_column_set_attributes (column, renderer,
 724       "text", COL_MESSAGE, NULL);
 725
 726   /* Remaining time column */
 727   column = gtk_tree_view_column_new ();
 728   gtk_tree_view_column_set_title (column, _("Remaining"));
 729   gtk_tree_view_column_set_sort_column_id (column, COL_REMAINING);
 730   gtk_tree_view_insert_column (view, column, -1);
 731
 732   renderer = gtk_cell_renderer_text_new ();
 733   g_object_set (renderer, "xalign", 0.5, NULL);
 734   gtk_tree_view_column_pack_start (column, renderer, FALSE);
 735   gtk_tree_view_column_set_attributes (column, renderer,
 736       "text", COL_REMAINING, NULL);
 737 }
 738
 739 static void
 740 empathy_ft_manager_finalize (GObject *object)
 741 {
 742   EmpathyFTManager *ft_manager = (EmpathyFTManager *) object;
 743
 744   DEBUG ("%p", object);
 745
 746   g_hash_table_destroy (ft_manager->priv->tp_file_to_row_ref);
 747
 748   if (ft_manager->priv->save_geometry_id != 0)
 749     g_source_remove (ft_manager->priv->save_geometry_id);
 750
 751   G_OBJECT_CLASS (empathy_ft_manager_parent_class)->finalize (object);
 752 }
 753
 754 static void
 755 empathy_ft_manager_init (EmpathyFTManager *ft_manager)
 756 {
 757   EmpathyFTManagerPriv *priv;
 758
 759   priv = G_TYPE_INSTANCE_GET_PRIVATE ((ft_manager), EMPATHY_TYPE_FT_MANAGER,
 760       EmpathyFTManagerPriv);
 761
 762   ft_manager->priv = priv;
 763
 764   priv->tp_file_to_row_ref = g_hash_table_new_full (g_direct_hash,
 765       g_direct_equal, (GDestroyNotify) g_object_unref,
 766       (GDestroyNotify) gtk_tree_row_reference_free);
 767
 768   ft_manager_build_ui (ft_manager);
 769 }
 770
 771 static void
 772 empathy_ft_manager_class_init (EmpathyFTManagerClass *klass)
 773 {
 774   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 775
 776   object_class->finalize = empathy_ft_manager_finalize;
 777
 778   g_type_class_add_private (object_class, sizeof (EmpathyFTManagerPriv));
 779 }
 780
 781 /**
 782  * empathy_ft_manager_get_default:
 783  *
 784  * Returns a new #EmpathyFTManager if there is not already one, or the existing
 785  * one if it exists.
 786  *
 787  * Returns: a #EmpathyFTManager
 788  */
 789 EmpathyFTManager *
 790 empathy_ft_manager_get_default (void)
 791 {
 792   static EmpathyFTManager *manager_p = NULL;
 793
 794   if (!manager_p)
 795     {
 796       manager_p = g_object_new (EMPATHY_TYPE_FT_MANAGER, NULL);
 797       g_object_add_weak_pointer (G_OBJECT (manager_p), (gpointer) &manager_p);
 798     }
 799
 800   return manager_p;
 801 }
 802
 803 /**
 804  * empathy_ft_manager_get_dialog:
 805  * @ft_manager: an #EmpathyFTManager
 806  *
 807  * Returns the #GtkWidget of @ft_manager.
 808  *
 809  * Returns: the dialog
 810  */
 811 GtkWidget *
 812 empathy_ft_manager_get_dialog (EmpathyFTManager *ft_manager)
 813 {
 814   g_return_val_if_fail (EMPATHY_IS_FT_MANAGER (ft_manager), NULL);
 815
 816   return ft_manager->priv->window;
 817 }
 818
 819 typedef struct {
 820   EmpathyFTManager *ft_manager;
 821   EmpathyTpFile *tp_file;
 822 } ReceiveResponseData;
 823
 824 static void
 825 ft_manager_receive_response_data_free (ReceiveResponseData *response_data)
 826 {
 827   if (!response_data)
 828     return;
 829
 830   g_object_unref (response_data->tp_file);
 831   g_object_unref (response_data->ft_manager);
 832   g_slice_free (ReceiveResponseData, response_data);
 833 }
 834
 835 static void
 836 ft_manager_save_dialog_response_cb (GtkDialog *widget,
 837                                     gint response_id,
 838                                     ReceiveResponseData *response_data)
 839 {
 840   if (response_id == GTK_RESPONSE_OK)
 841     {
 842       gchar *uri;
 843       gchar *folder;
 844
 845       uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (widget));
 846
 847       if (uri)
 848         {
 849           GFile *file;
 850           GError *error = NULL;
 851
 852           file = g_file_new_for_uri (uri);
 853           empathy_tp_file_accept (response_data->tp_file, 0, file, &error);
 854
 855           if (error)
 856             {
 857               GtkWidget *dialog;
 858
 859               DEBUG ("Error with opening file to write to: %s",
 860                   error->message ? error->message : "no error");
 861
 862               /* Error is already translated */
 863               dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR,
 864                   GTK_BUTTONS_CLOSE, _("Cannot save file to this location"));
 865
 866               gtk_message_dialog_format_secondary_text (
 867                   GTK_MESSAGE_DIALOG (dialog), "%s",
 868                   error->message);
 869
 870               g_signal_connect (dialog, "response",
 871                   G_CALLBACK (gtk_widget_destroy), NULL);
 872
 873               gtk_widget_show (dialog);
 874
 875               g_error_free (error);
 876               return;
 877             }
 878
 879           g_object_set_data_full (G_OBJECT (response_data->tp_file),
 880               "uri", uri, g_free);
 881
 882           ft_manager_add_tp_file_to_list (response_data->ft_manager,
 883               response_data->tp_file);
 884
 885           g_object_unref (file);
 886         }
 887
 888       folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (widget));
 889       if (folder)
 890         {
 891           empathy_conf_set_string (empathy_conf_get (),
 892               EMPATHY_PREFS_FILE_TRANSFER_DEFAULT_FOLDER,
 893               folder);
 894           g_free (folder);
 895         }
 896     }
 897
 898   gtk_widget_destroy (GTK_WIDGET (widget));
 899   ft_manager_receive_response_data_free (response_data);
 900 }
 901
 902 static void
 903 ft_manager_create_save_dialog (ReceiveResponseData *response_data)
 904 {
 905   GtkWidget *widget;
 906   gchar *folder;
 907
 908   DEBUG ("Creating save file chooser");
 909
 910   widget = gtk_file_chooser_dialog_new (_("Save file as..."),
 911       NULL, GTK_FILE_CHOOSER_ACTION_SAVE,
 912       GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 913       GTK_STOCK_SAVE_AS, GTK_RESPONSE_OK,
 914       NULL);
 915
 916   if (!empathy_conf_get_string (empathy_conf_get (),
 917       EMPATHY_PREFS_FILE_TRANSFER_DEFAULT_FOLDER,
 918       &folder) || !folder)
 919     folder = g_strdup (g_get_user_special_dir (G_USER_DIRECTORY_DOWNLOAD));
 920
 921   if (folder)
 922     gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (widget), folder);
 923
 924   gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (widget),
 925       empathy_tp_file_get_filename (response_data->tp_file));
 926
 927   gtk_dialog_set_default_response (GTK_DIALOG (widget),
 928       GTK_RESPONSE_OK);
 929
 930   gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (widget),
 931       TRUE);
 932
 933   g_signal_connect (widget, "response",
 934       G_CALLBACK (ft_manager_save_dialog_response_cb), response_data);
 935
 936   gtk_widget_show (widget);
 937
 938   g_free (folder);
 939 }
 940
 941 static void
 942 ft_manager_receive_file_response_cb (GtkWidget *dialog,
 943                                      gint response,
 944                                      ReceiveResponseData *response_data)
 945 {
 946   if (response == GTK_RESPONSE_ACCEPT)
 947     ft_manager_create_save_dialog (response_data);
 948   else
 949     {
 950       empathy_tp_file_cancel (response_data->tp_file);
 951       ft_manager_receive_response_data_free (response_data);
 952     }
 953
 954   gtk_widget_destroy (dialog);
 955 }
 956
 957 static void
 958 ft_manager_display_accept_dialog (EmpathyFTManager *ft_manager,
 959                                   EmpathyTpFile *tp_file)
 960 {
 961   GtkWidget *dialog;
 962   GtkWidget *image;
 963   GtkWidget *button;
 964   const gchar *contact_name;
 965   const gchar *filename;
 966   guint64 size;
 967   gchar *size_str;
 968   ReceiveResponseData *response_data;
 969
 970   g_return_if_fail (EMPATHY_IS_FT_MANAGER (ft_manager));
 971   g_return_if_fail (EMPATHY_IS_TP_FILE (tp_file));
 972
 973   DEBUG ("Creating accept dialog");
 974
 975   contact_name = empathy_contact_get_name (empathy_tp_file_get_contact (tp_file));
 976   filename = empathy_tp_file_get_filename (tp_file);
 977
 978   size = empathy_tp_file_get_size (tp_file);
 979   if (size == EMPATHY_TP_FILE_UNKNOWN_SIZE)
 980     size_str = g_strdup (_("unknown size"));
 981   else
 982     size_str = g_format_size_for_display (size);
 983
 984   dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_INFO,
 985       GTK_BUTTONS_NONE,
 986       _("%s would like to send you a file"),
 987       contact_name);
 988
 989   gtk_message_dialog_format_secondary_text
 990       (GTK_MESSAGE_DIALOG (dialog),
 991        _("Do you want to accept the file \"%s\" (%s)?"),
 992        filename, size_str);
 993
 994   /* Icon */
 995   image = gtk_image_new_from_stock (GTK_STOCK_SAVE, GTK_ICON_SIZE_DIALOG);
 996   gtk_widget_show (image);
 997   gtk_message_dialog_set_image (GTK_MESSAGE_DIALOG (dialog), image);
 998
 999   /* Decline button */
1000   button = gtk_button_new_with_mnemonic (_("_Decline"));
1001   gtk_button_set_image (GTK_BUTTON (button),
1002       gtk_image_new_from_stock (GTK_STOCK_CANCEL,
1003           GTK_ICON_SIZE_BUTTON));
1004   gtk_widget_show (button);
1005   gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button,
1006       GTK_RESPONSE_REJECT);
1007
1008   /* Accept button */
1009   button = gtk_button_new_with_mnemonic (_("_Accept"));
1010   gtk_button_set_image (GTK_BUTTON (button),
1011       gtk_image_new_from_stock (GTK_STOCK_SAVE,
1012           GTK_ICON_SIZE_BUTTON));
1013   gtk_widget_show (button);
1014   gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button,
1015       GTK_RESPONSE_ACCEPT);
1016   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1017   gtk_widget_grab_default (button);
1018
1019   response_data = g_slice_new0 (ReceiveResponseData);
1020   response_data->ft_manager = g_object_ref (ft_manager);
1021   response_data->tp_file = g_object_ref (tp_file);
1022
1023   g_signal_connect (dialog, "response",
1024       G_CALLBACK (ft_manager_receive_file_response_cb), response_data);
1025
1026   gtk_widget_show (dialog);
1027
1028   g_free (size_str);
1029 }
1030
1031 /**
1032  * empathy_ft_manager_add_tp_file:
1033  * @ft_manager: an #EmpathyFTManager
1034  * @ft: an #EmpathyFT
1035  *
1036  * Adds a file transfer to the file transfer manager dialog @ft_manager.
1037  * The manager dialog then shows the progress and other information about
1038  * @ft.
1039  */
1040 void
1041 empathy_ft_manager_add_tp_file (EmpathyFTManager *ft_manager,
1042                                 EmpathyTpFile *tp_file)
1043 {
1044   EmpFileTransferState state;
1045
1046   g_return_if_fail (EMPATHY_IS_FT_MANAGER (ft_manager));
1047   g_return_if_fail (EMPATHY_IS_TP_FILE (tp_file));
1048
1049   state = empathy_tp_file_get_state (tp_file, NULL);
1050
1051   DEBUG ("Adding a file transfer: contact=%s, filename=%s, state=%d",
1052       empathy_contact_get_name (empathy_tp_file_get_contact (tp_file)),
1053       empathy_tp_file_get_filename (tp_file), state);
1054
1055   if (state == EMP_FILE_TRANSFER_STATE_PENDING &&
1056       empathy_tp_file_is_incoming (tp_file))
1057     ft_manager_display_accept_dialog (ft_manager, tp_file);
1058   else
1059     ft_manager_add_tp_file_to_list (ft_manager, tp_file);
1060 }
1061