1 /**
2 * @file gtkft.c GTK+ File Transfer UI
3 * @ingroup pidgin
4 */
5
6 /* pidgin
7 *
8 * Pidgin is the legal property of its developers, whose names are too numerous
9 * to list here. Please refer to the COPYRIGHT file distributed with this
10 * source distribution.
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
25 */
26 #include "internal.h"
27 #include "pidgin.h"
28
29 #include "debug.h"
30 #include "notify.h"
31 #include "ft.h"
32 #include "prpl.h"
33 #include "util.h"
34
35 #include "gtkft.h"
36 #include "prefs.h"
37 #include "pidginstock.h"
38 #include "gtkutils.h"
39
40 #define PIDGINXFER(xfer) \
41 (PidginXferUiData *)(xfer)->ui_data
42
43 /* the maximum size of files we will try to make a thumbnail for */
44 #define PIDGIN_XFER_MAX_SIZE_IMAGE_THUMBNAIL 10 * 1024 * 1024
45
46 struct _PidginXferDialog
47 {
48 gboolean keep_open;
49 gboolean auto_clear;
50
51 gint num_transfers;
52
53 PurpleXfer *selected_xfer;
54
55 GtkWidget *window;
56 GtkWidget *tree;
57 GtkListStore *model;
58
59 GtkWidget *expander;
60
61 GtkWidget *table;
62
63 GtkWidget *local_user_desc_label;
64 GtkWidget *local_user_label;
65 GtkWidget *remote_user_desc_label;
66 GtkWidget *remote_user_label;
67 GtkWidget *protocol_label;
68 GtkWidget *filename_label;
69 GtkWidget *localfile_label;
70 GtkWidget *status_label;
71 GtkWidget *speed_label;
72 GtkWidget *time_elapsed_label;
73 GtkWidget *time_remaining_label;
74
75 GtkWidget *progress;
76
77 /* Buttons */
78 GtkWidget *open_button;
79 GtkWidget *remove_button;
80 GtkWidget *stop_button;
81 GtkWidget *close_button;
82 };
83
84 typedef struct
85 {
86 GtkTreeIter iter;
87 time_t last_updated_time;
88 gboolean in_list;
89
90 char *name;
91
92 } PidginXferUiData;
93
94 static PidginXferDialog *xfer_dialog = NULL;
95
96 enum
97 {
98 COLUMN_STATUS = 0,
99 COLUMN_PROGRESS,
100 COLUMN_FILENAME,
101 COLUMN_SIZE,
102 COLUMN_REMAINING,
103 COLUMN_DATA,
104 NUM_COLUMNS
105 };
106
107
108 /**************************************************************************
109 * Utility Functions
110 **************************************************************************/
111 static void
get_xfer_info_strings(PurpleXfer * xfer,char ** kbsec,char ** time_elapsed,char ** time_remaining)112 get_xfer_info_strings(PurpleXfer *xfer, char **kbsec, char **time_elapsed,
113 char **time_remaining)
114 {
115 double kb_sent, kb_rem;
116 double kbps = 0.0;
117 time_t elapsed, now;
118
119 if (xfer->end_time != 0)
120 now = xfer->end_time;
121 else
122 now = time(NULL);
123
124 kb_sent = purple_xfer_get_bytes_sent(xfer) / 1024.0;
125 kb_rem = purple_xfer_get_bytes_remaining(xfer) / 1024.0;
126 elapsed = (xfer->start_time > 0 ? now - xfer->start_time : 0);
127 kbps = (elapsed > 0 ? (kb_sent / elapsed) : 0);
128
129 if (kbsec != NULL) {
130 *kbsec = g_strdup_printf(_("%.2f KiB/s"), kbps);
131 }
132
133 if (time_elapsed != NULL)
134 {
135 int h, m, s;
136 int secs_elapsed;
137
138 if (xfer->start_time > 0)
139 {
140 secs_elapsed = now - xfer->start_time;
141
142 h = secs_elapsed / 3600;
143 m = (secs_elapsed % 3600) / 60;
144 s = secs_elapsed % 60;
145
146 *time_elapsed = g_strdup_printf("%d:%02d:%02d", h, m, s);
147 }
148 else
149 {
150 *time_elapsed = g_strdup(_("Not started"));
151 }
152 }
153
154 if (time_remaining != NULL) {
155 if (purple_xfer_is_completed(xfer)) {
156 *time_remaining = g_strdup(_("Finished"));
157 }
158 else if (purple_xfer_is_canceled(xfer)) {
159 *time_remaining = g_strdup(_("Cancelled"));
160 }
161 else if (purple_xfer_get_size(xfer) == 0 || (kb_sent > 0 && kbps == 0)) {
162 *time_remaining = g_strdup(_("Unknown"));
163 }
164 else if (kb_sent <= 0) {
165 *time_remaining = g_strdup(_("Waiting for transfer to begin"));
166 }
167 else {
168 int h, m, s;
169 int secs_remaining;
170
171 secs_remaining = (int)(kb_rem / kbps);
172
173 h = secs_remaining / 3600;
174 m = (secs_remaining % 3600) / 60;
175 s = secs_remaining % 60;
176
177 *time_remaining = g_strdup_printf("%d:%02d:%02d", h, m, s);
178 }
179 }
180 }
181
182 static void
update_title_progress(PidginXferDialog * dialog)183 update_title_progress(PidginXferDialog *dialog)
184 {
185 gboolean valid;
186 GtkTreeIter iter;
187 int num_active_xfers = 0;
188 guint64 total_bytes_xferred = 0;
189 guint64 total_file_size = 0;
190
191 if (dialog->window == NULL)
192 return;
193
194 valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(dialog->model), &iter);
195
196 /* Find all active transfers */
197 while (valid) {
198 GValue val;
199 PurpleXfer *xfer = NULL;
200
201 val.g_type = 0;
202 gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model),
203 &iter, COLUMN_DATA, &val);
204
205 xfer = g_value_get_pointer(&val);
206 if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_STARTED) {
207 num_active_xfers++;
208 total_bytes_xferred += purple_xfer_get_bytes_sent(xfer);
209 total_file_size += purple_xfer_get_size(xfer);
210 }
211
212 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(dialog->model), &iter);
213 }
214
215 /* Update the title */
216 if (num_active_xfers > 0)
217 {
218 gchar *title;
219 int total_pct = 0;
220
221 if (total_file_size > 0) {
222 total_pct = 100 * total_bytes_xferred / total_file_size;
223 }
224
225 title = g_strdup_printf(ngettext("File Transfers - %d%% of %d file",
226 "File Transfers - %d%% of %d files",
227 num_active_xfers),
228 total_pct, num_active_xfers);
229 gtk_window_set_title(GTK_WINDOW(dialog->window), title);
230 g_free(title);
231 } else {
232 gtk_window_set_title(GTK_WINDOW(dialog->window), _("File Transfers"));
233 }
234 }
235
236 static void
update_detailed_info(PidginXferDialog * dialog,PurpleXfer * xfer)237 update_detailed_info(PidginXferDialog *dialog, PurpleXfer *xfer)
238 {
239 PidginXferUiData *data;
240 char *kbsec, *time_elapsed, *time_remaining;
241 char *status, *utf8;
242
243 if (dialog == NULL || xfer == NULL)
244 return;
245
246 data = PIDGINXFER(xfer);
247
248 get_xfer_info_strings(xfer, &kbsec, &time_elapsed, &time_remaining);
249
250 status = g_strdup_printf("%d%% (%" G_GSIZE_FORMAT " of %" G_GSIZE_FORMAT " bytes)",
251 (int)(purple_xfer_get_progress(xfer)*100),
252 purple_xfer_get_bytes_sent(xfer),
253 purple_xfer_get_size(xfer));
254
255 if (purple_xfer_is_completed(xfer)) {
256
257 GdkPixbuf *pixbuf = NULL;
258
259 pixbuf = gtk_widget_render_icon(xfer_dialog->window,
260 PIDGIN_STOCK_FILE_DONE,
261 GTK_ICON_SIZE_MENU, NULL);
262
263 gtk_list_store_set(GTK_LIST_STORE(xfer_dialog->model), &data->iter,
264 COLUMN_STATUS, pixbuf,
265 -1);
266
267 g_object_unref(pixbuf);
268 }
269
270 if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) {
271 gtk_label_set_markup(GTK_LABEL(dialog->local_user_desc_label),
272 _("<b>Receiving As:</b>"));
273 gtk_label_set_markup(GTK_LABEL(dialog->remote_user_desc_label),
274 _("<b>Receiving From:</b>"));
275 }
276 else {
277 gtk_label_set_markup(GTK_LABEL(dialog->remote_user_desc_label),
278 _("<b>Sending To:</b>"));
279 gtk_label_set_markup(GTK_LABEL(dialog->local_user_desc_label),
280 _("<b>Sending As:</b>"));
281 }
282
283 gtk_label_set_text(GTK_LABEL(dialog->local_user_label),
284 purple_account_get_username(xfer->account));
285 gtk_label_set_text(GTK_LABEL(dialog->remote_user_label), xfer->who);
286 gtk_label_set_text(GTK_LABEL(dialog->protocol_label),
287 purple_account_get_protocol_name(xfer->account));
288
289 if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) {
290 gtk_label_set_text(GTK_LABEL(dialog->filename_label),
291 purple_xfer_get_filename(xfer));
292 } else {
293 char *tmp;
294
295 tmp = g_path_get_basename(purple_xfer_get_local_filename(xfer));
296 utf8 = g_filename_to_utf8(tmp, -1, NULL, NULL, NULL);
297 g_free(tmp);
298
299 gtk_label_set_text(GTK_LABEL(dialog->filename_label), utf8);
300 g_free(utf8);
301 }
302
303 utf8 = g_filename_to_utf8((purple_xfer_get_local_filename(xfer)), -1, NULL, NULL, NULL);
304 gtk_label_set_text(GTK_LABEL(dialog->localfile_label), utf8);
305 g_free(utf8);
306
307 gtk_label_set_text(GTK_LABEL(dialog->status_label), status);
308
309 gtk_label_set_text(GTK_LABEL(dialog->speed_label), kbsec);
310 gtk_label_set_text(GTK_LABEL(dialog->time_elapsed_label), time_elapsed);
311 gtk_label_set_text(GTK_LABEL(dialog->time_remaining_label),
312 time_remaining);
313
314 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dialog->progress),
315 purple_xfer_get_progress(xfer));
316
317 g_free(kbsec);
318 g_free(time_elapsed);
319 g_free(time_remaining);
320 g_free(status);
321 }
322
323 static void
update_buttons(PidginXferDialog * dialog,PurpleXfer * xfer)324 update_buttons(PidginXferDialog *dialog, PurpleXfer *xfer)
325 {
326 if (dialog->selected_xfer == NULL) {
327 gtk_widget_set_sensitive(dialog->expander, FALSE);
328 gtk_widget_set_sensitive(dialog->open_button, FALSE);
329 gtk_widget_set_sensitive(dialog->stop_button, FALSE);
330
331 gtk_widget_show(dialog->stop_button);
332 gtk_widget_hide(dialog->remove_button);
333
334 return;
335 }
336
337 if (dialog->selected_xfer != xfer)
338 return;
339
340 if (purple_xfer_is_completed(xfer)) {
341 gtk_widget_hide(dialog->stop_button);
342 gtk_widget_show(dialog->remove_button);
343
344 #ifdef _WIN32
345 /* If using Win32... */
346 if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) {
347 gtk_widget_set_sensitive(dialog->open_button, TRUE);
348 } else {
349 gtk_widget_set_sensitive(dialog->open_button, FALSE);
350 }
351 #else
352 if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) {
353 gtk_widget_set_sensitive(dialog->open_button, TRUE);
354 } else {
355 gtk_widget_set_sensitive (dialog->open_button, FALSE);
356 }
357 #endif
358
359 gtk_widget_set_sensitive(dialog->remove_button, TRUE);
360 } else if (purple_xfer_is_canceled(xfer)) {
361 gtk_widget_hide(dialog->stop_button);
362 gtk_widget_show(dialog->remove_button);
363
364 gtk_widget_set_sensitive(dialog->open_button, FALSE);
365
366 gtk_widget_set_sensitive(dialog->remove_button, TRUE);
367 } else {
368 gtk_widget_show(dialog->stop_button);
369 gtk_widget_hide(dialog->remove_button);
370
371 gtk_widget_set_sensitive(dialog->open_button, FALSE);
372 gtk_widget_set_sensitive(dialog->stop_button, TRUE);
373 }
374 }
375
376 static void
ensure_row_selected(PidginXferDialog * dialog)377 ensure_row_selected(PidginXferDialog *dialog)
378 {
379 GtkTreeIter iter;
380 GtkTreeSelection *selection;
381
382 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->tree));
383
384 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
385 return;
386
387 if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(dialog->model), &iter))
388 gtk_tree_selection_select_iter(selection, &iter);
389 }
390
391 /**************************************************************************
392 * Callbacks
393 **************************************************************************/
394 static gint
delete_win_cb(GtkWidget * w,GdkEventAny * e,gpointer d)395 delete_win_cb(GtkWidget *w, GdkEventAny *e, gpointer d)
396 {
397 PidginXferDialog *dialog;
398
399 dialog = (PidginXferDialog *)d;
400
401 pidgin_xfer_dialog_hide(dialog);
402
403 return TRUE;
404 }
405
406 static void
toggle_keep_open_cb(GtkWidget * w,PidginXferDialog * dialog)407 toggle_keep_open_cb(GtkWidget *w, PidginXferDialog *dialog)
408 {
409 dialog->keep_open = !dialog->keep_open;
410 purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/filetransfer/keep_open",
411 dialog->keep_open);
412 }
413
414 static void
toggle_clear_finished_cb(GtkWidget * w,PidginXferDialog * dialog)415 toggle_clear_finished_cb(GtkWidget *w, PidginXferDialog *dialog)
416 {
417 dialog->auto_clear = !dialog->auto_clear;
418 purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/filetransfer/clear_finished",
419 dialog->auto_clear);
420 }
421
422 static void
selection_changed_cb(GtkTreeSelection * selection,PidginXferDialog * dialog)423 selection_changed_cb(GtkTreeSelection *selection, PidginXferDialog *dialog)
424 {
425 GtkTreeIter iter;
426 PurpleXfer *xfer = NULL;
427
428 if (gtk_tree_selection_get_selected(selection, NULL, &iter)) {
429 GValue val;
430
431 gtk_widget_set_sensitive(dialog->expander, TRUE);
432
433 val.g_type = 0;
434 gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model),
435 &iter, COLUMN_DATA, &val);
436
437 xfer = g_value_get_pointer(&val);
438
439 update_detailed_info(dialog, xfer);
440
441 dialog->selected_xfer = xfer;
442 }
443 else {
444 gtk_expander_set_expanded(GTK_EXPANDER(dialog->expander),
445 FALSE);
446
447 gtk_widget_set_sensitive(dialog->expander, FALSE);
448
449 dialog->selected_xfer = NULL;
450 }
451
452 update_buttons(dialog, xfer);
453 }
454
455 static void
open_button_cb(GtkButton * button,PidginXferDialog * dialog)456 open_button_cb(GtkButton *button, PidginXferDialog *dialog)
457 {
458 #ifdef _WIN32
459 /* If using Win32... */
460 int code;
461 wchar_t *wc_filename = g_utf8_to_utf16(
462 purple_xfer_get_local_filename(
463 dialog->selected_xfer),
464 -1, NULL, NULL, NULL);
465
466 code = (int) ShellExecuteW(NULL, NULL, wc_filename, NULL, NULL,
467 SW_SHOW);
468
469 g_free(wc_filename);
470
471 if (code == SE_ERR_ASSOCINCOMPLETE || code == SE_ERR_NOASSOC)
472 {
473 purple_notify_error(dialog, NULL,
474 _("There is no application configured to open this type of file."), NULL);
475 }
476 else if (code < 32)
477 {
478 purple_notify_error(dialog, NULL,
479 _("An error occurred while opening the file."), NULL);
480 purple_debug_warning("ft", "filename: %s; code: %d\n",
481 purple_xfer_get_local_filename(dialog->selected_xfer), code);
482 }
483 #else
484 const char *filename = purple_xfer_get_local_filename(dialog->selected_xfer);
485 char *command = NULL;
486 GError *error = NULL;
487
488 if (purple_running_gnome())
489 {
490 char *escaped = g_shell_quote(filename);
491 command = g_strdup_printf("gnome-open %s", escaped);
492 g_free(escaped);
493 }
494 else if (purple_running_kde())
495 {
496 char *escaped = g_shell_quote(filename);
497
498 if (purple_str_has_suffix(filename, ".desktop"))
499 command = g_strdup_printf("kfmclient openURL %s 'text/plain'", escaped);
500 else
501 command = g_strdup_printf("kfmclient openURL %s", escaped);
502 g_free(escaped);
503 }
504 else
505 {
506 gchar *uri = g_strdup_printf("file://%s", filename);
507 purple_notify_uri(NULL, uri);
508 g_free(uri);
509 return;
510 }
511
512 if (purple_program_is_valid(command))
513 {
514 gint exit_status;
515 if (!g_spawn_command_line_sync(command, NULL, NULL, &exit_status, &error))
516 {
517 gchar *tmp = g_strdup_printf(_("Error launching %s: %s"),
518 purple_xfer_get_local_filename(dialog->selected_xfer),
519 error->message);
520 purple_notify_error(dialog, NULL, _("Unable to open file."), tmp);
521 g_free(tmp);
522 g_error_free(error);
523 }
524 if (exit_status != 0)
525 {
526 char *primary = g_strdup_printf(_("Error running %s"), command);
527 char *secondary = g_strdup_printf(_("Process returned error code %d"),
528 exit_status);
529 purple_notify_error(dialog, NULL, primary, secondary);
530 }
531 }
532 #endif
533 }
534
535 static void
remove_button_cb(GtkButton * button,PidginXferDialog * dialog)536 remove_button_cb(GtkButton *button, PidginXferDialog *dialog)
537 {
538 pidgin_xfer_dialog_remove_xfer(dialog, dialog->selected_xfer);
539 }
540
541 static void
stop_button_cb(GtkButton * button,PidginXferDialog * dialog)542 stop_button_cb(GtkButton *button, PidginXferDialog *dialog)
543 {
544 purple_xfer_cancel_local(dialog->selected_xfer);
545 }
546
547 static void
close_button_cb(GtkButton * button,PidginXferDialog * dialog)548 close_button_cb(GtkButton *button, PidginXferDialog *dialog)
549 {
550 pidgin_xfer_dialog_hide(dialog);
551 }
552
553
554 /**************************************************************************
555 * Dialog Building Functions
556 **************************************************************************/
557 static GtkWidget *
setup_tree(PidginXferDialog * dialog)558 setup_tree(PidginXferDialog *dialog)
559 {
560 GtkWidget *tree;
561 GtkListStore *model;
562 GtkCellRenderer *renderer;
563 GtkTreeViewColumn *column;
564 GtkTreeSelection *selection;
565
566 /* Build the tree model */
567 /* Transfer type, Progress Bar, Filename, Size, Remaining */
568 model = gtk_list_store_new(NUM_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_INT,
569 G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
570 G_TYPE_POINTER);
571 dialog->model = model;
572
573 /* Create the treeview */
574 dialog->tree = tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
575 gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
576 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
577 /* gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); */
578
579 gtk_widget_show(tree);
580
581 g_signal_connect(G_OBJECT(selection), "changed",
582 G_CALLBACK(selection_changed_cb), dialog);
583
584 g_object_unref(G_OBJECT(model));
585
586
587 /* Columns */
588
589 /* Transfer Type column */
590 renderer = gtk_cell_renderer_pixbuf_new();
591 column = gtk_tree_view_column_new_with_attributes(NULL, renderer,
592 "pixbuf", COLUMN_STATUS, NULL);
593 gtk_tree_view_column_set_sizing(GTK_TREE_VIEW_COLUMN(column),
594 GTK_TREE_VIEW_COLUMN_FIXED);
595 gtk_tree_view_column_set_fixed_width(GTK_TREE_VIEW_COLUMN(column), 25);
596 gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
597 gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
598
599 /* Progress bar column */
600 renderer = gtk_cell_renderer_progress_new();
601 column = gtk_tree_view_column_new_with_attributes(_("Progress"), renderer,
602 "value", COLUMN_PROGRESS, NULL);
603 gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
604 gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
605
606 /* Filename column */
607 renderer = gtk_cell_renderer_text_new();
608 column = gtk_tree_view_column_new_with_attributes(_("Filename"), renderer,
609 "text", COLUMN_FILENAME, NULL);
610 gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
611 gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
612
613 /* File Size column */
614 renderer = gtk_cell_renderer_text_new();
615 column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer,
616 "text", COLUMN_SIZE, NULL);
617 gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
618 gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
619
620 /* Bytes Remaining column */
621 renderer = gtk_cell_renderer_text_new();
622 column = gtk_tree_view_column_new_with_attributes(_("Remaining"),
623 renderer, "text", COLUMN_REMAINING, NULL);
624 gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
625 gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
626
627 gtk_tree_view_columns_autosize(GTK_TREE_VIEW(tree));
628
629 gtk_widget_show(tree);
630
631 return tree;
632 }
633
634 static GtkWidget *
make_info_table(PidginXferDialog * dialog)635 make_info_table(PidginXferDialog *dialog)
636 {
637 GtkWidget *table;
638 GtkWidget *label;
639 gsize i;
640
641 struct
642 {
643 GtkWidget **desc_label;
644 GtkWidget **val_label;
645 const char *desc;
646
647 } labels[] =
648 {
649 { &dialog->local_user_desc_label, &dialog->local_user_label, NULL },
650 { &dialog->remote_user_desc_label, &dialog->remote_user_label, NULL },
651 { &label, &dialog->protocol_label, _("Protocol:") },
652 { &label, &dialog->filename_label, _("Filename:") },
653 { &label, &dialog->localfile_label, _("Local File:") },
654 { &label, &dialog->status_label, _("Status:") },
655 { &label, &dialog->speed_label, _("Speed:") },
656 { &label, &dialog->time_elapsed_label, _("Time Elapsed:") },
657 { &label, &dialog->time_remaining_label, _("Time Remaining:") }
658 };
659
660 /* Setup the initial table */
661 dialog->table = table = gtk_table_new(G_N_ELEMENTS(labels) + 1, 2, FALSE);
662 gtk_table_set_row_spacings(GTK_TABLE(table), PIDGIN_HIG_BOX_SPACE);
663 gtk_table_set_col_spacings(GTK_TABLE(table), PIDGIN_HIG_BOX_SPACE);
664
665 /* Setup the labels */
666 for (i = 0; i < G_N_ELEMENTS(labels); i++) {
667 GtkWidget *label;
668 char buf[256];
669
670 g_snprintf(buf, sizeof(buf), "<b>%s</b>",
671 labels[i].desc != NULL ? labels[i].desc : "");
672
673 *labels[i].desc_label = label = gtk_label_new(NULL);
674 gtk_label_set_markup(GTK_LABEL(label), buf);
675 gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT);
676 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
677 gtk_table_attach(GTK_TABLE(table), label, 0, 1, i, i + 1,
678 GTK_FILL, 0, 0, 0);
679 gtk_widget_show(label);
680
681 *labels[i].val_label = label = gtk_label_new(NULL);
682 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
683 gtk_table_attach(GTK_TABLE(table), label, 1, 2, i, i + 1,
684 GTK_FILL | GTK_EXPAND, 0, 0, 0);
685 gtk_widget_show(label);
686 }
687
688 /* Setup the progress bar */
689 dialog->progress = gtk_progress_bar_new();
690 gtk_table_attach(GTK_TABLE(table), dialog->progress,
691 0, 2,
692 G_N_ELEMENTS(labels), G_N_ELEMENTS(labels) + 1,
693 GTK_FILL, GTK_FILL, 0, 0);
694 gtk_widget_show(dialog->progress);
695
696 return table;
697 }
698
699 PidginXferDialog *
pidgin_xfer_dialog_new(void)700 pidgin_xfer_dialog_new(void)
701 {
702 PidginXferDialog *dialog;
703 GtkWidget *window;
704 GtkWidget *vbox1, *vbox2;
705 GtkWidget *expander;
706 GtkWidget *alignment;
707 GtkWidget *table;
708 GtkWidget *checkbox;
709 GtkWidget *bbox;
710
711 dialog = g_new0(PidginXferDialog, 1);
712 dialog->keep_open =
713 purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/filetransfer/keep_open");
714 dialog->auto_clear =
715 purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/filetransfer/clear_finished");
716
717 /* Create the window. */
718 dialog->window = window = pidgin_create_window(_("File Transfers"), PIDGIN_HIG_BORDER, "file transfer", TRUE);
719 gtk_window_set_default_size(GTK_WINDOW(window), 450, 250);
720
721 g_signal_connect(G_OBJECT(window), "delete_event",
722 G_CALLBACK(delete_win_cb), dialog);
723
724 /* Create the parent vbox for everything. */
725 vbox1 = gtk_vbox_new(FALSE, 0);
726 gtk_widget_show(vbox1);
727 gtk_container_add(GTK_CONTAINER(window), vbox1);
728
729 /* Create the main vbox for top half of the window. */
730 vbox2 = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
731 gtk_box_pack_start(GTK_BOX(vbox1), vbox2, TRUE, TRUE, 0);
732 gtk_widget_show(vbox2);
733
734 /* Setup the listbox */
735 gtk_box_pack_start(GTK_BOX(vbox2),
736 pidgin_make_scrollable(setup_tree(dialog), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC, GTK_SHADOW_IN, -1, 140),
737 TRUE, TRUE, 0);
738
739 /* "Close this window when all transfers finish" */
740 checkbox = gtk_check_button_new_with_mnemonic(
741 _("Close this window when all transfers _finish"));
742 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox),
743 !dialog->keep_open);
744 g_signal_connect(G_OBJECT(checkbox), "toggled",
745 G_CALLBACK(toggle_keep_open_cb), dialog);
746 gtk_box_pack_start(GTK_BOX(vbox2), checkbox, FALSE, FALSE, 0);
747 gtk_widget_show(checkbox);
748
749 /* "Clear finished transfers" */
750 checkbox = gtk_check_button_new_with_mnemonic(
751 _("C_lear finished transfers"));
752 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox),
753 dialog->auto_clear);
754 g_signal_connect(G_OBJECT(checkbox), "toggled",
755 G_CALLBACK(toggle_clear_finished_cb), dialog);
756 gtk_box_pack_start(GTK_BOX(vbox2), checkbox, FALSE, FALSE, 0);
757 gtk_widget_show(checkbox);
758
759 /* "Download Details" arrow */
760 expander = gtk_expander_new_with_mnemonic(_("File transfer _details"));
761 dialog->expander = expander;
762 gtk_box_pack_start(GTK_BOX(vbox2), expander, FALSE, FALSE, 0);
763 gtk_widget_show(expander);
764
765 gtk_widget_set_sensitive(expander, FALSE);
766
767 /* Small indent make table fall under GtkExpander's label */
768 alignment = gtk_alignment_new(1, 0, 1, 1);
769 gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, 20, 0);
770 gtk_container_add(GTK_CONTAINER(expander), alignment);
771 gtk_widget_show(alignment);
772
773 /* The table of information. */
774 table = make_info_table(dialog);
775 gtk_container_add(GTK_CONTAINER(alignment), table);
776 gtk_widget_show(table);
777
778 bbox = gtk_hbutton_box_new();
779 gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
780 gtk_box_set_spacing(GTK_BOX(bbox), PIDGIN_HIG_BOX_SPACE);
781 gtk_box_pack_end(GTK_BOX(vbox1), bbox, FALSE, TRUE, 0);
782 gtk_widget_show(bbox);
783
784 #define ADD_BUTTON(b, label, callback, callbackdata) do { \
785 GtkWidget *button = gtk_button_new_from_stock(label); \
786 gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); \
787 g_signal_connect(G_OBJECT(button), "clicked", callback, callbackdata); \
788 gtk_widget_show(button); \
789 b = button; \
790 } while (0)
791
792 /* Open button */
793 ADD_BUTTON(dialog->open_button, GTK_STOCK_OPEN, G_CALLBACK(open_button_cb), dialog);
794 gtk_widget_set_sensitive(dialog->open_button, FALSE);
795
796 /* Remove button */
797 ADD_BUTTON(dialog->remove_button, GTK_STOCK_REMOVE, G_CALLBACK(remove_button_cb), dialog);
798 gtk_widget_hide(dialog->remove_button);
799
800 /* Stop button */
801 ADD_BUTTON(dialog->stop_button, GTK_STOCK_STOP, G_CALLBACK(stop_button_cb), dialog);
802 gtk_widget_set_sensitive(dialog->stop_button, FALSE);
803
804 /* Close button */
805 ADD_BUTTON(dialog->close_button, GTK_STOCK_CLOSE, G_CALLBACK(close_button_cb), dialog);
806
807 #undef ADD_BUTTON
808
809 #ifdef _WIN32
810 g_signal_connect(G_OBJECT(dialog->window), "show",
811 G_CALLBACK(winpidgin_ensure_onscreen), dialog->window);
812 #endif
813
814 return dialog;
815 }
816
817 void
pidgin_xfer_dialog_destroy(PidginXferDialog * dialog)818 pidgin_xfer_dialog_destroy(PidginXferDialog *dialog)
819 {
820 g_return_if_fail(dialog != NULL);
821
822 purple_notify_close_with_handle(dialog);
823
824 gtk_widget_destroy(dialog->window);
825
826 g_free(dialog);
827 }
828
829 void
pidgin_xfer_dialog_show(PidginXferDialog * dialog)830 pidgin_xfer_dialog_show(PidginXferDialog *dialog)
831 {
832 PidginXferDialog *tmp;
833
834 if (dialog == NULL) {
835 tmp = pidgin_get_xfer_dialog();
836
837 if (tmp == NULL) {
838 tmp = pidgin_xfer_dialog_new();
839 pidgin_set_xfer_dialog(tmp);
840 }
841
842 gtk_widget_show(tmp->window);
843 } else {
844 gtk_window_present(GTK_WINDOW(dialog->window));
845 }
846 }
847
848 void
pidgin_xfer_dialog_hide(PidginXferDialog * dialog)849 pidgin_xfer_dialog_hide(PidginXferDialog *dialog)
850 {
851 g_return_if_fail(dialog != NULL);
852
853 purple_notify_close_with_handle(dialog);
854
855 gtk_widget_hide(dialog->window);
856 }
857
858 void
pidgin_xfer_dialog_add_xfer(PidginXferDialog * dialog,PurpleXfer * xfer)859 pidgin_xfer_dialog_add_xfer(PidginXferDialog *dialog, PurpleXfer *xfer)
860 {
861 PidginXferUiData *data;
862 PurpleXferType type;
863 GdkPixbuf *pixbuf;
864 char *size_str, *remaining_str;
865 char *lfilename, *utf8;
866
867 g_return_if_fail(dialog != NULL);
868 g_return_if_fail(xfer != NULL);
869
870 purple_xfer_ref(xfer);
871
872 data = PIDGINXFER(xfer);
873 data->in_list = TRUE;
874
875 pidgin_xfer_dialog_show(dialog);
876
877 data->last_updated_time = 0;
878
879 type = purple_xfer_get_type(xfer);
880
881 size_str = purple_str_size_to_units(purple_xfer_get_size(xfer));
882 remaining_str = purple_str_size_to_units(purple_xfer_get_bytes_remaining(xfer));
883
884 pixbuf = gtk_widget_render_icon(dialog->window,
885 (type == PURPLE_XFER_RECEIVE
886 ? PIDGIN_STOCK_DOWNLOAD
887 : PIDGIN_STOCK_UPLOAD),
888 GTK_ICON_SIZE_MENU, NULL);
889
890 gtk_list_store_append(dialog->model, &data->iter);
891 lfilename = g_path_get_basename(purple_xfer_get_local_filename(xfer));
892 utf8 = g_filename_to_utf8(lfilename, -1, NULL, NULL, NULL);
893 g_free(lfilename);
894 lfilename = utf8;
895 gtk_list_store_set(dialog->model, &data->iter,
896 COLUMN_STATUS, pixbuf,
897 COLUMN_PROGRESS, 0,
898 COLUMN_FILENAME, (type == PURPLE_XFER_RECEIVE)
899 ? purple_xfer_get_filename(xfer)
900 : lfilename,
901 COLUMN_SIZE, size_str,
902 COLUMN_REMAINING, _("Waiting for transfer to begin"),
903 COLUMN_DATA, xfer,
904 -1);
905 g_free(lfilename);
906
907 gtk_tree_view_columns_autosize(GTK_TREE_VIEW(dialog->tree));
908
909 g_object_unref(pixbuf);
910
911 g_free(size_str);
912 g_free(remaining_str);
913
914 dialog->num_transfers++;
915
916 ensure_row_selected(dialog);
917 update_title_progress(dialog);
918 }
919
920 void
pidgin_xfer_dialog_remove_xfer(PidginXferDialog * dialog,PurpleXfer * xfer)921 pidgin_xfer_dialog_remove_xfer(PidginXferDialog *dialog,
922 PurpleXfer *xfer)
923 {
924 PidginXferUiData *data;
925
926 g_return_if_fail(dialog != NULL);
927 g_return_if_fail(xfer != NULL);
928
929 data = PIDGINXFER(xfer);
930
931 if (data == NULL)
932 return;
933
934 if (!data->in_list)
935 return;
936
937 data->in_list = FALSE;
938
939 gtk_list_store_remove(GTK_LIST_STORE(dialog->model), &data->iter);
940
941 dialog->num_transfers--;
942
943 ensure_row_selected(dialog);
944
945 update_title_progress(dialog);
946 purple_xfer_unref(xfer);
947 }
948
949 void
pidgin_xfer_dialog_cancel_xfer(PidginXferDialog * dialog,PurpleXfer * xfer)950 pidgin_xfer_dialog_cancel_xfer(PidginXferDialog *dialog,
951 PurpleXfer *xfer)
952 {
953 PidginXferUiData *data;
954 GdkPixbuf *pixbuf;
955 const gchar *status;
956
957 g_return_if_fail(dialog != NULL);
958 g_return_if_fail(xfer != NULL);
959
960 data = PIDGINXFER(xfer);
961
962 if (data == NULL)
963 return;
964
965 if (!data->in_list)
966 return;
967
968 if ((purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL) && (dialog->auto_clear)) {
969 pidgin_xfer_dialog_remove_xfer(dialog, xfer);
970 return;
971 }
972
973 data = PIDGINXFER(xfer);
974
975 update_detailed_info(dialog, xfer);
976 update_title_progress(dialog);
977
978 pixbuf = gtk_widget_render_icon(dialog->window,
979 PIDGIN_STOCK_FILE_CANCELED,
980 GTK_ICON_SIZE_MENU, NULL);
981
982 if (purple_xfer_is_canceled(xfer))
983 status = _("Cancelled");
984 else
985 status = _("Failed");
986
987 gtk_list_store_set(dialog->model, &data->iter,
988 COLUMN_STATUS, pixbuf,
989 COLUMN_REMAINING, status,
990 -1);
991
992 g_object_unref(pixbuf);
993
994 update_buttons(dialog, xfer);
995 }
996
997 void
pidgin_xfer_dialog_update_xfer(PidginXferDialog * dialog,PurpleXfer * xfer)998 pidgin_xfer_dialog_update_xfer(PidginXferDialog *dialog,
999 PurpleXfer *xfer)
1000 {
1001 PidginXferUiData *data;
1002 char *size_str, *remaining_str;
1003 time_t current_time;
1004 GtkTreeIter iter;
1005 gboolean valid;
1006
1007 g_return_if_fail(dialog != NULL);
1008 g_return_if_fail(xfer != NULL);
1009
1010 if ((data = PIDGINXFER(xfer)) == NULL)
1011 return;
1012
1013 if (data->in_list == FALSE)
1014 return;
1015
1016 current_time = time(NULL);
1017 if (((current_time - data->last_updated_time) == 0) &&
1018 (!purple_xfer_is_completed(xfer)))
1019 {
1020 /* Don't update the window more than once per second */
1021 return;
1022 }
1023 data->last_updated_time = current_time;
1024
1025 size_str = purple_str_size_to_units(purple_xfer_get_size(xfer));
1026 remaining_str = purple_str_size_to_units(purple_xfer_get_bytes_remaining(xfer));
1027
1028 gtk_list_store_set(xfer_dialog->model, &data->iter,
1029 COLUMN_PROGRESS, (gint)(purple_xfer_get_progress(xfer) * 100),
1030 COLUMN_SIZE, size_str,
1031 COLUMN_REMAINING, remaining_str,
1032 -1);
1033
1034 g_free(size_str);
1035 g_free(remaining_str);
1036
1037 if (purple_xfer_is_completed(xfer))
1038 {
1039 GdkPixbuf *pixbuf;
1040
1041 pixbuf = gtk_widget_render_icon(dialog->window,
1042 PIDGIN_STOCK_FILE_DONE,
1043 GTK_ICON_SIZE_MENU, NULL);
1044
1045 gtk_list_store_set(GTK_LIST_STORE(xfer_dialog->model), &data->iter,
1046 COLUMN_STATUS, pixbuf,
1047 COLUMN_REMAINING, _("Finished"),
1048 -1);
1049
1050 g_object_unref(pixbuf);
1051 }
1052
1053 update_title_progress(dialog);
1054 if (xfer == dialog->selected_xfer)
1055 update_detailed_info(xfer_dialog, xfer);
1056
1057 if (purple_xfer_is_completed(xfer) && dialog->auto_clear)
1058 pidgin_xfer_dialog_remove_xfer(dialog, xfer);
1059 else
1060 update_buttons(dialog, xfer);
1061
1062 /*
1063 * If all transfers are finished, and the pref is set, then
1064 * close the dialog. Otherwise just exit this function.
1065 */
1066 if (dialog->keep_open)
1067 return;
1068
1069 valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(dialog->model), &iter);
1070 while (valid)
1071 {
1072 GValue val;
1073 PurpleXfer *next;
1074
1075 val.g_type = 0;
1076 gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model),
1077 &iter, COLUMN_DATA, &val);
1078
1079 next = g_value_get_pointer(&val);
1080 if (!purple_xfer_is_completed(next))
1081 return;
1082
1083 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(dialog->model), &iter);
1084 }
1085
1086 /* If we got to this point then we know everything is finished */
1087 pidgin_xfer_dialog_hide(dialog);
1088 }
1089
1090 /**************************************************************************
1091 * File Transfer UI Ops
1092 **************************************************************************/
1093 static void
pidgin_xfer_new_xfer(PurpleXfer * xfer)1094 pidgin_xfer_new_xfer(PurpleXfer *xfer)
1095 {
1096 PidginXferUiData *data;
1097
1098 /* This is where we're setting xfer->ui_data for the first time. */
1099 data = g_new0(PidginXferUiData, 1);
1100 xfer->ui_data = data;
1101 }
1102
1103 static void
pidgin_xfer_destroy(PurpleXfer * xfer)1104 pidgin_xfer_destroy(PurpleXfer *xfer)
1105 {
1106 PidginXferUiData *data;
1107
1108 data = PIDGINXFER(xfer);
1109 if (data) {
1110 g_free(data->name);
1111 g_free(data);
1112 xfer->ui_data = NULL;
1113 }
1114 }
1115
1116 static void
pidgin_xfer_add_xfer(PurpleXfer * xfer)1117 pidgin_xfer_add_xfer(PurpleXfer *xfer)
1118 {
1119 if (xfer_dialog == NULL)
1120 xfer_dialog = pidgin_xfer_dialog_new();
1121
1122 pidgin_xfer_dialog_add_xfer(xfer_dialog, xfer);
1123 }
1124
1125 static void
pidgin_xfer_update_progress(PurpleXfer * xfer,double percent)1126 pidgin_xfer_update_progress(PurpleXfer *xfer, double percent)
1127 {
1128 pidgin_xfer_dialog_update_xfer(xfer_dialog, xfer);
1129 }
1130
1131 static void
pidgin_xfer_cancel_local(PurpleXfer * xfer)1132 pidgin_xfer_cancel_local(PurpleXfer *xfer)
1133 {
1134 if (xfer_dialog)
1135 pidgin_xfer_dialog_cancel_xfer(xfer_dialog, xfer);
1136 }
1137
1138 static void
pidgin_xfer_cancel_remote(PurpleXfer * xfer)1139 pidgin_xfer_cancel_remote(PurpleXfer *xfer)
1140 {
1141 if (xfer_dialog)
1142 pidgin_xfer_dialog_cancel_xfer(xfer_dialog, xfer);
1143 }
1144
1145 static void
pidgin_xfer_add_thumbnail(PurpleXfer * xfer,const gchar * formats)1146 pidgin_xfer_add_thumbnail(PurpleXfer *xfer, const gchar *formats)
1147 {
1148 purple_debug_info("ft", "creating thumbnail for transfer\n");
1149
1150 if (purple_xfer_get_size(xfer) <= PIDGIN_XFER_MAX_SIZE_IMAGE_THUMBNAIL) {
1151 GdkPixbuf *thumbnail =
1152 pidgin_pixbuf_new_from_file_at_size(
1153 purple_xfer_get_local_filename(xfer), 128, 128);
1154
1155 if (thumbnail) {
1156 gchar **formats_split = g_strsplit(formats, ",", 0);
1157 gchar *buffer = NULL;
1158 gsize size;
1159 char *option_keys[2] = {NULL, NULL};
1160 char *option_values[2] = {NULL, NULL};
1161 int i;
1162 gchar *format = NULL;
1163
1164 for (i = 0; formats_split[i]; i++) {
1165 if (purple_strequal(formats_split[i], "jpeg")) {
1166 purple_debug_info("ft", "creating JPEG thumbnail\n");
1167 option_keys[0] = "quality";
1168 option_values[0] = "90";
1169 format = "jpeg";
1170 break;
1171 } else if (purple_strequal(formats_split[i], "png")) {
1172 purple_debug_info("ft", "creating PNG thumbnail\n");
1173 option_keys[0] = "compression";
1174 option_values[0] = "9";
1175 format = "png";
1176 break;
1177 }
1178 }
1179
1180 /* Try the first format given by the PRPL without options */
1181 if (format == NULL) {
1182 purple_debug_info("ft",
1183 "creating thumbnail of format %s as demanded by PRPL\n",
1184 formats_split[0]);
1185 format = formats_split[0];
1186 }
1187
1188 gdk_pixbuf_save_to_bufferv(thumbnail, &buffer, &size, format,
1189 option_keys, option_values, NULL);
1190
1191 if (buffer) {
1192 gchar *mimetype = g_strdup_printf("image/%s", format);
1193 purple_debug_info("ft",
1194 "created thumbnail of %" G_GSIZE_FORMAT " bytes\n",
1195 size);
1196 purple_xfer_set_thumbnail(xfer, buffer, size, mimetype);
1197 g_free(buffer);
1198 g_free(mimetype);
1199 }
1200 g_object_unref(thumbnail);
1201 g_strfreev(formats_split);
1202 }
1203 }
1204 }
1205
1206 static PurpleXferUiOps ops =
1207 {
1208 pidgin_xfer_new_xfer,
1209 pidgin_xfer_destroy,
1210 pidgin_xfer_add_xfer,
1211 pidgin_xfer_update_progress,
1212 pidgin_xfer_cancel_local,
1213 pidgin_xfer_cancel_remote,
1214 NULL,
1215 NULL,
1216 NULL,
1217 pidgin_xfer_add_thumbnail
1218 };
1219
1220 /**************************************************************************
1221 * GTK+ File Transfer API
1222 **************************************************************************/
1223 void
pidgin_xfers_init(void)1224 pidgin_xfers_init(void)
1225 {
1226 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/filetransfer");
1227 purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/filetransfer/clear_finished", TRUE);
1228 purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/filetransfer/keep_open", FALSE);
1229 }
1230
1231 void
pidgin_xfers_uninit(void)1232 pidgin_xfers_uninit(void)
1233 {
1234 if (xfer_dialog != NULL)
1235 pidgin_xfer_dialog_destroy(xfer_dialog);
1236 }
1237
1238 void
pidgin_set_xfer_dialog(PidginXferDialog * dialog)1239 pidgin_set_xfer_dialog(PidginXferDialog *dialog)
1240 {
1241 xfer_dialog = dialog;
1242 }
1243
1244 PidginXferDialog *
pidgin_get_xfer_dialog(void)1245 pidgin_get_xfer_dialog(void)
1246 {
1247 return xfer_dialog;
1248 }
1249
1250 PurpleXferUiOps *
pidgin_xfers_get_ui_ops(void)1251 pidgin_xfers_get_ui_ops(void)
1252 {
1253 return &ops;
1254 }
1255