download.c

Go to the documentation of this file.

/*
 * Copyright 2008 Michael Lester <element3260@gmail.com>
 *
 * This file is part of NetSurf, http://www.netsurf-browser.org/
 *
 * NetSurf is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * NetSurf is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#include <stdlib.h>
#include <string.h>
#include <math.h>
 
#include <gtk/gtk.h>
#include <glib/gstdio.h>
 
#include "utils/log.h"
#include "utils/utils.h"
#include "utils/nsurl.h"
#include "utils/messages.h"
#include "utils/nsoption.h"
#include "utils/string.h"
#include "desktop/download.h"
#include "netsurf/download.h"
 
#include "gtk/warn.h"
#include "gtk/scaffolding.h"
#include "gtk/toolbar_items.h"
#include "gtk/window.h"
#include "gtk/compat.h"
#include "gtk/resources.h"
#include "gtk/download.h"
 
#define UPDATE_RATE 500 /* In milliseconds */
 
struct download_context;
 
enum {
        NSGTK_DOWNLOAD_PROGRESS,
        NSGTK_DOWNLOAD_INFO,
        NSGTK_DOWNLOAD_REMAINING,
        NSGTK_DOWNLOAD_SPEED,
        NSGTK_DOWNLOAD_PULSE,
        NSGTK_DOWNLOAD_STATUS,
        NSGTK_DOWNLOAD,
 
        NSGTK_DOWNLOAD_N_COLUMNS
};
 
typedef enum {
        NSGTK_DOWNLOAD_NONE,
        NSGTK_DOWNLOAD_WORKING,
        NSGTK_DOWNLOAD_ERROR,
        NSGTK_DOWNLOAD_COMPLETE,
        NSGTK_DOWNLOAD_CANCELED
} nsgtk_download_status;
 
typedef enum {
        NSGTK_DOWNLOAD_PAUSE    = 1 << 0,
        NSGTK_DOWNLOAD_RESUME   = 1 << 1,
        NSGTK_DOWNLOAD_CANCEL   = 1 << 2,
        NSGTK_DOWNLOAD_CLEAR    = 1 << 3
} nsgtk_download_actions;
 
static const gchar* status_messages[] = {
        NULL,
        "gtkWorking",
        "gtkError",
        "gtkComplete",
        "gtkCanceled"
};
 
/**
 * context for each download.
 */
struct gui_download_window {
        struct download_context *ctx;
        nsgtk_download_actions sensitivity;
        nsgtk_download_status status;
 
        GString *name;
        GString *time_left;
        unsigned long long int size_total;
        unsigned long long int size_downloaded;
        gint progress;
        gfloat time_remaining;
        gfloat start_time;
        gfloat speed;
 
        GtkTreeRowReference *row;
        GIOChannel *write;
        GError *error;
};
 
typedef void (*nsgtk_download_selection_action)(struct gui_download_window *dl,
                                                void *user_data);
 
/**
 * context for a nsgtk download window.
 */
struct download_window_ctx {
        GtkWindow *window;
        GtkWindow *parent;
 
        GtkProgressBar *progress;
 
        GtkTreeView *tree;
        GtkListStore *store;
        GtkTreeSelection *selection;
        GtkTreeIter iter;
 
        GTimer *timer;
        GList *list;
        GtkButton *pause;
        GtkButton *clear;
        GtkButton *cancel;
        GtkButton *resume;
 
        gint num_active;
};
 
/**
 * global instance of the download window
 */
static struct download_window_ctx dl_ctx;
 
 
static GtkTreeView* nsgtk_download_tree_view_new(GtkBuilder *gladeFile)
{
        GtkTreeView *treeview;
        GtkCellRenderer *renderer;
 
        treeview = GTK_TREE_VIEW(gtk_builder_get_object(gladeFile,
                                                        "treeDownloads"));
 
        /* Progress column */
        renderer = gtk_cell_renderer_progress_new();
        gtk_tree_view_insert_column_with_attributes(treeview,
                                                    -1,
                                                    messages_get("gtkProgress"),
                                                    renderer,
                                                    "value",
                                                    NSGTK_DOWNLOAD_PROGRESS,
                                                    "pulse",
                                                    NSGTK_DOWNLOAD_PULSE,
                                                    "text",
                                                    NSGTK_DOWNLOAD_STATUS,
                                                    NULL);
 
        /* Information column */
        renderer = gtk_cell_renderer_text_new();
        g_object_set(G_OBJECT(renderer),
                     "wrap-mode",
                     PANGO_WRAP_WORD_CHAR,
                     "wrap-width",
                     300,
                     NULL);
        gtk_tree_view_insert_column_with_attributes(treeview,
                                                    -1,
                                                    messages_get("gtkDetails"),
                                                    renderer,
                                                    "text",
                                                    NSGTK_DOWNLOAD_INFO,
                                                    NULL);
        gtk_tree_view_column_set_expand(
                        gtk_tree_view_get_column(treeview,
                                                 NSGTK_DOWNLOAD_INFO), TRUE);
 
        /* Time remaining column */
        renderer = gtk_cell_renderer_text_new();
        gtk_tree_view_insert_column_with_attributes(treeview,
                                                    -1,
                                                    messages_get("gtkRemaining"),
                                                    renderer,
                                                    "text",
                                                    NSGTK_DOWNLOAD_REMAINING,
                                                    NULL);
 
        /* Speed column */
        renderer = gtk_cell_renderer_text_new();
        gtk_tree_view_insert_column_with_attributes(treeview,
                                                    -1,
                                                    messages_get("gtkSpeed"),
                                                    renderer,
                                                    "text",
                                                    NSGTK_DOWNLOAD_SPEED,
                                                    NULL);
 
        return treeview;
}
 
 
static gint
nsgtk_download_sort(GtkTreeModel *model,
                    GtkTreeIter *a,
                    GtkTreeIter *b,
                    gpointer userdata)
{
        struct gui_download_window *dl1, *dl2;
 
        gtk_tree_model_get(model, a, NSGTK_DOWNLOAD, &dl1, -1);
        gtk_tree_model_get(model, b, NSGTK_DOWNLOAD, &dl2, -1);
 
        return dl1->status - dl2->status;
}
 
 
static void
nsgtk_download_sensitivity_update_buttons(nsgtk_download_actions sensitivity)
{
        /* Glade seems to pack the buttons in an arbitrary order */
        enum { PAUSE_BUTTON, CLEAR_BUTTON, CANCEL_BUTTON, RESUME_BUTTON };
 
        gtk_widget_set_sensitive(GTK_WIDGET(dl_ctx.pause),
                                 sensitivity & NSGTK_DOWNLOAD_PAUSE);
        gtk_widget_set_sensitive(GTK_WIDGET(dl_ctx.clear),
                                 sensitivity & NSGTK_DOWNLOAD_CLEAR);
        gtk_widget_set_sensitive(GTK_WIDGET(dl_ctx.cancel),
                                 sensitivity & NSGTK_DOWNLOAD_CANCEL);
        gtk_widget_set_sensitive(GTK_WIDGET(dl_ctx.resume),
                                 sensitivity & NSGTK_DOWNLOAD_RESUME);
}
 
 
static void nsgtk_download_sensitivity_evaluate(GtkTreeSelection *selection)
{
        GtkTreeIter iter;
        GList *rows;
        gboolean selected;
        GtkTreeModel *model;
        nsgtk_download_actions sensitivity = 0;
        struct gui_download_window *dl;
 
        model = GTK_TREE_MODEL(dl_ctx.store);
 
        selected = gtk_tree_selection_count_selected_rows(selection);
        if (selected) {
                rows = gtk_tree_selection_get_selected_rows(selection, &model);
                while (rows != NULL) {
                        gtk_tree_model_get_iter(model,
                                                &iter,
                                                (GtkTreePath*)rows->data);
                        gtk_tree_model_get(model,
                                           &iter,
                                           NSGTK_DOWNLOAD,
                                           &dl,
                                           -1);
                        sensitivity |= dl->sensitivity;
                        rows = rows->next;
                }
        } else {
                rows = dl_ctx.list;
                while (rows != NULL) {
                        dl = rows->data;
                        sensitivity |= (dl->sensitivity & NSGTK_DOWNLOAD_CLEAR);
                        rows = rows->next;
                }
        }
 
        nsgtk_download_sensitivity_update_buttons(sensitivity);
}
 
 
/**
 * Wrapper to GFunc-ify gtk_tree_path_free for g_list_foreach.
 */
static void
nsgtk_download_gfunc__gtk_tree_path_free(gpointer data, gpointer user_data)
{
        gtk_tree_path_free(data);
}
 
 
/**
 * Wrapper to GFunc-ify g_free for g_list_foreach.
 */
static void
nsgtk_download_gfunc__g_free(gpointer data, gpointer user_data)
{
        g_free(data);
}
 
 
static void nsgtk_download_do(nsgtk_download_selection_action action)
{
        GList *rows, *dls = NULL;
        GtkTreeModel *model;
 
        if (gtk_tree_selection_count_selected_rows(dl_ctx.selection)) {
                model = GTK_TREE_MODEL(dl_ctx.store);
 
                rows = gtk_tree_selection_get_selected_rows(dl_ctx.selection,
                                                            &model);
                while (rows != NULL) {
                        struct gui_download_window *dl;
 
                        gtk_tree_model_get_iter(GTK_TREE_MODEL(dl_ctx.store),
                                                &dl_ctx.iter,
                                                (GtkTreePath*)rows->data);
 
                        gtk_tree_model_get(GTK_TREE_MODEL(dl_ctx.store),
                                           &dl_ctx.iter,
                                           NSGTK_DOWNLOAD,
                                           &dl,
                                           -1);
 
                        dls = g_list_prepend(dls, dl);
 
                        rows = rows->next;
                }
                g_list_foreach(rows,
                               nsgtk_download_gfunc__gtk_tree_path_free,
                               NULL);
                g_list_foreach(rows,
                               nsgtk_download_gfunc__g_free,
                               NULL);
                g_list_free(rows);
        } else {
                dls = g_list_copy(dl_ctx.list);
        }
 
        g_list_foreach(dls, (GFunc)action, NULL);
        g_list_free(dls);
}
 
 
static gchar* nsgtk_download_info_to_string(struct gui_download_window *dl)
{
        gchar *size_info;
        gchar *r;
 
        size_info = g_strdup_printf(messages_get("gtkSizeInfo"),
                                    human_friendly_bytesize(dl->size_downloaded),
                                    dl->size_total == 0 ?
                                    messages_get("gtkUnknownSize") :
                                    human_friendly_bytesize(dl->size_total));
 
        if (dl->status != NSGTK_DOWNLOAD_ERROR) {
                r = g_strdup_printf("%s\n%s", dl->name->str, size_info);
        } else {
                r = g_strdup_printf("%s\n%s", dl->name->str, dl->error->message);
        }
 
        g_free(size_info);
 
        return r;
}
 
 
static gchar* nsgtk_download_time_to_string(gint seconds)
{
        gint hours, minutes;
 
        if (seconds < 0) {
                return g_strdup("-");
        }
 
        hours = seconds / 3600;
        seconds -= hours * 3600;
        minutes = seconds / 60;
        seconds -= minutes * 60;
 
        if (hours > 0) {
                return g_strdup_printf("%u:%02u:%02u",
                                       hours,
                                       minutes,
                                       seconds);
        } else {
                return g_strdup_printf("%u:%02u", minutes, seconds);
        }
}
 
 
static void nsgtk_download_store_update_item(struct gui_download_window *dl)
{
        gchar *info = nsgtk_download_info_to_string(dl);
        char *human = human_friendly_bytesize(dl->speed);
        char speed[strlen(human) + SLEN("/s") + 1];
        sprintf(speed, "%s/s", human);
        gchar *time = nsgtk_download_time_to_string(dl->time_remaining);
        gboolean pulse = dl->status == NSGTK_DOWNLOAD_WORKING;
 
        /* Updates iter (which is needed to set and get data) with the dl row */
        gtk_tree_model_get_iter(GTK_TREE_MODEL(dl_ctx.store),
                                &dl_ctx.iter,
                                gtk_tree_row_reference_get_path(dl->row));
 
        gtk_list_store_set(dl_ctx.store, &dl_ctx.iter,
                           NSGTK_DOWNLOAD_PULSE, pulse ? dl->progress : -1,
                           NSGTK_DOWNLOAD_PROGRESS, pulse ? 0 : dl->progress,
                           NSGTK_DOWNLOAD_INFO, info,
                           NSGTK_DOWNLOAD_SPEED, dl->speed == 0 ? "-" : speed,
                           NSGTK_DOWNLOAD_REMAINING, time,
                           NSGTK_DOWNLOAD, dl,
                           -1);
 
        g_free(info);
        g_free(time);
}
 
 
static gboolean nsgtk_download_update(gboolean force_update)
{
        /* Be sure we need to update */
        if (!nsgtk_widget_get_visible(GTK_WIDGET(dl_ctx.window))) {
                return TRUE;
        }
 
        GList *list;
        gchar *text;
        gboolean update, pulse_mode = FALSE;
        unsigned long long int downloaded = 0;
        unsigned long long int total = 0;
        gint dls = 0;
        gfloat percent, elapsed = g_timer_elapsed(dl_ctx.timer, NULL);
 
        dl_ctx.num_active = 0;
 
        for (list = dl_ctx.list; list != NULL; list = list->next) {
                struct gui_download_window *dl = list->data;
                update = force_update;
 
                switch (dl->status) {
                case NSGTK_DOWNLOAD_WORKING:
                        pulse_mode = TRUE;
                        fallthrough;
 
                case NSGTK_DOWNLOAD_NONE:
                        dl->speed = dl->size_downloaded /
                                (elapsed - dl->start_time);
                        if (dl->status == NSGTK_DOWNLOAD_NONE) {
                                dl->time_remaining = (dl->size_total -
                                                      dl->size_downloaded)/
                                        dl->speed;
                                dl->progress = (double)dl->size_downloaded /
                                        (double)dl->size_total * 100;
                        } else {
                                dl->progress++;
                        }
 
                        dl_ctx.num_active++;
                        update = TRUE;
                        fallthrough;
 
                case NSGTK_DOWNLOAD_COMPLETE:
                        downloaded += dl->size_downloaded;
                        total += dl->size_total;
                        dls++;
                        fallthrough;
 
                default:
                        ;//Do nothing
 
                }
                if (update) {
                        nsgtk_download_store_update_item(dl);
                }
        }
 
        if (pulse_mode) {
                text = g_strdup_printf(
                        messages_get(dl_ctx.num_active > 1 ?
                                     "gtkProgressBarPulse" :
                                     "gtkProgressBarPulseSingle"),
                        dl_ctx.num_active);
                gtk_progress_bar_pulse(dl_ctx.progress);
                gtk_progress_bar_set_text(dl_ctx.progress, text);
        } else {
                percent = total != 0 ? (double)downloaded / (double)total : 0;
                text = g_strdup_printf(messages_get("gtkProgressBar"),
                                       floor(percent * 100), dls);
                gtk_progress_bar_set_fraction(dl_ctx.progress,
                                              percent);
                gtk_progress_bar_set_text(dl_ctx.progress, text);
        }
 
        g_free(text);
 
        if (dl_ctx.num_active == 0) {
                return FALSE; /* Returning FALSE here cancels the g_timeout */
        } else {
                return TRUE;
        }
}
 
 
static void
nsgtk_download_store_clear_item(struct gui_download_window *dl, void *user_data)
{
        if (dl->sensitivity & NSGTK_DOWNLOAD_CLEAR) {
                dl_ctx.list = g_list_remove(dl_ctx.list, dl);
 
                gtk_tree_model_get_iter(GTK_TREE_MODEL(dl_ctx.store),
                                        &dl_ctx.iter,
                                        gtk_tree_row_reference_get_path(dl->row));
                gtk_list_store_remove(dl_ctx.store,
                                      &dl_ctx.iter);
 
                download_context_destroy(dl->ctx);
                g_string_free(dl->name, TRUE);
                g_string_free(dl->time_left, TRUE);
                g_free(dl);
 
                nsgtk_download_sensitivity_evaluate(dl_ctx.selection);
                nsgtk_download_update(FALSE);
        }
}
 
 
static void
nsgtk_download_tree_view_row_activated(GtkTreeView *tree,
                                       GtkTreePath *path,
                                       GtkTreeViewColumn *column,
                                       gpointer data)
{
        GtkTreeModel *model;
        GtkTreeIter iter;
 
        model = gtk_tree_view_get_model(tree);
 
        if (gtk_tree_model_get_iter(model, &iter, path)) {
                /* TODO: This will be a context action (pause, start, clear) */
                nsgtk_download_do(nsgtk_download_store_clear_item);
        }
}
 
 
static void
nsgtk_download_change_sensitivity(struct gui_download_window *dl,
                                  nsgtk_download_actions sensitivity)
{
        dl->sensitivity = sensitivity;
        nsgtk_download_sensitivity_evaluate(dl_ctx.selection);
}
 
 
static void
nsgtk_download_change_status(struct gui_download_window *dl,
                             nsgtk_download_status status)
{
        dl->status = status;
        if (status != NSGTK_DOWNLOAD_NONE) {
                gtk_tree_model_get_iter(GTK_TREE_MODEL(dl_ctx.store),
                                        &dl_ctx.iter,
                                        gtk_tree_row_reference_get_path(dl->row));
 
                gtk_list_store_set(dl_ctx.store, &dl_ctx.iter,
                                   NSGTK_DOWNLOAD_STATUS,
                                   messages_get(status_messages[status]), -1);
        }
}
 
 
static void
nsgtk_download_store_cancel_item(struct gui_download_window *dl,
                                 void *user_data)
{
        if (dl->sensitivity & NSGTK_DOWNLOAD_CANCEL) {
                dl->speed = 0;
                dl->size_downloaded = 0;
                dl->progress = 0;
                dl->time_remaining = -1;
                nsgtk_download_change_sensitivity(dl, NSGTK_DOWNLOAD_CLEAR);
                nsgtk_download_change_status(dl, NSGTK_DOWNLOAD_CANCELED);
 
                download_context_abort(dl->ctx);
 
                g_unlink(download_context_get_filename(dl->ctx));
 
                nsgtk_download_update(TRUE);
        }
}
 
 
static gboolean nsgtk_download_hide(GtkWidget *window)
{
        gtk_widget_hide(window);
        return TRUE;
}
 
 
/**
 * Prompt user for downloaded file name
 *
 * \param filename The original name of the file
 * \param domain the domain the file is being downloaded from
 * \param size The size of the file being downloaded
 */
static gchar*
nsgtk_download_dialog_show(const gchar *filename,
                           const gchar *domain,
                           const gchar *size)
{
        enum { GTK_RESPONSE_DOWNLOAD, GTK_RESPONSE_SAVE_AS };
        GtkWidget *dialog;
        char *destination = NULL;
        gchar *message;
        gchar *info;
 
        message = g_strdup(messages_get("gtkStartDownload"));
        info = g_strdup_printf(messages_get("gtkInfo"), filename, domain, size);
 
        dialog = gtk_message_dialog_new_with_markup(
                                dl_ctx.parent,
                                GTK_DIALOG_DESTROY_WITH_PARENT,
                                GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE,
                                "<span size=\"x-large\" weight=\"ultrabold\">%s</span>"
                                "\n\n<small>%s</small>",
                                message,
                                info);
 
        gtk_dialog_add_buttons(GTK_DIALOG(dialog),
                               NSGTK_STOCK_SAVE, GTK_RESPONSE_DOWNLOAD,
                               NSGTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                               NSGTK_STOCK_SAVE_AS, GTK_RESPONSE_SAVE_AS,
                               NULL);
 
        gint result = gtk_dialog_run(GTK_DIALOG(dialog));
        gtk_widget_destroy(dialog);
        g_free(message);
        g_free(info);
 
        switch (result) {
        case GTK_RESPONSE_SAVE_AS: {
                dialog = gtk_file_chooser_dialog_new(
                                messages_get("gtkSave"),
                                dl_ctx.parent,
                                GTK_FILE_CHOOSER_ACTION_SAVE,
                                NSGTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                NSGTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
                                NULL);
                gtk_file_chooser_set_current_name
                        (GTK_FILE_CHOOSER(dialog), filename);
                gtk_file_chooser_set_current_folder
                        (GTK_FILE_CHOOSER(dialog),
                         nsoption_charp(downloads_directory));
                gtk_file_chooser_set_do_overwrite_confirmation
                        (GTK_FILE_CHOOSER(dialog),
                         nsoption_bool(request_overwrite));
 
                gint result = gtk_dialog_run(GTK_DIALOG(dialog));
                if (result == GTK_RESPONSE_ACCEPT)
                        destination = gtk_file_chooser_get_filename
                                (GTK_FILE_CHOOSER(dialog));
                gtk_widget_destroy(dialog);
                break;
        }
        case GTK_RESPONSE_DOWNLOAD: {
                destination = malloc(strlen(nsoption_charp(downloads_directory))
                                     + strlen(filename) + SLEN("/") + 1);
                if (destination == NULL) {
                        nsgtk_warning(messages_get("NoMemory"), 0);
                        break;
                }
                sprintf(destination, "%s/%s",
                        nsoption_charp(downloads_directory), filename);
                /* Test if file already exists and display overwrite
                 * confirmation if needed */
                if (g_file_test(destination, G_FILE_TEST_EXISTS) &&
                    nsoption_bool(request_overwrite)) {
                        GtkWidget *button;
 
                        message = g_strdup_printf(messages_get("gtkOverwrite"),
                                                  filename);
                        info = g_strdup_printf(messages_get("gtkOverwriteInfo"),
                                               nsoption_charp(downloads_directory));
 
                        dialog = gtk_message_dialog_new_with_markup(
                                                dl_ctx.parent,
                                                GTK_DIALOG_DESTROY_WITH_PARENT,
                                                GTK_MESSAGE_QUESTION,
                                                GTK_BUTTONS_CANCEL,
                                                "<b>%s</b>",
                                                message);
                        gtk_message_dialog_format_secondary_markup(
                                                GTK_MESSAGE_DIALOG(dialog),
                                                "%s",
                                                info);
 
                        button = gtk_dialog_add_button(GTK_DIALOG(dialog),
                                                       "_Replace",
                                                       GTK_RESPONSE_DOWNLOAD);
                        gtk_button_set_image(GTK_BUTTON(button),
                                             nsgtk_image_new_from_stock(
                                                        NSGTK_STOCK_SAVE,
                                                        GTK_ICON_SIZE_BUTTON));
 
                        gint result = gtk_dialog_run(GTK_DIALOG(dialog));
                        if (result == GTK_RESPONSE_CANCEL)
                                destination = NULL;
 
                        gtk_widget_destroy(dialog);
                        g_free(message);
                        g_free(info);
                }
                break;
        }
        }
        return destination;
}
 
 
static gboolean nsgtk_download_handle_error(GError *error)
{
        GtkWidget*dialog;
        gchar *message;
 
        if (error != NULL) {
                message = g_strdup_printf(messages_get("gtkFileError"),
                                          error->message);
 
                dialog = gtk_message_dialog_new_with_markup(
                                        dl_ctx.parent,
                                        GTK_DIALOG_MODAL,
                                        GTK_MESSAGE_ERROR,
                                        GTK_BUTTONS_OK,
                                        "<big><b>%s</b></big>\n\n"
                                        "<small>%s</small>",
                                        messages_get("gtkFailed"),
                                        message);
 
                gtk_dialog_run(GTK_DIALOG(dialog));
                gtk_widget_destroy(dialog);
                return TRUE;
        }
        return FALSE;
}
 
 
static void nsgtk_download_store_create_item(struct gui_download_window *dl)
{
        nsgtk_download_store_update_item(dl);
        /* The iter has already been updated to this row */
        gtk_list_store_set(dl_ctx.store,
                           &dl_ctx.iter,
                           NSGTK_DOWNLOAD,
                           dl,
                           -1);
}
 
 
/**
 * Wrapper to GSourceFunc-ify nsgtk_download_update.
 */
static gboolean
nsgtk_download_gsourcefunc__nsgtk_download_update(gpointer user_data)
{
        return nsgtk_download_update(FALSE);
}
 
 
/**
 * core callback on creating a new download
 */
static struct gui_download_window *
gui_download_window_create(download_context *ctx, struct gui_window *gui)
{
        nsurl *url;
        unsigned long long int total_size;
        gchar *domain;
        gchar *destination;
        gboolean unknown_size;
        struct gui_download_window *download;
        const char *size;
 
        url = download_context_get_url(ctx);
        total_size = download_context_get_total_length(ctx);
        unknown_size = total_size == 0;
        size = (total_size == 0 ?
                messages_get("gtkUnknownSize") :
                human_friendly_bytesize(total_size));
 
        dl_ctx.parent = nsgtk_scaffolding_window(nsgtk_get_scaffold(gui));
 
        download = malloc(sizeof *download);
        if (download == NULL) {
                return NULL;
        }
 
        /* set the domain to the host component of the url if it exists */
        if (nsurl_has_component(url, NSURL_HOST)) {
                domain = g_strdup(lwc_string_data(nsurl_get_component(url, NSURL_HOST)));
        } else {
                domain = g_strdup(messages_get("gtkUnknownHost"));
        }
        if (domain == NULL) {
                free(download);
                return NULL;
        }
 
        /* show the dialog */
        destination = nsgtk_download_dialog_show(
                download_context_get_filename(ctx), domain, size);
        if (destination == NULL) {
                g_free(domain);
                free(download);
                return NULL;
        }
 
        /* Add the new row and store the reference to it (which keeps track of
         * the tree changes) */
        gtk_list_store_prepend(dl_ctx.store, &dl_ctx.iter);
        download->row = gtk_tree_row_reference_new(
                                        GTK_TREE_MODEL(dl_ctx.store),
                                        gtk_tree_model_get_path(
                                                GTK_TREE_MODEL(dl_ctx.store),
                                                &dl_ctx.iter));
 
        download->ctx = ctx;
        download->name = g_string_new(download_context_get_filename(ctx));
        download->time_left = g_string_new("");
        download->size_total = total_size;
        download->size_downloaded = 0;
        download->speed = 0;
        download->start_time = g_timer_elapsed(dl_ctx.timer, NULL);
        download->time_remaining = -1;
        download->status = NSGTK_DOWNLOAD_NONE;
        download->progress = 0;
        download->error = NULL;
        download->write = g_io_channel_new_file(destination,
                                                "w",
                                                &download->error);
 
        if (nsgtk_download_handle_error(download->error)) {
                g_string_free(download->name, TRUE);
                g_string_free(download->time_left, TRUE);
                free(download);
                return NULL;
        }
        g_io_channel_set_encoding(download->write, NULL, &download->error);
 
        nsgtk_download_change_sensitivity(download, NSGTK_DOWNLOAD_CANCEL);
 
        nsgtk_download_store_create_item(download);
        nsgtk_download_show(dl_ctx.parent);
 
        if (unknown_size) {
                nsgtk_download_change_status(download, NSGTK_DOWNLOAD_WORKING);
        }
 
        if (dl_ctx.num_active == 0) {
                g_timeout_add(
                        UPDATE_RATE,
                        nsgtk_download_gsourcefunc__nsgtk_download_update,
                        NULL);
        }
 
        dl_ctx.list = g_list_prepend(dl_ctx.list, download);
 
        return download;
}
 
 
/**
 * core callback on receipt of data
 */
static nserror
gui_download_window_data(struct gui_download_window *dw,
                         const char *data,
                         unsigned int size)
{
        g_io_channel_write_chars(dw->write, data, size, NULL, &dw->error);
        if (dw->error != NULL) {
                dw->speed = 0;
                dw->time_remaining = -1;
 
                nsgtk_download_change_sensitivity(dw, NSGTK_DOWNLOAD_CLEAR);
                nsgtk_download_change_status(dw, NSGTK_DOWNLOAD_ERROR);
 
                nsgtk_download_update(TRUE);
 
                gtk_window_present(dl_ctx.window);
 
                return NSERROR_SAVE_FAILED;
        }
        dw->size_downloaded += size;
 
        return NSERROR_OK;
}
 
 
/**
 * core callback on error
 */
static void
gui_download_window_error(struct gui_download_window *dw, const char *error_msg)
{
}
 
 
/**
 * core callback when core download is complete
 */
static void gui_download_window_done(struct gui_download_window *dw)
{
        g_io_channel_shutdown(dw->write, TRUE, &dw->error);
        g_io_channel_unref(dw->write);
 
        dw->speed = 0;
        dw->time_remaining = -1;
        dw->progress = 100;
        dw->size_total = dw->size_downloaded;
        nsgtk_download_change_sensitivity(dw, NSGTK_DOWNLOAD_CLEAR);
        nsgtk_download_change_status(dw, NSGTK_DOWNLOAD_COMPLETE);
 
        if (nsoption_bool(downloads_clear)) {
                nsgtk_download_store_clear_item(dw, NULL);
        } else {
                nsgtk_download_update(TRUE);
        }
}
 
 
static struct gui_download_table download_table = {
        .create = gui_download_window_create,
        .data = gui_download_window_data,
        .error = gui_download_window_error,
        .done = gui_download_window_done,
};
 
struct gui_download_table *nsgtk_download_table = &download_table;
 
 
/* exported interface documented in gtk/download.h */
nserror nsgtk_download_init(void)
{
        GtkBuilder* builder;
        nserror res;
 
        res = nsgtk_builder_new_from_resname("downloads", &builder);
        if (res != NSERROR_OK) {
                NSLOG(netsurf, INFO, "Download UI builder init failed");
                return res;
        }
 
        gtk_builder_connect_signals(builder, NULL);
 
        dl_ctx.pause = GTK_BUTTON(gtk_builder_get_object(builder,
                                                         "buttonPause"));
        dl_ctx.clear = GTK_BUTTON(gtk_builder_get_object(builder,
                                                         "buttonClear"));
        dl_ctx.cancel = GTK_BUTTON(gtk_builder_get_object(builder,
                                                          "buttonCancel"));
        dl_ctx.resume = GTK_BUTTON(gtk_builder_get_object(builder,
                                                          "buttonPlay"));
 
        dl_ctx.progress = GTK_PROGRESS_BAR(gtk_builder_get_object(builder,
                                                                  "progressBar"));
        dl_ctx.window = GTK_WINDOW(gtk_builder_get_object(builder,
                                                          "wndDownloads"));
        dl_ctx.parent = NULL;
 
        gtk_window_set_transient_for(GTK_WINDOW(dl_ctx.window),
                                     dl_ctx.parent);
        gtk_window_set_destroy_with_parent(GTK_WINDOW(dl_ctx.window),
                                           FALSE);
 
        dl_ctx.timer = g_timer_new();
 
        dl_ctx.tree = nsgtk_download_tree_view_new(builder);
 
        dl_ctx.store = gtk_list_store_new(NSGTK_DOWNLOAD_N_COLUMNS,
                                          G_TYPE_INT, /* % complete */
                                          G_TYPE_STRING, /* Description */
                                          G_TYPE_STRING, /* Time remaining */
                                          G_TYPE_STRING, /* Speed */
                                          G_TYPE_INT,   /* Pulse */
                                          G_TYPE_STRING, /* Status */
                                          G_TYPE_POINTER /* Download structure */
                                          );
 
 
        gtk_tree_view_set_model(dl_ctx.tree, GTK_TREE_MODEL(dl_ctx.store));
 
        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(dl_ctx.store),
                                        NSGTK_DOWNLOAD_STATUS,
                                        (GtkTreeIterCompareFunc)nsgtk_download_sort, NULL, NULL);
        gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(dl_ctx.store),
                                             NSGTK_DOWNLOAD_STATUS,
                                             GTK_SORT_ASCENDING);
 
        g_object_unref(dl_ctx.store);
 
        dl_ctx.selection = gtk_tree_view_get_selection(dl_ctx.tree);
        gtk_tree_selection_set_mode(dl_ctx.selection, GTK_SELECTION_MULTIPLE);
 
        g_signal_connect(G_OBJECT(dl_ctx.selection),
                         "changed",
                         G_CALLBACK(nsgtk_download_sensitivity_evaluate),
                         NULL);
 
        g_signal_connect(dl_ctx.tree,
                         "row-activated",
                         G_CALLBACK(nsgtk_download_tree_view_row_activated),
                         NULL);
 
        g_signal_connect_swapped(gtk_builder_get_object(builder, "buttonClear"),
                                 "clicked",
                                 G_CALLBACK(nsgtk_download_do),
                                 nsgtk_download_store_clear_item);
 
        g_signal_connect_swapped(gtk_builder_get_object(builder, "buttonCancel"),
                                 "clicked",
                                 G_CALLBACK(nsgtk_download_do),
                                 nsgtk_download_store_cancel_item);
 
        g_signal_connect(G_OBJECT(dl_ctx.window),
                         "delete-event",
                         G_CALLBACK(nsgtk_download_hide),
                         NULL);
 
        return NSERROR_OK;
}
 
 
/* exported interface documented in gtk/download.h */
void nsgtk_download_destroy(void)
{
        nsgtk_download_do(nsgtk_download_store_cancel_item);
}
 
 
/* exported interface documented in gtk/download.h */
bool nsgtk_check_for_downloads(GtkWindow *parent)
{
        GtkWidget *dialog;
        gint response;
 
        if (dl_ctx.num_active == 0) {
                return false;
        }
 
        dialog = gtk_message_dialog_new_with_markup(
                                parent,
                                GTK_DIALOG_MODAL,
                                GTK_MESSAGE_WARNING,
                                GTK_BUTTONS_NONE,
                                "<big><b>%s</b></big>\n\n"
                                "<small>%s</small>",
                                messages_get("gtkQuit"),
                                messages_get("gtkDownloadsRunning"));
 
        gtk_dialog_add_buttons(GTK_DIALOG(dialog),
                               "gtk-cancel", GTK_RESPONSE_CANCEL,
                               "gtk-quit", GTK_RESPONSE_CLOSE,
                               NULL);
 
        response = gtk_dialog_run(GTK_DIALOG(dialog));
        gtk_widget_destroy(dialog);
 
        if (response == GTK_RESPONSE_CANCEL) {
                return true;
        }
 
        return false;
}
 
 
/* exported interface documented in gtk/download.h */
void nsgtk_download_show(GtkWindow *parent)
{
        gtk_window_set_transient_for(dl_ctx.window, dl_ctx.parent);
        gtk_window_present(dl_ctx.window);
}