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
  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 #include "extensions/extensions.h"
  50
  51 /**
  52  * SECTION:empathy-ft-manager
  53  * @short_description: File transfer dialog
  54  * @see_also: #EmpathyTpFile, empathy_dispatcher_send_file()
  55  * @include: libempthy-gtk/empathy-ft-manager.h
  56  *
  57  * The #EmpathyFTManager object represents the file transfer dialog,
  58  * it can show multiple file transfers at the same time (added
  59  * with empathy_ft_manager_add_tp_file()).
  60  */
  61
  62 enum
  63 {
  64   COL_PERCENT,
  65   COL_ICON,
  66   COL_MESSAGE,
  67   COL_REMAINING,
  68   COL_FT_OBJECT
  69 };
  70
  71 /**
  72  * EmpathyFTManagerPriv:
  73  *
  74  * Private fields of the #EmpathyFTManager class.
  75  */
  76 typedef struct {
  77   GtkTreeModel *model;
  78   GHashTable *ft_handler_to_row_ref;
  79   GHashTable *cancellable_refs;
  80
  81   /* Widgets */
  82   GtkWidget *window;
  83   GtkWidget *treeview;
  84   GtkWidget *open_button;
  85   GtkWidget *abort_button;
  86
  87   guint save_geometry_id;
  88 } EmpathyFTManagerPriv;
  89
  90 enum
  91 {
  92   RESPONSE_OPEN  = 1,
  93   RESPONSE_STOP  = 2,
  94   RESPONSE_CLEAR = 3
  95 };
  96
  97 G_DEFINE_TYPE (EmpathyFTManager, empathy_ft_manager, G_TYPE_OBJECT);
  98
  99 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyFTManager)
 100
 101 static EmpathyFTManager *manager_singleton = NULL;
 102
 103 #if 0
 104 static gchar *
 105 ft_manager_format_interval (gint interval)
 106 {
 107   gint hours, mins, secs;
 108
 109   hours = interval / 3600;
 110   interval -= hours * 3600;
 111   mins = interval / 60;
 112   interval -= mins * 60;
 113   secs = interval;
 114
 115   if (hours > 0)
 116     /* Translators: time left, when it is more than one hour */
 117     return g_strdup_printf (_("%u:%02u.%02u"), hours, mins, secs);
 118   else
 119     /* Translators: time left, when is is less than one hour */
 120     return g_strdup_printf (_("%02u.%02u"), mins, secs);
 121 }
 122 #endif
 123
 124 static void
 125 ft_manager_update_buttons (EmpathyFTManager *manager)
 126 {
 127   GtkTreeSelection *selection;
 128   GtkTreeModel *model;
 129   GtkTreeIter iter;
 130 <<<<<<< HEAD:src/empathy-ft-manager.c
 131   EmpathyTpFile *tp_file;
 132   TpFileTransferState state;
 133 =======
 134   EmpathyFTHandler *handler;
 135 >>>>>>> Use the proper TP interface instead of emp_cli:src/empathy-ft-manager.c
 136   gboolean open_enabled = FALSE;
 137   gboolean abort_enabled = FALSE;
 138   gboolean is_completed, is_cancelled;
 139   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 140
 141   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
 142
 143   if (gtk_tree_selection_get_selected (selection, &model, &iter))
 144     {
 145       gtk_tree_model_get (model, &iter, COL_FT_OBJECT, &handler, -1);
 146
 147       is_completed = empathy_ft_handler_is_completed (handler);
 148       is_cancelled = empathy_ft_handler_is_cancelled (handler);
 149
 150       /* I can open the file if the transfer is completed and was incoming */
 151 <<<<<<< HEAD:src/empathy-ft-manager.c
 152       open_enabled = (state == TP_FILE_TRANSFER_STATE_COMPLETED &&
 153         empathy_tp_file_is_incoming (tp_file));
 154
 155       /* I can abort if the transfer is not already finished */
 156       abort_enabled = (state != TP_FILE_TRANSFER_STATE_CANCELLED &&
 157         state != TP_FILE_TRANSFER_STATE_COMPLETED);
 158 =======
 159       open_enabled = (is_completed && empathy_ft_handler_is_incoming (handler));
 160
 161       /* I can abort if the transfer is not already finished */
 162       abort_enabled = (is_cancelled == FALSE && is_completed == FALSE);
 163 >>>>>>> Use the proper TP interface instead of emp_cli:src/empathy-ft-manager.c
 164
 165       g_object_unref (handler);
 166     }
 167
 168   gtk_widget_set_sensitive (priv->open_button, open_enabled);
 169   gtk_widget_set_sensitive (priv->abort_button, abort_enabled);
 170 }
 171
 172 #if 0
 173 static const gchar *
 174 ft_manager_state_change_reason_to_string (TpFileTransferStateChangeReason reason)
 175 {
 176   switch (reason)
 177     {
 178       case TP_FILE_TRANSFER_STATE_CHANGE_REASON_NONE:
 179         return _("No reason was specified");
 180       case TP_FILE_TRANSFER_STATE_CHANGE_REASON_REQUESTED:
 181         return _("The change in state was requested");
 182       case TP_FILE_TRANSFER_STATE_CHANGE_REASON_LOCAL_STOPPED:
 183         return _("You canceled the file transfer");
 184       case TP_FILE_TRANSFER_STATE_CHANGE_REASON_REMOTE_STOPPED:
 185         return _("The other participant canceled the file transfer");
 186       case TP_FILE_TRANSFER_STATE_CHANGE_REASON_LOCAL_ERROR:
 187         return _("Error while trying to transfer the file");
 188       case TP_FILE_TRANSFER_STATE_CHANGE_REASON_REMOTE_ERROR:
 189         return _("The other participant is unable to transfer the file");
 190     }
 191   return _("Unknown reason");
 192 }
 193 #endif
 194
 195 static void
 196 ft_manager_selection_changed (GtkTreeSelection *selection,
 197                               EmpathyFTManager *manager)
 198 {
 199   ft_manager_update_buttons (manager);
 200 }
 201
 202 static void
 203 ft_manager_progress_cell_data_func (GtkTreeViewColumn *col,
 204                                     GtkCellRenderer *renderer,
 205                                     GtkTreeModel *model,
 206                                     GtkTreeIter *iter,
 207                                     gpointer user_data)
 208 {
 209   const gchar *text = NULL;
 210   gint percent;
 211
 212   gtk_tree_model_get (model, iter, COL_PERCENT, &percent, -1);
 213
 214   if (percent < 0)
 215     {
 216       percent = 0;
 217       text = C_("file transfer percent", "Unknown");
 218     }
 219
 220   g_object_set (renderer, "text", text, "value", percent, NULL);
 221 }
 222
 223 static GtkTreeRowReference *
 224 ft_manager_get_row_from_handler (EmpathyFTManager *manager,
 225                                  EmpathyFTHandler *handler)
 226 {
 227   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 228
 229   return g_hash_table_lookup (priv->ft_handler_to_row_ref, handler);
 230 }
 231
 232 static void
 233 ft_manager_remove_file_from_model (EmpathyFTManager *manager,
 234                                    EmpathyFTHandler *handler)
 235 {
 236   GtkTreeRowReference *row_ref;
 237   GtkTreeSelection *selection;
 238   GtkTreePath *path = NULL;
 239   GtkTreeIter iter;
 240   gboolean update_selection;
 241   GCancellable *cancellable;
 242   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 243
 244   row_ref = ft_manager_get_row_from_handler (manager, handler);
 245   g_return_if_fail (row_ref);
 246
 247   DEBUG ("Removing file transfer from window: contact=%s, filename=%s",
 248       empathy_contact_get_name (empathy_ft_handler_get_contact (handler)),
 249       empathy_ft_handler_get_filename (handler));
 250
 251   /* Get the iter from the row_ref */
 252   path = gtk_tree_row_reference_get_path (row_ref);
 253   gtk_tree_model_get_iter (priv->model, &iter, path);
 254   gtk_tree_path_free (path);
 255
 256   /* We have to update the selection only if we are removing the selected row */
 257   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
 258   update_selection = gtk_tree_selection_iter_is_selected (selection, &iter);
 259
 260   /* Remove tp_file's row. After that iter points to the next row */
 261   if (!gtk_list_store_remove (GTK_LIST_STORE (priv->model), &iter))
 262     {
 263       gint n_row;
 264
 265       /* There is no next row, set iter to the last row */
 266       n_row = gtk_tree_model_iter_n_children (priv->model, NULL);
 267       if (n_row > 0)
 268         gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, n_row - 1);
 269       else
 270         update_selection = FALSE;
 271     }
 272
 273   if (update_selection)
 274     gtk_tree_selection_select_iter (selection, &iter);
 275
 276   cancellable = g_hash_table_lookup (priv->cancellable_refs, handler);
 277
 278   if (cancellable != NULL) {
 279     g_cancellable_cancel (cancellable);
 280   }
 281 }
 282
 283 static gboolean
 284 remove_finished_transfer_foreach (gpointer key,
 285                                   gpointer value,
 286                                   gpointer user_data)
 287 {
 288   EmpathyFTHandler *handler = key;
 289   EmpathyFTManager *manager = user_data;
 290
 291   if (empathy_ft_handler_is_completed (handler) ||
 292       empathy_ft_handler_is_cancelled (handler))
 293     {
 294       ft_manager_remove_file_from_model (manager, handler);
 295       return TRUE;
 296     }
 297
 298   return FALSE;
 299 }
 300
 301 static char *
 302 ft_manager_format_progress_bytes_and_percentage (guint64 current,
 303                                                  guint64 total,
 304                                                  int *percentage)
 305 {
 306   char *total_str, *current_str, *retval;
 307
 308   total_str = g_format_size_for_display (total);
 309   current_str = g_format_size_for_display (current);
 310
 311   /* translators: first %s is the currently processed size, second %s is
 312    * the total file size */
 313   retval = g_strdup_printf (_("%s of %s"), current_str, total_str);
 314
 315   g_free (total_str);
 316   g_free (current_str);
 317
 318   if (percentage != NULL)
 319     {
 320       if (total != 0)
 321         *percentage = current * 100 / total;
 322       else
 323         *percentage = -1;
 324     }
 325
 326   return retval;
 327 }
 328
 329 static char *
 330 ft_manager_format_contact_info (EmpathyFTHandler *handler)
 331 {
 332   gboolean incoming;
 333   const char *filename, *contact_name, *first_line_format;
 334   char *retval;
 335
 336   incoming = empathy_ft_handler_is_incoming (handler);
 337   contact_name = empathy_contact_get_name
 338     (empathy_ft_handler_get_contact (handler));
 339   filename = empathy_ft_handler_get_filename (handler);
 340
 341   if (incoming)
 342     /* translators: first %s is filename, second %s is the contact name */
 343     first_line_format = _("Receiving \"%s\" from %s");
 344   else
 345     /* translators: first %s is filename, second %s is the contact name */
 346     first_line_format = _("Sending \"%s\" to %s");
 347
 348   retval = g_strdup_printf (first_line_format, filename, contact_name);
 349
 350   return retval;
 351 }
 352
 353 static void
 354 ft_manager_update_handler_message (EmpathyFTManager *manager,
 355                                    GtkTreeRowReference *row_ref,
 356                                    const char *message)
 357 {
 358   GtkTreePath *path;
 359   GtkTreeIter iter;
 360   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 361
 362   /* Set new value in the store */
 363   path = gtk_tree_row_reference_get_path (row_ref);
 364   gtk_tree_model_get_iter (priv->model, &iter, path);
 365   gtk_list_store_set (GTK_LIST_STORE (priv->model),
 366       &iter,
 367       COL_MESSAGE, message ? message : "",
 368       -1);
 369
 370   gtk_tree_path_free (path);
 371 }
 372
 373 static void
 374 ft_manager_update_handler_progress (EmpathyFTManager *manager,
 375                                     GtkTreeRowReference *row_ref,
 376                                     int percentage)
 377 {
 378   GtkTreePath *path;
 379   GtkTreeIter iter;
 380   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 381
 382   /* Set new value in the store */
 383   path = gtk_tree_row_reference_get_path (row_ref);
 384   gtk_tree_model_get_iter (priv->model, &iter, path);
 385   gtk_list_store_set (GTK_LIST_STORE (priv->model),
 386       &iter,
 387       COL_PERCENT, percentage,
 388       -1);
 389
 390   gtk_tree_path_free (path);
 391
 392 }
 393
 394 static void
 395 ft_handler_transfer_error_cb (EmpathyFTHandler *handler,
 396                               GError *error,
 397                               EmpathyFTManager *manager)
 398 {
 399   /* TODO: implement */
 400 }
 401
 402 static void
 403 ft_handler_transfer_done_cb (EmpathyFTHandler *handler,
 404                              EmpathyTpFile *tp_file,
 405                              EmpathyFTManager *manager)
 406 {
 407   const char *contact_name;
 408   const char *filename;
 409   char *first_line, *second_line, *message;
 410   gboolean incoming;
 411   GtkTreeRowReference *row_ref;
 412   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 413
 414   row_ref = ft_manager_get_row_from_handler (manager, handler);
 415   g_return_if_fail (row_ref != NULL);
 416
 417   incoming = empathy_ft_handler_is_incoming (handler);
 418   contact_name = empathy_contact_get_name
 419     (empathy_ft_handler_get_contact (handler));
 420   filename = empathy_ft_handler_get_filename (handler);
 421
 422   if (incoming)
 423     /* translators: first %s is filename, second %s
 424      * is the contact name */
 425     first_line = g_strdup_printf (_("\"%s\" received from %s"), filename,
 426         contact_name);
 427   else
 428     /* translators: first %s is filename, second %s
 429      * is the contact name */
 430     first_line = g_strdup_printf (_("\"%s\" sent to %s"), filename,
 431         contact_name);
 432
 433   second_line = g_strdup (_("File transfer completed"));
 434
 435   message = g_strdup_printf ("%s\n%s", first_line, second_line);
 436   ft_manager_update_handler_message (manager, row_ref, message);
 437
 438   /* remove the cancellable object */
 439   g_hash_table_remove (priv->cancellable_refs, handler);
 440
 441   /* update buttons */
 442   ft_manager_update_buttons (manager);
 443
 444   g_free (message);
 445   g_free (first_line);
 446   g_free (second_line);
 447 }
 448
 449 static void
 450 ft_handler_transfer_progress_cb (EmpathyFTHandler *handler,
 451                                  guint64 current_bytes,
 452                                  guint64 total_bytes,
 453                                  EmpathyFTManager *manager)
 454 {
 455   char *first_line, *second_line, *message;
 456   int percentage;
 457   GtkTreeRowReference *row_ref;
 458
 459   row_ref = ft_manager_get_row_from_handler (manager, handler);
 460   g_return_if_fail (row_ref != NULL);
 461
 462   first_line = ft_manager_format_contact_info (handler);
 463   second_line = ft_manager_format_progress_bytes_and_percentage
 464     (current_bytes, total_bytes, &percentage);
 465
 466   message = g_strdup_printf ("%s\n%s", first_line, second_line);
 467
 468   ft_manager_update_handler_message (manager, row_ref, message);
 469   ft_manager_update_handler_progress (manager, row_ref, percentage);
 470
 471   g_free (message);
 472 }
 473
 474 static void
 475 ft_handler_transfer_started_cb (EmpathyFTHandler *handler,
 476                                 EmpathyTpFile *tp_file,
 477                                 EmpathyFTManager *manager)
 478 {
 479   guint64 transferred_bytes, total_bytes;
 480
 481   g_signal_connect (handler, "transfer-progress",
 482       G_CALLBACK (ft_handler_transfer_progress_cb), manager);
 483   g_signal_connect (handler, "transfer-done",
 484       G_CALLBACK (ft_handler_transfer_done_cb), manager);
 485
 486   transferred_bytes = empathy_ft_handler_get_transferred_bytes (handler);
 487   total_bytes = empathy_ft_handler_get_total_bytes (handler);
 488
 489   ft_handler_transfer_progress_cb (handler, transferred_bytes, total_bytes,
 490       manager);
 491 }
 492
 493 static void
 494 ft_handler_hashing_done_cb (EmpathyFTHandler *handler,
 495                             EmpathyFTManager *manager)
 496 {
 497   g_signal_connect (handler, "transfer-started",
 498       G_CALLBACK (ft_handler_transfer_started_cb), manager);
 499 }
 500
 501 static void
 502 ft_handler_hashing_progress_cb (EmpathyFTHandler *handler,
 503                                 guint64 current_bytes,
 504                                 guint64 total_bytes,
 505                                 EmpathyFTManager *manager)
 506 {
 507   char *first_line, *second_line, *message;
 508   GtkTreeRowReference *row_ref;
 509
 510   row_ref = ft_manager_get_row_from_handler (manager, handler);
 511   g_return_if_fail (row_ref != NULL);
 512
 513   first_line =  g_strdup_printf (_("Hashing \"%s\""),
 514       empathy_ft_handler_get_filename (handler));
 515   second_line = ft_manager_format_progress_bytes_and_percentage
 516     (current_bytes, total_bytes, NULL);
 517
 518   message = g_strdup_printf ("%s\n%s", first_line, second_line);
 519
 520   ft_manager_update_handler_message (manager, row_ref, message);
 521
 522   g_free (message);
 523 }
 524
 525 static void
 526 ft_handler_hashing_started_cb (EmpathyFTHandler *handler,
 527                                EmpathyFTManager *manager)
 528 {
 529   char *message;
 530   GtkTreeRowReference *row_ref;
 531
 532   g_signal_connect (handler, "hashing-progress",
 533      G_CALLBACK (ft_handler_hashing_progress_cb), manager);
 534   g_signal_connect (handler, "hashing-done",
 535      G_CALLBACK (ft_handler_hashing_done_cb), manager);
 536
 537   row_ref = ft_manager_get_row_from_handler (manager, handler);
 538   g_return_if_fail (row_ref != NULL);
 539
 540   message =  g_strdup_printf (_("Hashing \"%s\""),
 541       empathy_ft_handler_get_filename (handler));
 542
 543   ft_manager_update_handler_message (manager, row_ref, message);
 544
 545   g_free (message);
 546 }
 547
 548 static void
 549 ft_manager_start_transfer (EmpathyFTManager *manager,
 550                            EmpathyFTHandler *handler)
 551 {
 552   GCancellable *cancellable;
 553   EmpathyFTManagerPriv *priv;
 554
 555   priv = GET_PRIV (manager);
 556
 557   cancellable = g_cancellable_new ();
 558   g_hash_table_insert (priv->cancellable_refs, g_object_ref (handler),
 559       cancellable);
 560
 561   /* now connect the signals */
 562   g_signal_connect (handler, "transfer-error",
 563       G_CALLBACK (ft_handler_transfer_error_cb), manager);
 564
 565   if (empathy_ft_handler_is_incoming (handler)) {
 566     g_signal_connect (handler, "hashing-started",
 567         G_CALLBACK (ft_handler_hashing_started_cb), manager);
 568   } else {
 569     g_signal_connect (handler, "transfer-started",
 570         G_CALLBACK (ft_handler_transfer_started_cb), manager);
 571   }
 572
 573   empathy_ft_handler_start_transfer (handler, cancellable);
 574 }
 575
 576 static void
 577 ft_manager_add_handler_to_list (EmpathyFTManager *manager,
 578                                 EmpathyFTHandler *handler)
 579 {
 580   GtkTreeRowReference *row_ref;
 581   GtkTreeIter iter;
 582   GtkTreeSelection *selection;
 583   GtkTreePath *path;
 584   GIcon *icon;
 585   const char *content_type;
 586   char *first_line, *second_line, *message;
 587   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 588
 589   /* get the icon name from the mime-type of the file. */
 590   content_type = empathy_ft_handler_get_content_type (handler);
 591   icon = g_content_type_get_icon (content_type);
 592
 593   /* append the handler in the store */
 594   gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->model),
 595       &iter, G_MAXINT, COL_FT_OBJECT, handler, COL_ICON, icon, -1);
 596   g_object_unref (icon);
 597
 598   /* insert the new row_ref in the hash table  */
 599   path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->model), &iter);
 600   row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (priv->model), path);
 601   gtk_tree_path_free (path);
 602   g_hash_table_insert (priv->ft_handler_to_row_ref, g_object_ref (handler),
 603       row_ref);
 604
 605   /* select the new row */
 606   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
 607   gtk_tree_selection_select_iter (selection, &iter);
 608
 609   /* hook up the signals and start the transfer */
 610   ft_manager_start_transfer (manager, handler);
 611
 612   /* update the row with the initial values */
 613   first_line = ft_manager_format_contact_info (handler);
 614   second_line = g_strdup (_("Waiting for the other participant's response"));
 615   message = g_strdup_printf ("%s\n%s", first_line, second_line);
 616
 617   ft_manager_update_handler_message (manager, row_ref, message);
 618
 619   g_free (first_line);
 620   g_free (second_line);
 621   g_free (message);
 622 }
 623
 624 static void
 625 ft_manager_clear (EmpathyFTManager *manager)
 626 {
 627   EmpathyFTManagerPriv *priv;
 628
 629   DEBUG ("Clearing file transfer list");
 630
 631   priv = GET_PRIV (manager);
 632
 633   /* Remove completed and cancelled transfers */
 634   g_hash_table_foreach_remove (priv->ft_handler_to_row_ref,
 635       remove_finished_transfer_foreach, manager);
 636 }
 637
 638 static void
 639 ft_manager_open (EmpathyFTManager *manager)
 640 {
 641   GtkTreeSelection *selection;
 642   GtkTreeIter iter;
 643   GtkTreeModel *model;
 644   EmpathyFTHandler *handler;
 645   char *uri;
 646   GFile *file;
 647   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 648
 649   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
 650
 651   if (!gtk_tree_selection_get_selected (selection, &model, &iter))
 652     return;
 653
 654   gtk_tree_model_get (model, &iter, COL_FT_OBJECT, &handler, -1);
 655
 656   file = empathy_ft_handler_get_gfile (handler);
 657   uri = g_file_get_uri (file);
 658
 659   DEBUG ("Opening URI: %s", uri);
 660   empathy_url_show (GTK_WIDGET (priv->window), uri);
 661
 662   g_object_unref (handler);
 663   g_free (uri);
 664 }
 665
 666 static void
 667 ft_manager_stop (EmpathyFTManager *manager)
 668 {
 669   GtkTreeSelection *selection;
 670   GtkTreeIter iter;
 671   GtkTreeModel *model;
 672   EmpathyFTHandler *handler;
 673   GCancellable *cancellable;
 674   EmpathyFTManagerPriv *priv;
 675
 676   priv = GET_PRIV (manager);
 677
 678   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
 679
 680   if (!gtk_tree_selection_get_selected (selection, &model, &iter))
 681     return;
 682
 683   gtk_tree_model_get (model, &iter, COL_FT_OBJECT, &handler, -1);
 684   g_return_if_fail (handler != NULL);
 685
 686   DEBUG ("Stopping file transfer: contact=%s, filename=%s",
 687       empathy_contact_get_name (empathy_ft_handler_get_contact (handler)),
 688       empathy_ft_handler_get_filename (handler));
 689
 690   cancellable = g_hash_table_lookup (priv->cancellable_refs, handler);
 691   g_assert (cancellable != NULL);
 692
 693   g_cancellable_cancel (cancellable);
 694 }
 695
 696 static gboolean
 697 ft_manager_save_geometry_timeout_cb (EmpathyFTManager *manager)
 698 {
 699   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 700   gint x, y, w, h;
 701
 702   gtk_window_get_size (GTK_WINDOW (priv->window), &w, &h);
 703   gtk_window_get_position (GTK_WINDOW (priv->window), &x, &y);
 704
 705   empathy_geometry_save ("ft-manager", x, y, w, h);
 706
 707   priv->save_geometry_id = 0;
 708
 709   return FALSE;
 710 }
 711
 712 static gboolean
 713 ft_manager_configure_event_cb (GtkWidget *widget,
 714                                GdkEventConfigure *event,
 715                                EmpathyFTManager *manager)
 716 {
 717   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 718
 719   if (priv->save_geometry_id != 0)
 720     g_source_remove (priv->save_geometry_id);
 721
 722   priv->save_geometry_id = g_timeout_add (500,
 723       (GSourceFunc) ft_manager_save_geometry_timeout_cb, manager);
 724
 725   return FALSE;
 726 }
 727
 728 static void
 729 ft_manager_response_cb (GtkWidget *widget,
 730                         gint response,
 731                         EmpathyFTManager *manager)
 732 {
 733   switch (response)
 734     {
 735       case RESPONSE_CLEAR:
 736         ft_manager_clear (manager);
 737         break;
 738       case RESPONSE_OPEN:
 739         ft_manager_open (manager);
 740         break;
 741       case RESPONSE_STOP:
 742         ft_manager_stop (manager);
 743         break;
 744     }
 745 }
 746
 747 static gboolean
 748 ft_manager_delete_event_cb (GtkWidget *widget,
 749                             GdkEvent *event,
 750                             EmpathyFTManager *manager)
 751 {
 752   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 753
 754   /* remove all the completed/cancelled/errored transfers */
 755   ft_manager_clear (manager);
 756
 757   if (g_hash_table_size (priv->ft_handler_to_row_ref) > 0)
 758     {
 759       /* There is still FTs on flight, just hide the window */
 760       DEBUG ("Hiding window");
 761       gtk_widget_hide (widget);
 762       return TRUE;
 763     }
 764
 765   return FALSE;
 766 }
 767
 768 static void
 769 ft_manager_destroy_cb (GtkWidget *widget,
 770                        EmpathyFTManager *manager)
 771 {
 772   g_object_unref (manager);
 773 }
 774
 775 static void
 776 ft_manager_build_ui (EmpathyFTManager *manager)
 777 {
 778   GtkBuilder *gui;
 779   gint x, y, w, h;
 780   GtkTreeView *view;
 781   GtkListStore *liststore;
 782   GtkTreeViewColumn *column;
 783   GtkCellRenderer *renderer;
 784   GtkTreeSelection *selection;
 785   gchar *filename;
 786   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 787
 788   filename = empathy_file_lookup ("empathy-ft-manager.ui", "src");
 789   gui = empathy_builder_get_file (filename,
 790       "ft_manager_dialog", &priv->window,
 791       "ft_list", &priv->treeview,
 792       "open_button", &priv->open_button,
 793       "abort_button", &priv->abort_button,
 794       NULL);
 795   g_free (filename);
 796
 797   empathy_builder_connect (gui, manager,
 798       "ft_manager_dialog", "destroy", ft_manager_destroy_cb,
 799       "ft_manager_dialog", "response", ft_manager_response_cb,
 800       "ft_manager_dialog", "delete-event", ft_manager_delete_event_cb,
 801       "ft_manager_dialog", "configure-event", ft_manager_configure_event_cb,
 802       NULL);
 803
 804   g_object_unref (gui);
 805
 806   /* Window geometry. */
 807   empathy_geometry_load ("ft-manager", &x, &y, &w, &h);
 808
 809   if (x >= 0 && y >= 0)
 810     {
 811       /* Let the window manager position it if we don't have
 812        * good x, y coordinates. */
 813       gtk_window_move (GTK_WINDOW (priv->window), x, y);
 814     }
 815
 816   if (w > 0 && h > 0)
 817     {
 818       /* Use the defaults from the ui file if we don't have
 819        * good w, h geometry. */
 820       gtk_window_resize (GTK_WINDOW (priv->window), w, h);
 821     }
 822
 823   /* Setup the tree view */
 824   view = GTK_TREE_VIEW (priv->treeview);
 825   selection = gtk_tree_view_get_selection (view);
 826   gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
 827   g_signal_connect (selection, "changed",
 828       G_CALLBACK (ft_manager_selection_changed), manager);
 829   gtk_tree_view_set_headers_visible (view, TRUE);
 830   gtk_tree_view_set_enable_search (view, FALSE);
 831
 832   /* Setup the model */
 833   liststore = gtk_list_store_new (5,
 834       G_TYPE_INT,     /* percent */
 835       G_TYPE_ICON,    /* icon */
 836       G_TYPE_STRING,  /* message */
 837       G_TYPE_STRING,  /* remaining */
 838       G_TYPE_OBJECT); /* ft_handler */
 839   gtk_tree_view_set_model (view, GTK_TREE_MODEL (liststore));
 840   priv->model = GTK_TREE_MODEL (liststore);
 841   g_object_unref (liststore);
 842
 843   /* Progress column */
 844   column = gtk_tree_view_column_new ();
 845   gtk_tree_view_column_set_title (column, _("%"));
 846   gtk_tree_view_column_set_sort_column_id (column, COL_PERCENT);
 847   gtk_tree_view_insert_column (view, column, -1);
 848
 849   renderer = gtk_cell_renderer_progress_new ();
 850   g_object_set (renderer, "xalign", 0.5, NULL);
 851   gtk_tree_view_column_pack_start (column, renderer, FALSE);
 852   gtk_tree_view_column_set_cell_data_func (column, renderer,
 853       ft_manager_progress_cell_data_func, NULL, NULL);
 854
 855   /* Icon and filename column*/
 856   column = gtk_tree_view_column_new ();
 857   gtk_tree_view_column_set_title (column, _("File"));
 858   gtk_tree_view_column_set_expand (column, TRUE);
 859   gtk_tree_view_column_set_resizable (column, TRUE);
 860   gtk_tree_view_column_set_sort_column_id (column, COL_MESSAGE);
 861   gtk_tree_view_column_set_spacing (column, 3);
 862   gtk_tree_view_insert_column (view, column, -1);
 863
 864   renderer = gtk_cell_renderer_pixbuf_new ();
 865   g_object_set (renderer, "xpad", 3,
 866       "stock-size", GTK_ICON_SIZE_DND, NULL);
 867   gtk_tree_view_column_pack_start (column, renderer, FALSE);
 868   gtk_tree_view_column_set_attributes (column, renderer,
 869       "gicon", COL_ICON, NULL);
 870
 871   renderer = gtk_cell_renderer_text_new ();
 872   g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 873   gtk_tree_view_column_pack_start (column, renderer, TRUE);
 874   gtk_tree_view_column_set_attributes (column, renderer,
 875       "text", COL_MESSAGE, NULL);
 876
 877   /* Remaining time column */
 878   column = gtk_tree_view_column_new ();
 879   gtk_tree_view_column_set_title (column, _("Remaining"));
 880   gtk_tree_view_column_set_sort_column_id (column, COL_REMAINING);
 881   gtk_tree_view_insert_column (view, column, -1);
 882
 883   renderer = gtk_cell_renderer_text_new ();
 884   g_object_set (renderer, "xalign", 0.5, NULL);
 885   gtk_tree_view_column_pack_start (column, renderer, FALSE);
 886   gtk_tree_view_column_set_attributes (column, renderer,
 887       "text", COL_REMAINING, NULL);
 888 }
 889
 890 /* GObject method overrides */
 891
 892 static void
 893 empathy_ft_manager_finalize (GObject *object)
 894 {
 895   EmpathyFTManagerPriv *priv = GET_PRIV (object);
 896
 897   DEBUG ("%p", object);
 898
 899   g_hash_table_destroy (priv->ft_handler_to_row_ref);
 900
 901   if (priv->save_geometry_id != 0)
 902     g_source_remove (priv->save_geometry_id);
 903
 904   G_OBJECT_CLASS (empathy_ft_manager_parent_class)->finalize (object);
 905 }
 906
 907 static void
 908 empathy_ft_manager_init (EmpathyFTManager *manager)
 909 {
 910   EmpathyFTManagerPriv *priv;
 911
 912   priv = G_TYPE_INSTANCE_GET_PRIVATE ((manager), EMPATHY_TYPE_FT_MANAGER,
 913       EmpathyFTManagerPriv);
 914
 915   manager->priv = priv;
 916
 917   priv->ft_handler_to_row_ref = g_hash_table_new_full (g_direct_hash,
 918       g_direct_equal, (GDestroyNotify) g_object_unref,
 919       (GDestroyNotify) gtk_tree_row_reference_free);
 920   priv->cancellable_refs = g_hash_table_new_full (g_direct_hash, g_direct_equal,
 921       (GDestroyNotify) g_object_unref, (GDestroyNotify) g_object_unref);
 922
 923   ft_manager_build_ui (manager);
 924 }
 925
 926 static GObject *
 927 empathy_ft_manager_constructor (GType type,
 928                                 guint n_props,
 929                                 GObjectConstructParam *props)
 930 {
 931   GObject *retval;
 932
 933   if (manager_singleton)
 934     {
 935       retval = g_object_ref (manager_singleton);
 936     }
 937   else
 938     {
 939       retval = G_OBJECT_CLASS (empathy_ft_manager_parent_class)->constructor
 940           (type, n_props, props);
 941
 942       manager_singleton = EMPATHY_FT_MANAGER (retval);
 943       g_object_add_weak_pointer (retval, (gpointer) &manager_singleton);
 944     }
 945
 946   return retval;
 947 }
 948
 949 static void
 950 empathy_ft_manager_class_init (EmpathyFTManagerClass *klass)
 951 {
 952   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 953
 954   object_class->finalize = empathy_ft_manager_finalize;
 955   object_class->constructor = empathy_ft_manager_constructor;
 956
 957   g_type_class_add_private (object_class, sizeof (EmpathyFTManagerPriv));
 958 }
 959
 960 /* public methods */
 961
 962 /**
 963  * empathy_ft_manager_dup_singleton:
 964  *
 965  * Returns a reference to the #EmpathyFTManager singleton object.
 966  *
 967  * Returns: a #EmpathyFTManager
 968  */
 969 EmpathyFTManager *
 970 empathy_ft_manager_dup_singleton (void)
 971 {
 972   return g_object_new (EMPATHY_TYPE_FT_MANAGER, NULL);
 973 }
 974
 975 void
 976 empathy_ft_manager_add_handler (EmpathyFTManager *manager,
 977                                 EmpathyFTHandler *handler)
 978 {
 979   EmpathyFTManagerPriv *priv = GET_PRIV (manager);
 980
 981   g_return_if_fail (EMPATHY_IS_FT_MANAGER (manager));
 982   g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
 983
 984   ft_manager_add_handler_to_list (manager, handler);
 985   gtk_window_present (GTK_WINDOW (priv->window));
 986 }
 987