2 * Copyright (C) 2003, 2004 Xan Lopez
3 * Copyright (C) 2007 Marco Barisione <marco@barisione.org>
4 * Copyright (C) 2008-2009 Collabora Ltd.
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.
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.
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
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>
28 /* The original file transfer manager code was copied from Epiphany */
31 #include "empathy-ft-manager.h"
33 #include <glib/gi18n.h>
35 #include "empathy-geometry.h"
36 #include "empathy-ui-utils.h"
37 #include "empathy-utils.h"
39 #define DEBUG_FLAG EMPATHY_DEBUG_FT
40 #include "empathy-debug.h"
53 GHashTable *ft_handler_to_row_ref;
58 GtkWidget *open_button;
59 GtkWidget *abort_button;
60 GtkWidget *clear_button;
61 } EmpathyFTManagerPriv;
71 G_DEFINE_TYPE (EmpathyFTManager, empathy_ft_manager, G_TYPE_OBJECT);
73 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyFTManager)
75 static EmpathyFTManager *manager_singleton = NULL;
77 static void ft_handler_hashing_started_cb (EmpathyFTHandler *handler,
78 EmpathyFTManager *manager);
81 ft_manager_format_interval (guint interval)
83 gint hours, mins, secs;
85 hours = interval / 3600;
86 interval -= hours * 3600;
88 interval -= mins * 60;
92 /* Translators: time left, when it is more than one hour */
93 return g_strdup_printf (_("%u:%02u.%02u"), hours, mins, secs);
95 /* Translators: time left, when is is less than one hour */
96 return g_strdup_printf (_("%02u.%02u"), mins, secs);
100 ft_manager_update_buttons (EmpathyFTManager *manager)
102 GtkTreeSelection *selection;
105 EmpathyFTHandler *handler;
106 gboolean open_enabled = FALSE;
107 gboolean abort_enabled = FALSE;
108 gboolean clear_enabled = FALSE;
109 gboolean is_completed, is_cancelled;
110 GHashTableIter hash_iter;
111 EmpathyFTManagerPriv *priv = GET_PRIV (manager);
113 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
115 if (gtk_tree_selection_get_selected (selection, &model, &iter))
117 gtk_tree_model_get (model, &iter, COL_FT_OBJECT, &handler, -1);
119 is_completed = empathy_ft_handler_is_completed (handler);
120 is_cancelled = empathy_ft_handler_is_cancelled (handler);
122 /* I can open the file if the transfer is completed and was incoming */
123 open_enabled = (is_completed && empathy_ft_handler_is_incoming (handler));
125 /* I can abort if the transfer is not already finished */
126 abort_enabled = (is_cancelled == FALSE && is_completed == FALSE);
128 g_object_unref (handler);
131 g_hash_table_iter_init (&hash_iter, priv->ft_handler_to_row_ref);
133 while (g_hash_table_iter_next (&hash_iter, (gpointer *) &handler, NULL))
135 if (empathy_ft_handler_is_completed (handler) ||
136 empathy_ft_handler_is_cancelled (handler))
137 clear_enabled = TRUE;
143 gtk_widget_set_sensitive (priv->open_button, open_enabled);
144 gtk_widget_set_sensitive (priv->abort_button, abort_enabled);
147 gtk_widget_set_sensitive (priv->clear_button, TRUE);
151 ft_manager_selection_changed (GtkTreeSelection *selection,
152 EmpathyFTManager *manager)
154 ft_manager_update_buttons (manager);
158 ft_manager_progress_cell_data_func (GtkTreeViewColumn *col,
159 GtkCellRenderer *renderer,
164 const gchar *text = NULL;
167 gtk_tree_model_get (model, iter, COL_PERCENT, &percent, -1);
172 text = C_("file transfer percent", "Unknown");
175 g_object_set (renderer, "text", text, "value", percent, NULL);
178 static GtkTreeRowReference *
179 ft_manager_get_row_from_handler (EmpathyFTManager *manager,
180 EmpathyFTHandler *handler)
182 EmpathyFTManagerPriv *priv = GET_PRIV (manager);
184 return g_hash_table_lookup (priv->ft_handler_to_row_ref, handler);
188 ft_manager_remove_file_from_model (EmpathyFTManager *manager,
189 EmpathyFTHandler *handler)
191 GtkTreeRowReference *row_ref;
192 GtkTreeSelection *selection;
193 GtkTreePath *path = NULL;
195 gboolean update_selection;
196 EmpathyFTManagerPriv *priv = GET_PRIV (manager);
198 row_ref = ft_manager_get_row_from_handler (manager, handler);
199 g_return_if_fail (row_ref);
201 DEBUG ("Removing file transfer from window: contact=%s, filename=%s",
202 empathy_contact_get_alias (empathy_ft_handler_get_contact (handler)),
203 empathy_ft_handler_get_filename (handler));
205 /* Get the iter from the row_ref */
206 path = gtk_tree_row_reference_get_path (row_ref);
207 gtk_tree_model_get_iter (priv->model, &iter, path);
208 gtk_tree_path_free (path);
210 /* We have to update the selection only if we are removing the selected row */
211 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
212 update_selection = gtk_tree_selection_iter_is_selected (selection, &iter);
214 /* Remove tp_file's row. After that iter points to the next row */
215 if (!gtk_list_store_remove (GTK_LIST_STORE (priv->model), &iter))
219 /* There is no next row, set iter to the last row */
220 n_row = gtk_tree_model_iter_n_children (priv->model, NULL);
222 gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, n_row - 1);
224 update_selection = FALSE;
227 if (update_selection)
228 gtk_tree_selection_select_iter (selection, &iter);
232 remove_finished_transfer_foreach (gpointer key,
236 EmpathyFTHandler *handler = key;
237 EmpathyFTManager *manager = user_data;
239 if (empathy_ft_handler_is_completed (handler) ||
240 empathy_ft_handler_is_cancelled (handler))
242 ft_manager_remove_file_from_model (manager, handler);
250 ft_manager_format_progress_bytes_and_percentage (guint64 current,
255 char *total_str, *current_str, *retval;
256 char *speed_str = NULL;
258 total_str = g_format_size (total);
259 current_str = g_format_size (current);
262 speed_str = g_format_size ((goffset) speed);
264 /* translators: first %s is the currently processed size, second %s is
265 * the total file size */
267 g_strdup_printf (_("%s of %s at %s/s"), current_str, total_str, speed_str) :
268 g_strdup_printf (_("%s of %s"), current_str, total_str);
271 g_free (current_str);
274 if (percentage != NULL)
277 *percentage = current * 100 / total;
286 ft_manager_format_contact_info (EmpathyFTHandler *handler)
289 const char *filename, *contact_name, *first_line_format;
292 incoming = empathy_ft_handler_is_incoming (handler);
293 contact_name = empathy_contact_get_alias
294 (empathy_ft_handler_get_contact (handler));
295 filename = empathy_ft_handler_get_filename (handler);
298 /* translators: first %s is filename, second %s is the contact name */
299 first_line_format = _("Receiving \"%s\" from %s");
301 /* translators: first %s is filename, second %s is the contact name */
302 first_line_format = _("Sending \"%s\" to %s");
304 retval = g_strdup_printf (first_line_format, filename, contact_name);
310 ft_manager_format_error_message (EmpathyFTHandler *handler,
313 const char *contact_name, *filename;
314 EmpathyContact *contact;
315 char *first_line, *message;
319 incoming = empathy_ft_handler_is_incoming (handler);
321 contact = empathy_ft_handler_get_contact (handler);
323 contact_name = empathy_contact_get_alias (contact);
325 filename = empathy_ft_handler_get_filename (handler);
328 /* filename/contact_name here are either both NULL or both valid */
329 if (filename && contact_name)
330 /* translators: first %s is filename, second %s
331 * is the contact name */
332 first_line = g_strdup_printf (_("Error receiving \"%s\" from %s"), filename,
335 first_line = g_strdup (_("Error receiving a file"));
337 /* translators: first %s is filename, second %s
338 * is the contact name */
339 if (filename && contact_name)
340 first_line = g_strdup_printf (_("Error sending \"%s\" to %s"), filename,
343 first_line = g_strdup (_("Error sending a file"));
345 message = g_strdup_printf ("%s\n%s", first_line, error->message);
353 ft_manager_update_handler_message (EmpathyFTManager *manager,
354 GtkTreeRowReference *row_ref,
359 EmpathyFTManagerPriv *priv = GET_PRIV (manager);
361 /* Set new value in the store */
362 path = gtk_tree_row_reference_get_path (row_ref);
363 gtk_tree_model_get_iter (priv->model, &iter, path);
364 gtk_list_store_set (GTK_LIST_STORE (priv->model),
366 COL_MESSAGE, message ? message : "",
369 gtk_tree_path_free (path);
373 ft_manager_update_handler_progress (EmpathyFTManager *manager,
374 GtkTreeRowReference *row_ref,
379 EmpathyFTManagerPriv *priv = GET_PRIV (manager);
381 /* Set new value in the store */
382 path = gtk_tree_row_reference_get_path (row_ref);
383 gtk_tree_model_get_iter (priv->model, &iter, path);
384 gtk_list_store_set (GTK_LIST_STORE (priv->model),
386 COL_PERCENT, percentage,
389 gtk_tree_path_free (path);
394 ft_manager_update_handler_time (EmpathyFTManager *manager,
395 GtkTreeRowReference *row_ref,
396 guint remaining_time)
400 EmpathyFTManagerPriv *priv = GET_PRIV (manager);
403 remaining_str = ft_manager_format_interval (remaining_time);
405 /* Set new value in the store */
406 path = gtk_tree_row_reference_get_path (row_ref);
407 gtk_tree_model_get_iter (priv->model, &iter, path);
408 gtk_list_store_set (GTK_LIST_STORE (priv->model),
410 COL_REMAINING, remaining_str,
413 gtk_tree_path_free (path);
414 g_free (remaining_str);
418 ft_manager_clear_handler_time (EmpathyFTManager *manager,
419 GtkTreeRowReference *row_ref)
423 EmpathyFTManagerPriv *priv = GET_PRIV (manager);
425 /* Set new value in the store */
426 path = gtk_tree_row_reference_get_path (row_ref);
427 gtk_tree_model_get_iter (priv->model, &iter, path);
428 gtk_list_store_set (GTK_LIST_STORE (priv->model),
433 gtk_tree_path_free (path);
437 ft_handler_transfer_error_cb (EmpathyFTHandler *handler,
439 EmpathyFTManager *manager)
442 GtkTreeRowReference *row_ref;
444 DEBUG ("Transfer error %s", error->message);
446 row_ref = ft_manager_get_row_from_handler (manager, handler);
447 g_return_if_fail (row_ref != NULL);
449 message = ft_manager_format_error_message (handler, error);
451 ft_manager_update_handler_message (manager, row_ref, message);
452 ft_manager_clear_handler_time (manager, row_ref);
453 ft_manager_update_buttons (manager);
459 do_real_transfer_done (EmpathyFTManager *manager,
460 EmpathyFTHandler *handler)
462 const char *contact_name;
463 const char *filename;
464 char *first_line, *second_line, *message;
467 GtkTreeRowReference *row_ref;
468 GtkRecentManager *recent_manager;
471 row_ref = ft_manager_get_row_from_handler (manager, handler);
472 g_return_if_fail (row_ref != NULL);
474 incoming = empathy_ft_handler_is_incoming (handler);
475 contact_name = empathy_contact_get_alias
476 (empathy_ft_handler_get_contact (handler));
477 filename = empathy_ft_handler_get_filename (handler);
480 /* translators: first %s is filename, second %s
481 * is the contact name */
482 first_line = g_strdup_printf (_("\"%s\" received from %s"), filename,
485 /* translators: first %s is filename, second %s
486 * is the contact name */
487 first_line = g_strdup_printf (_("\"%s\" sent to %s"), filename,
490 second_line = g_strdup (_("File transfer completed"));
492 message = g_strdup_printf ("%s\n%s", first_line, second_line);
493 ft_manager_update_handler_message (manager, row_ref, message);
494 ft_manager_clear_handler_time (manager, row_ref);
497 ft_manager_update_buttons (manager);
501 g_free (second_line);
503 recent_manager = gtk_recent_manager_get_default ();
504 file = empathy_ft_handler_get_gfile (handler);
505 uri = g_file_get_uri (file);
507 gtk_recent_manager_add_item (recent_manager, uri);
513 ft_handler_transfer_done_cb (EmpathyFTHandler *handler,
514 TpFileTransferChannel *channel,
515 EmpathyFTManager *manager)
517 if (empathy_ft_handler_is_incoming (handler) &&
518 empathy_ft_handler_get_use_hash (handler))
520 DEBUG ("Transfer done, waiting for hashing-started");
522 /* connect to the signal and return early */
523 g_signal_connect (handler, "hashing-started",
524 G_CALLBACK (ft_handler_hashing_started_cb), manager);
529 DEBUG ("Transfer done, no hashing");
531 do_real_transfer_done (manager, handler);
535 ft_handler_transfer_progress_cb (EmpathyFTHandler *handler,
536 guint64 current_bytes,
538 guint remaining_time,
540 EmpathyFTManager *manager)
542 char *first_line, *second_line, *message;
544 GtkTreeRowReference *row_ref;
546 DEBUG ("Transfer progress");
548 row_ref = ft_manager_get_row_from_handler (manager, handler);
549 g_return_if_fail (row_ref != NULL);
551 first_line = ft_manager_format_contact_info (handler);
552 second_line = ft_manager_format_progress_bytes_and_percentage
553 (current_bytes, total_bytes, speed, &percentage);
555 message = g_strdup_printf ("%s\n%s", first_line, second_line);
557 ft_manager_update_handler_message (manager, row_ref, message);
558 ft_manager_update_handler_progress (manager, row_ref, percentage);
560 if (remaining_time > 0)
561 ft_manager_update_handler_time (manager, row_ref, remaining_time);
565 g_free (second_line);
569 ft_handler_transfer_started_cb (EmpathyFTHandler *handler,
570 TpFileTransferChannel *channel,
571 EmpathyFTManager *manager)
573 guint64 transferred_bytes, total_bytes;
575 DEBUG ("Transfer started");
577 g_signal_connect (handler, "transfer-progress",
578 G_CALLBACK (ft_handler_transfer_progress_cb), manager);
579 g_signal_connect (handler, "transfer-done",
580 G_CALLBACK (ft_handler_transfer_done_cb), manager);
582 transferred_bytes = empathy_ft_handler_get_transferred_bytes (handler);
583 total_bytes = empathy_ft_handler_get_total_bytes (handler);
585 ft_handler_transfer_progress_cb (handler, transferred_bytes, total_bytes,
590 ft_handler_hashing_done_cb (EmpathyFTHandler *handler,
591 EmpathyFTManager *manager)
593 GtkTreeRowReference *row_ref;
594 char *first_line, *second_line, *message;
596 DEBUG ("Hashing done");
598 /* update the message */
599 if (empathy_ft_handler_is_incoming (handler))
601 do_real_transfer_done (manager, handler);
605 row_ref = ft_manager_get_row_from_handler (manager, handler);
606 g_return_if_fail (row_ref != NULL);
608 first_line = ft_manager_format_contact_info (handler);
609 second_line = g_strdup (_("Waiting for the other participant's response"));
610 message = g_strdup_printf ("%s\n%s", first_line, second_line);
612 ft_manager_update_handler_message (manager, row_ref, message);
616 g_free (second_line);
618 g_signal_connect (handler, "transfer-started",
619 G_CALLBACK (ft_handler_transfer_started_cb), manager);
623 ft_handler_hashing_progress_cb (EmpathyFTHandler *handler,
624 guint64 current_bytes,
626 EmpathyFTManager *manager)
628 char *first_line, *second_line, *message;
629 GtkTreeRowReference *row_ref;
631 row_ref = ft_manager_get_row_from_handler (manager, handler);
632 g_return_if_fail (row_ref != NULL);
634 if (empathy_ft_handler_is_incoming (handler))
635 first_line = g_strdup_printf (_("Checking integrity of \"%s\""),
636 empathy_ft_handler_get_filename (handler));
638 first_line = g_strdup_printf (_("Hashing \"%s\""),
639 empathy_ft_handler_get_filename (handler));
641 second_line = ft_manager_format_progress_bytes_and_percentage
642 (current_bytes, total_bytes, -1, NULL);
644 message = g_strdup_printf ("%s\n%s", first_line, second_line);
646 ft_manager_update_handler_message (manager, row_ref, message);
650 g_free (second_line);
654 ft_handler_hashing_started_cb (EmpathyFTHandler *handler,
655 EmpathyFTManager *manager)
657 char *message, *first_line, *second_line;
658 GtkTreeRowReference *row_ref;
660 DEBUG ("Hashing started");
662 g_signal_connect (handler, "hashing-progress",
663 G_CALLBACK (ft_handler_hashing_progress_cb), manager);
664 g_signal_connect (handler, "hashing-done",
665 G_CALLBACK (ft_handler_hashing_done_cb), manager);
667 row_ref = ft_manager_get_row_from_handler (manager, handler);
668 g_return_if_fail (row_ref != NULL);
670 first_line = ft_manager_format_contact_info (handler);
672 if (empathy_ft_handler_is_incoming (handler))
673 second_line = g_strdup_printf (_("Checking integrity of \"%s\""),
674 empathy_ft_handler_get_filename (handler));
676 second_line = g_strdup_printf (_("Hashing \"%s\""),
677 empathy_ft_handler_get_filename (handler));
679 message = g_strdup_printf ("%s\n%s", first_line, second_line);
681 ft_manager_update_handler_message (manager, row_ref, message);
684 g_free (second_line);
689 ft_manager_start_transfer (EmpathyFTManager *manager,
690 EmpathyFTHandler *handler)
692 gboolean is_outgoing;
694 is_outgoing = !empathy_ft_handler_is_incoming (handler);
696 DEBUG ("Start transfer, is outgoing %s",
697 is_outgoing ? "True" : "False");
699 /* now connect the signals */
700 g_signal_connect (handler, "transfer-error",
701 G_CALLBACK (ft_handler_transfer_error_cb), manager);
703 if (is_outgoing && empathy_ft_handler_get_use_hash (handler)) {
704 g_signal_connect (handler, "hashing-started",
705 G_CALLBACK (ft_handler_hashing_started_cb), manager);
707 /* either incoming or outgoing without hash */
708 g_signal_connect (handler, "transfer-started",
709 G_CALLBACK (ft_handler_transfer_started_cb), manager);
712 empathy_ft_handler_start_transfer (handler);
716 ft_manager_add_handler_to_list (EmpathyFTManager *manager,
717 EmpathyFTHandler *handler,
720 GtkTreeRowReference *row_ref;
722 GtkTreeSelection *selection;
725 const char *content_type, *second_line;
726 char *first_line, *message;
727 EmpathyFTManagerPriv *priv = GET_PRIV (manager);
731 /* get the icon name from the mime-type of the file. */
732 content_type = empathy_ft_handler_get_content_type (handler);
734 if (content_type != NULL)
735 icon = g_content_type_get_icon (content_type);
737 /* append the handler in the store */
738 gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->model),
739 &iter, G_MAXINT, COL_FT_OBJECT, handler,
743 g_object_unref (icon);
745 /* insert the new row_ref in the hash table */
746 path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->model), &iter);
747 row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (priv->model), path);
748 gtk_tree_path_free (path);
749 g_hash_table_insert (priv->ft_handler_to_row_ref, g_object_ref (handler),
752 /* select the new row */
753 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
754 gtk_tree_selection_select_iter (selection, &iter);
758 message = ft_manager_format_error_message (handler, error);
759 ft_manager_update_handler_message (manager, row_ref, message);
765 /* update the row with the initial values.
766 * the only case where we postpone this is in case we're managing
767 * an outgoing+hashing transfer, as the hashing started signal will
768 * take care of updating the information.
770 if (empathy_ft_handler_is_incoming (handler) ||
771 !empathy_ft_handler_get_use_hash (handler)) {
772 first_line = ft_manager_format_contact_info (handler);
773 second_line = _("Waiting for the other participant's response");
774 message = g_strdup_printf ("%s\n%s", first_line, second_line);
776 ft_manager_update_handler_message (manager, row_ref, message);
782 /* hook up the signals and start the transfer */
783 ft_manager_start_transfer (manager, handler);
787 ft_manager_clear (EmpathyFTManager *manager)
789 EmpathyFTManagerPriv *priv;
791 DEBUG ("Clearing file transfer list");
793 priv = GET_PRIV (manager);
795 /* Remove completed and cancelled transfers */
796 g_hash_table_foreach_remove (priv->ft_handler_to_row_ref,
797 remove_finished_transfer_foreach, manager);
799 /* set the clear button back to insensitive */
800 gtk_widget_set_sensitive (priv->clear_button, FALSE);
804 ft_manager_open (EmpathyFTManager *manager)
806 GtkTreeSelection *selection;
809 EmpathyFTHandler *handler;
810 EmpathyFTManagerPriv *priv = GET_PRIV (manager);
812 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
814 if (!gtk_tree_selection_get_selected (selection, &model, &iter))
817 gtk_tree_model_get (model, &iter, COL_FT_OBJECT, &handler, -1);
819 if (empathy_ft_handler_is_completed (handler)){
823 file = empathy_ft_handler_get_gfile (handler);
824 uri = g_file_get_uri (file);
826 DEBUG ("Opening URI: %s", uri);
827 empathy_url_show (GTK_WIDGET (priv->window), uri);
831 g_object_unref (handler);
835 ft_manager_stop (EmpathyFTManager *manager)
837 GtkTreeSelection *selection;
840 EmpathyFTHandler *handler;
841 EmpathyFTManagerPriv *priv;
843 priv = GET_PRIV (manager);
845 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
847 if (!gtk_tree_selection_get_selected (selection, &model, &iter))
850 gtk_tree_model_get (model, &iter, COL_FT_OBJECT, &handler, -1);
851 g_return_if_fail (handler != NULL);
853 DEBUG ("Stopping file transfer: contact=%s, filename=%s",
854 empathy_contact_get_alias (empathy_ft_handler_get_contact (handler)),
855 empathy_ft_handler_get_filename (handler));
857 empathy_ft_handler_cancel_transfer (handler);
859 g_object_unref (handler);
863 close_window (EmpathyFTManager *manager)
865 EmpathyFTManagerPriv *priv = GET_PRIV (manager);
867 DEBUG ("%p", manager);
869 /* remove all the completed/cancelled/errored transfers */
870 ft_manager_clear (manager);
872 if (g_hash_table_size (priv->ft_handler_to_row_ref) > 0)
874 /* There is still FTs on flight, just hide the window */
875 DEBUG ("Hiding window");
876 gtk_widget_hide (priv->window);
884 ft_manager_response_cb (GtkWidget *widget,
886 EmpathyFTManager *manager)
888 EmpathyFTManagerPriv *priv = GET_PRIV (manager);
893 ft_manager_clear (manager);
896 ft_manager_open (manager);
899 ft_manager_stop (manager);
902 if (!close_window (manager))
903 gtk_widget_destroy (priv->window);
905 case GTK_RESPONSE_NONE:
906 case GTK_RESPONSE_DELETE_EVENT:
910 g_assert_not_reached ();
915 ft_manager_delete_event_cb (GtkWidget *widget,
917 EmpathyFTManager *manager)
919 return close_window (manager);
923 ft_manager_destroy_cb (GtkWidget *widget,
924 EmpathyFTManager *manager)
926 DEBUG ("%p", manager);
928 g_object_unref (manager);
932 ft_view_button_press_event_cb (GtkWidget *widget,
934 EmpathyFTManager *manager)
937 if (event->type != GDK_2BUTTON_PRESS)
940 ft_manager_open (manager);
946 ft_manager_key_press_event_cb (GtkWidget *widget,
950 if ((event->state & GDK_CONTROL_MASK && event->keyval == GDK_KEY_w)
951 || event->keyval == GDK_KEY_Escape)
953 gtk_widget_destroy (widget);
961 ft_manager_build_ui (EmpathyFTManager *manager)
965 GtkListStore *liststore;
966 GtkTreeViewColumn *column;
967 GtkCellRenderer *renderer;
968 GtkTreeSelection *selection;
970 EmpathyFTManagerPriv *priv = GET_PRIV (manager);
972 filename = empathy_file_lookup ("empathy-ft-manager.ui", "src");
973 gui = empathy_builder_get_file (filename,
974 "ft_manager_dialog", &priv->window,
975 "ft_list", &priv->treeview,
976 "clear_button", &priv->clear_button,
977 "open_button", &priv->open_button,
978 "abort_button", &priv->abort_button,
982 empathy_builder_connect (gui, manager,
983 "ft_manager_dialog", "destroy", ft_manager_destroy_cb,
984 "ft_manager_dialog", "response", ft_manager_response_cb,
985 "ft_manager_dialog", "delete-event", ft_manager_delete_event_cb,
986 "ft_manager_dialog", "key-press-event", ft_manager_key_press_event_cb,
989 empathy_builder_unref_and_keep_widget (gui, priv->window);
991 /* Window geometry. */
992 empathy_geometry_bind (GTK_WINDOW (priv->window), "ft-manager");
994 /* Setup the tree view */
995 view = GTK_TREE_VIEW (priv->treeview);
996 selection = gtk_tree_view_get_selection (view);
997 gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
998 g_signal_connect (selection, "changed",
999 G_CALLBACK (ft_manager_selection_changed), manager);
1000 g_signal_connect (view, "button-press-event",
1001 G_CALLBACK (ft_view_button_press_event_cb),
1003 gtk_tree_view_set_headers_visible (view, TRUE);
1004 gtk_tree_view_set_enable_search (view, FALSE);
1006 /* Setup the model */
1007 liststore = gtk_list_store_new (5,
1008 G_TYPE_INT, /* percent */
1009 G_TYPE_ICON, /* icon */
1010 G_TYPE_STRING, /* message */
1011 G_TYPE_STRING, /* remaining */
1012 G_TYPE_OBJECT); /* ft_handler */
1013 gtk_tree_view_set_model (view, GTK_TREE_MODEL (liststore));
1014 priv->model = GTK_TREE_MODEL (liststore);
1015 g_object_unref (liststore);
1017 /* Progress column */
1018 column = gtk_tree_view_column_new ();
1019 gtk_tree_view_column_set_title (column, _("%"));
1020 gtk_tree_view_column_set_sort_column_id (column, COL_PERCENT);
1021 gtk_tree_view_insert_column (view, column, -1);
1023 renderer = gtk_cell_renderer_progress_new ();
1024 g_object_set (renderer, "xalign", 0.5, NULL);
1025 gtk_tree_view_column_pack_start (column, renderer, FALSE);
1026 gtk_tree_view_column_set_cell_data_func (column, renderer,
1027 ft_manager_progress_cell_data_func, NULL, NULL);
1029 /* Icon and filename column*/
1030 column = gtk_tree_view_column_new ();
1031 gtk_tree_view_column_set_title (column, _("File"));
1032 gtk_tree_view_column_set_expand (column, TRUE);
1033 gtk_tree_view_column_set_resizable (column, TRUE);
1034 gtk_tree_view_column_set_sort_column_id (column, COL_MESSAGE);
1035 gtk_tree_view_column_set_spacing (column, 3);
1036 gtk_tree_view_insert_column (view, column, -1);
1038 renderer = gtk_cell_renderer_pixbuf_new ();
1039 g_object_set (renderer, "xpad", 3,
1040 "stock-size", GTK_ICON_SIZE_DND, NULL);
1041 gtk_tree_view_column_pack_start (column, renderer, FALSE);
1042 gtk_tree_view_column_set_attributes (column, renderer,
1043 "gicon", COL_ICON, NULL);
1045 renderer = gtk_cell_renderer_text_new ();
1046 g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
1047 gtk_tree_view_column_pack_start (column, renderer, TRUE);
1048 gtk_tree_view_column_set_attributes (column, renderer,
1049 "text", COL_MESSAGE, NULL);
1051 /* Remaining time column */
1052 column = gtk_tree_view_column_new ();
1053 gtk_tree_view_column_set_title (column, _("Remaining"));
1054 gtk_tree_view_column_set_sort_column_id (column, COL_REMAINING);
1055 gtk_tree_view_insert_column (view, column, -1);
1057 renderer = gtk_cell_renderer_text_new ();
1058 g_object_set (renderer, "xalign", 0.5, NULL);
1059 gtk_tree_view_column_pack_start (column, renderer, FALSE);
1060 gtk_tree_view_column_set_attributes (column, renderer,
1061 "text", COL_REMAINING, NULL);
1063 /* clear button should be sensitive only if there are completed/cancelled
1064 * handlers in the store.
1066 gtk_widget_set_sensitive (priv->clear_button, FALSE);
1069 /* GObject method overrides */
1072 empathy_ft_manager_finalize (GObject *object)
1074 EmpathyFTManagerPriv *priv = GET_PRIV (object);
1076 DEBUG ("FT Manager %p", object);
1078 g_hash_table_unref (priv->ft_handler_to_row_ref);
1080 G_OBJECT_CLASS (empathy_ft_manager_parent_class)->finalize (object);
1084 empathy_ft_manager_init (EmpathyFTManager *manager)
1086 EmpathyFTManagerPriv *priv;
1088 priv = G_TYPE_INSTANCE_GET_PRIVATE ((manager), EMPATHY_TYPE_FT_MANAGER,
1089 EmpathyFTManagerPriv);
1091 manager->priv = priv;
1093 priv->ft_handler_to_row_ref = g_hash_table_new_full (g_direct_hash,
1094 g_direct_equal, (GDestroyNotify) g_object_unref,
1095 (GDestroyNotify) gtk_tree_row_reference_free);
1097 ft_manager_build_ui (manager);
1101 empathy_ft_manager_constructor (GType type,
1103 GObjectConstructParam *props)
1107 if (manager_singleton)
1109 retval = G_OBJECT (manager_singleton);
1113 retval = G_OBJECT_CLASS (empathy_ft_manager_parent_class)->constructor
1114 (type, n_props, props);
1116 manager_singleton = EMPATHY_FT_MANAGER (retval);
1117 g_object_add_weak_pointer (retval, (gpointer) &manager_singleton);
1124 empathy_ft_manager_class_init (EmpathyFTManagerClass *klass)
1126 GObjectClass *object_class = G_OBJECT_CLASS (klass);
1128 object_class->finalize = empathy_ft_manager_finalize;
1129 object_class->constructor = empathy_ft_manager_constructor;
1131 g_type_class_add_private (object_class, sizeof (EmpathyFTManagerPriv));
1134 /* public methods */
1137 empathy_ft_manager_add_handler (EmpathyFTHandler *handler)
1139 EmpathyFTManager *manager;
1140 EmpathyFTManagerPriv *priv;
1142 DEBUG ("Adding handler");
1144 g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
1146 manager = g_object_new (EMPATHY_TYPE_FT_MANAGER, NULL);
1147 priv = GET_PRIV (manager);
1149 ft_manager_add_handler_to_list (manager, handler, NULL);
1150 gtk_window_present (GTK_WINDOW (priv->window));
1154 empathy_ft_manager_display_error (EmpathyFTHandler *handler,
1155 const GError *error)
1157 EmpathyFTManager *manager;
1158 EmpathyFTManagerPriv *priv;
1160 g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
1161 g_return_if_fail (error != NULL);
1163 manager = g_object_new (EMPATHY_TYPE_FT_MANAGER, NULL);
1164 priv = GET_PRIV (manager);
1166 ft_manager_add_handler_to_list (manager, handler, error);
1167 gtk_window_present (GTK_WINDOW (priv->window));
1171 empathy_ft_manager_show (void)
1173 EmpathyFTManager *manager;
1174 EmpathyFTManagerPriv *priv;
1176 manager = g_object_new (EMPATHY_TYPE_FT_MANAGER, NULL);
1177 priv = GET_PRIV (manager);
1179 gtk_window_present (GTK_WINDOW (priv->window));