NNTPGrab

/* 

    Copyright (C) 2005-2010  Erik van Pienbroek

    This program 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; either version 2 of the License, or

    (at your option) any later version.

    This program 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, write to the Free Software

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#ifdef WIN32

#include 

#include 

#endif

#include 

#include 

#include "gui.h"

#include 

#include "config_gui.h"

#include "nntpgrab_utils.h"

#ifdef HAVE_LIBNOTIFY

#include 

#endif

static gboolean find_iter_by_collection_name(GtkTreeModel *model, const char *collection_name, GtkTreeIter *iter);

static gboolean find_iter_by_subject(GtkTreeModel *model, GtkTreeIter parent, const char *subject, GtkTreeIter *iter);

static NGSchedularState status_flag = SCHEDULAR_STATE_RUNNING;     // Schedular is running by default

enum {

    FIELD_COLLECTION_NAME,

    FIELD_COLLECTION_NAME_HASH,

    FIELD_SUBJECT,

    FIELD_SUBJECT_HASH,

    FIELD_POSTER,

    FIELD_GROUPS,

    FIELD_STAMP_STR,

    FIELD_PROGRESS,

    FIELD_FILESIZE,

    FIELD_FILESIZE_STR,

    FIELD_FILESIZE_REMAINING,

    FIELD_FILESIZE_REMAINING_STR,

    FIELD_NUM_PARTS,

    FIELD_PARTS_DONE,

    FIELD_PARTS_FAILED,

    FIELD_STATE_STR,

    FIELD_ESTIMATED_TIME_REMAINING,

    FIELD_ESTIMATED_TIME_TO_FINISH,

    FIELD_POSITION,

    FIELD_REAL_FILENAME,

    LAST_FIELD

};

static GtkTreeViewColumn *columns[LAST_FIELD] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 , 0 };

#ifdef WIN32

static void

open_file(const char *file, gboolean open_folder)

{

    char *mode;

    char *file_localized;

    GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

    if (open_folder) {

        mode = "explore";

    } else {

        mode = "open";

    }

    file_localized = g_win32_locale_filename_from_utf8(file);

    g_return_if_fail(file_localized != NULL);

    if ((int) ShellExecuteA((HWND) GDK_WINDOW_HWND(windowMain->window), mode, file_localized, NULL, file_localized, SW_SHOW) < 32) {

        char *msg;

        GtkWidget *windowMain;

        windowMain = nntpgrab_gui_base_get_widget("windowMain");

        if (open_folder) {

            msg = g_strdup_printf(_("Unable to navigate to the download folder\n"));    // TODO: Add GetLastError message

        } else {

            msg = g_strdup_printf(_("Unable to execute file\n%s"), file);    // TODO: Add GetLastError message

        }

        nntpgrab_gui_base_dialog_show(windowMain, msg, GTK_MESSAGE_INFO, GTK_BUTTONS_OK);

        g_free(msg);

    }

    g_free(file_localized);

}

#else

static void

open_file(const char *folder_unquoted, gboolean open_folder)

{

    char *cmd = NULL;

    GError *err = NULL;

    char *folder = g_shell_quote(folder_unquoted);

    gboolean ret;

#if GTK_CHECK_VERSION(2,14,0) && !defined(DARWIN)

    char *uri = g_strdup_printf("file://%s", folder_unquoted);

    ret = gtk_show_uri(NULL, uri, GDK_CURRENT_TIME, &err);

    g_free(uri);

#else

#ifdef DARWIN

    cmd = g_strdup_printf("open %s", folder);

#else

    cmd = g_strdup_printf("xdg-open %s", folder);

#endif

    ret = g_spawn_command_line_async(cmd, &err);

#endif /* GTK_CHECK_VERSION(2,14,0) */

    if (!ret) {

        char *msg;

        GtkWidget *windowMain;

        windowMain = nntpgrab_gui_base_get_widget("windowMain");

        if (open_folder) {

            msg = g_strdup_printf(_("Unable to navigate to the download folder:\n%s"), err->message);

        } else {

            msg = g_strdup_printf(_("Unable to execute file\n%s:\n%s"), folder, err->message);

        }

        g_error_free(err);

        nntpgrab_gui_base_dialog_show(windowMain, msg, GTK_MESSAGE_INFO, GTK_BUTTONS_OK);

        g_free(msg);

    }

    g_free(cmd);

}

#endif

G_MODULE_EXPORT gboolean

on_treeDownloadQueue_button_press_event(GtkWidget *caller, GdkEventButton *event, gpointer data)

{

    GtkWidget *menuDownloadQueue;

    GtkTreeModel *model;

    GtkTreeSelection *selection;

    GValue val;

#if GTK_CHECK_VERSION(2,12,0)

    GObject *menuitemExecuteItem;

    GObject *menuitemOpenDownloadFolder;

    GObject *menuitemMarkOptional;

#else

    GtkWidget *menuitemExecuteItem;

    GtkWidget *menuitemOpenDownloadFolder;

    GtkWidget *menuitemMarkOptional;

#endif

    const char *str_optional;

    gboolean show_optional_button;

    char *progress_str = NULL;

    GtkTreeIter iter;

    GtkTreeIter parent;

    GList *list;

#ifdef DARWIN

    // Catch both the right mouse button and CTRL + left mouse button

    if (!(event->button == 3 || (event->button == 1 && event->state == GDK_CONTROL_MASK))) {

        return FALSE;

    }

#else

    // We only want to catch the right mouse button

    if (event->button != 3) {

        return FALSE;

    }

#endif

    // Is at least one item selected?

    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(caller));

    if (gtk_tree_selection_count_selected_rows(selection) == 0)

    {

        GtkTreePath *path;

        /* Get tree path for row that was clicked */

        if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(caller),

                                            (gint) event->x,

                                            (gint) event->y,

                                            &path, NULL, NULL, NULL))

        {

            // No item(s) selected and no item under the cursor. Ignore

            return FALSE;

        }

        gtk_tree_selection_unselect_all(selection);

        gtk_tree_selection_select_path(selection, path);

        gtk_tree_path_free(path);

    }

    // Do we have exactly one selected item and is this item already downloaded?

#if GTK_CHECK_VERSION(2,12,0)

    menuitemExecuteItem = nntpgrab_gui_base_get_object("menuitemExecuteItem");

    memset(&val, 0, sizeof(val));

    g_value_init(&val, G_TYPE_BOOLEAN);

    g_value_set_boolean (&val, FALSE);

    g_object_set_property(G_OBJECT(menuitemExecuteItem), "sensitive", &val);

#else

    menuitemExecuteItem = nntpgrab_gui_base_get_widget("menuitemExecuteItem");

    gtk_widget_set_sensitive(menuitemExecuteItem, FALSE);

#endif

    if (!nntpgrab_glue_get_is_standalone(glue)) {

#if GTK_CHECK_VERSION(2,12,0)

        menuitemOpenDownloadFolder = nntpgrab_gui_base_get_object("menuitemOpenDownloadFolder");

        memset(&val, 0, sizeof(val));

        g_value_init(&val, G_TYPE_BOOLEAN);

        g_value_set_boolean (&val, FALSE);

        g_object_set_property(G_OBJECT(menuitemOpenDownloadFolder), "sensitive", &val);

#else

        menuitemOpenDownloadFolder = nntpgrab_gui_base_get_widget("menuitemOpenDownloadFolder");

        gtk_widget_set_sensitive(menuitemOpenDownloadFolder, FALSE);

#endif

    }

    list = gtk_tree_selection_get_selected_rows(selection, &model);

    gtk_tree_model_get_iter(model, &iter, (GtkTreePath *) list->data);

    gtk_tree_model_get(model, &iter, FIELD_STATE_STR, &progress_str, -1);

    if (progress_str != NULL) {

        if (gtk_tree_selection_count_selected_rows(selection) == 1) {

            if (!strcmp(progress_str, _("Done")) ||

                !strcmp(progress_str, _("Incomplete"))) {

                if (nntpgrab_glue_get_is_standalone(glue)) {

#if GTK_CHECK_VERSION(2,12,0)

                    g_value_set_boolean (&val, TRUE);

                    g_object_set_property(G_OBJECT(menuitemExecuteItem), "sensitive", &val);

#else

                    gtk_widget_set_sensitive(menuitemExecuteItem, TRUE);

#endif

                }

            }

        }

    }

    if (progress_str && !strcmp(progress_str, _("Skipped"))) {

        str_optional = _("Forcefully download file(s)");

    } else {

        str_optional = _("Don't download file(s)");

    }

    menuitemMarkOptional = nntpgrab_gui_base_get_object("menuitemMarkOptional");

    g_value_unset(&val);

    g_value_init(&val, G_TYPE_STRING);

    g_value_set_string(&val, str_optional);

    g_object_set_property(G_OBJECT(menuitemMarkOptional), "label", &val);

    if (gtk_tree_model_iter_parent(model, &parent, &iter) &&

        (!progress_str || strcmp(progress_str, _("Done"))) &&

        (!progress_str || strcmp(progress_str, _("Incomplete"))) &&

        (!progress_str || strcmp(progress_str, _("Not available")))) {

        show_optional_button = TRUE;

    } else {

        show_optional_button = FALSE;

    }

#if GTK_CHECK_VERSION(2,12,0)

    g_value_unset(&val);

    g_value_init(&val, G_TYPE_BOOLEAN);

    g_value_set_boolean (&val, show_optional_button);

    g_object_set_property(G_OBJECT(menuitemMarkOptional), "sensitive", &val);

#else

    gtk_widget_set_sensitive(menuitemMarkOptional, show_optional_button);

#endif

    g_free(progress_str);

    g_list_foreach (list, (GFunc) gtk_tree_path_free, NULL);

    g_list_free (list);

    // Do we have multiple items selected and do these all belong to the same collection ?

    // TODO

    menuDownloadQueue = nntpgrab_gui_base_get_widget("menuDownloadQueue");

    gtk_menu_popup(GTK_MENU(menuDownloadQueue), NULL, NULL, NULL, NULL, event->button, event->time);

    return TRUE;

}

G_MODULE_EXPORT void

on_menuitemRestartTask_activate(GtkWidget *caller, gpointer data)

{

    GtkWidget *treeDownloadQueue;

    GtkTreeSelection *selection;

    GList *list, *selectedRows;

    GtkTreeModel *model;

    GtkTreeIter iter, parent;

    char *collection_name = NULL;

    char *subject = NULL;

    char *errmsg = NULL;

    treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");

    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeDownloadQueue));

    g_assert(gtk_tree_selection_count_selected_rows(selection) > 0);

    selectedRows = gtk_tree_selection_get_selected_rows(GTK_TREE_SELECTION(selection), &model);

    list = selectedRows;

    while (list) {

        GtkTreePath *path = list->data;

        gtk_tree_model_get_iter(model, &iter, path);

        if (!gtk_tree_model_iter_parent(model, &parent, &iter)) {

            // Item contains no parent, restart the whole collection

            gtk_tree_model_get(model, &iter, FIELD_COLLECTION_NAME, &collection_name, -1);

            if (!nntpgrab_schedular_restart_task(glue, collection_name, NULL, &errmsg)) {

                GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

                char msg[1024];

                memset(&msg, 0, sizeof(msg));

                snprintf(msg, sizeof(msg) - 1, _("Unable to restart collection due to an error:\n%s"), errmsg);

                nntpgrab_gui_base_dialog_show(windowMain, msg, GTK_MESSAGE_INFO, GTK_BUTTONS_OK);

                g_free(errmsg); 

            }

            g_free(collection_name);

        } else {

            // Restart one item from the collection

            gtk_tree_model_get(model, &parent, FIELD_COLLECTION_NAME, &collection_name, -1);

            gtk_tree_model_get(model, &iter, FIELD_SUBJECT, &subject, -1);

            if (!nntpgrab_schedular_restart_task(glue, collection_name, subject, &errmsg)) {

                GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

                char msg[1024];

                memset(&msg, 0, sizeof(msg));

                snprintf(msg, sizeof(msg) - 1, _("Unable to restart task due to an error:\n%s"), errmsg);

                nntpgrab_gui_base_dialog_show(windowMain, msg, GTK_MESSAGE_INFO, GTK_BUTTONS_OK);

                g_free(errmsg);

            }

            g_free(collection_name);

            g_free(subject);

        }

        list = g_list_next(list);

    }

    g_list_foreach (selectedRows, (GFunc) gtk_tree_path_free, NULL);

    g_list_free (selectedRows);

    if (!nntpgrab_schedular_save_queue(glue, &errmsg)) {

        GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

        char msg[1024];

        memset(&msg, 0, sizeof(msg));

        snprintf(msg, sizeof(msg) - 1, _("Download queue could not be saved:\n%s"), errmsg);

        nntpgrab_gui_base_dialog_show(windowMain, msg, GTK_MESSAGE_INFO, GTK_BUTTONS_OK);

        g_free(errmsg);

    }

}

G_MODULE_EXPORT void

on_menuitemMarkOptional_activate(GtkWidget *caller, gpointer data)

{

    GtkWidget *treeDownloadQueue;

    GtkTreeSelection *selection;

    GList *list, *selectedRows;

    GtkTreeModel *model;

    GtkTreeIter iter, parent;

    char *collection_name = NULL;

    char *subject = NULL;

    gboolean is_optional = FALSE;

    gboolean flag_set = FALSE;

    treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");

    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeDownloadQueue));

    g_assert(gtk_tree_selection_count_selected_rows(selection) > 0);

    selectedRows = gtk_tree_selection_get_selected_rows(GTK_TREE_SELECTION(selection), &model);

    list = selectedRows;

    while (list) {

        GtkTreePath *path = list->data;

        gtk_tree_model_get_iter(model, &iter, path);

        if (!gtk_tree_model_iter_parent(model, &parent, &iter)) {

            // Item contains no parent

        } else {

            // Restart one item from the collection

            gtk_tree_model_get(model, &parent, FIELD_COLLECTION_NAME, &collection_name, -1);

            gtk_tree_model_get(model, &iter, FIELD_SUBJECT, &subject, -1);

            if (!flag_set) {

                char *state = NULL;

                gtk_tree_model_get(model, &iter, FIELD_STATE_STR, &state, -1);

                if (state && !strcmp(state, _("Skipped"))) {

                    is_optional = FALSE;

                } else {

                    is_optional = TRUE;

                }

                flag_set = TRUE;

                g_free(state);

            }

            if (!nntpgrab_schedular_mark_task_optional(glue, collection_name, subject, is_optional)) {

                GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

                nntpgrab_gui_base_dialog_show(windowMain, _("Unable to change the status of the selected file(s)"), GTK_MESSAGE_INFO, GTK_BUTTONS_OK);

            }

            g_free(collection_name);

            g_free(subject);

        }

        list = g_list_next(list);

    }

    g_list_foreach (selectedRows, (GFunc) gtk_tree_path_free, NULL);

    g_list_free (selectedRows);

}

G_MODULE_EXPORT void

on_menuitemOpenDownloadFolder_activate(GtkWidget *caller, gpointer data)

{

    // Is only one collection selected or more ?

    gboolean multiple_collections = FALSE;

    char *collection_name = NULL;

    GtkWidget *treeDownloadQueue;

    GtkTreeSelection *selection;

    GList *list, *selectedRows;

    GtkTreeModel *model;

    ConfigOpts opts;

    treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");

    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeDownloadQueue));

    g_assert(gtk_tree_selection_count_selected_rows(selection) > 0);

    selectedRows = gtk_tree_selection_get_selected_rows(GTK_TREE_SELECTION(selection), &model);

    list = selectedRows;

    while (list) {

        GtkTreePath *path = list->data;

        GtkTreeIter iter;

        char *name = NULL;

        gtk_tree_model_get_iter(model, &iter, path);

        gtk_tree_model_get(model, &iter, FIELD_COLLECTION_NAME, &name, -1);

        if (name == NULL || strlen(name) == 0) {

            GtkTreeIter parent;

            if (name) {

                g_free(name);

            }

            // Look at the parent

            gtk_tree_model_iter_parent(model, &parent, &iter);

            gtk_tree_model_get(model, &parent, FIELD_COLLECTION_NAME, &name, -1);

        }

        g_return_if_fail(name != NULL);

        if (!collection_name) {

            collection_name = g_strdup(name);

        } else {

            if (strcmp(name, collection_name)) {

                // A previous found collection name and this collection name differ!

                multiple_collections = TRUE;

            }

        }

        g_free(name);

        list = g_list_next(list);

    }

    g_list_foreach (selectedRows, (GFunc) gtk_tree_path_free, NULL);

    g_list_free (selectedRows);

    opts = nntpgrab_config_get_opts(glue);

    if (multiple_collections) {

        // Open the default download folder

        open_file(opts.download_directory, TRUE);

    } else {

        // Open the download folder of the active collection

        char *folder = g_strdup_printf("%s%s%s", opts.download_directory, G_DIR_SEPARATOR_S, collection_name);

        if (!g_file_test(folder, G_FILE_TEST_IS_DIR)) {

            // Folder doesn't exist yet, fall back to default download directory

            open_file(opts.download_directory, TRUE);

        } else {

            open_file(folder, TRUE);

        }

        g_free(folder);

    }

    if (collection_name) {

        g_free(collection_name);

    }

}

G_MODULE_EXPORT void

on_menuitemExecuteItem_activate(GtkWidget *caller, gpointer data)

{

    char *collection_name = NULL;

    char *real_filename = NULL;

    GtkWidget *treeDownloadQueue;

    GtkTreeSelection *selection;

    GList *selectedRows;

    GtkTreeModel *model;

    ConfigOpts opts;

    GtkTreePath *path;

    GtkTreeIter iter;

    char *subject;

    char *full_filename;

    GtkTreeIter parent;

    treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");

    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeDownloadQueue));

    g_return_if_fail(gtk_tree_selection_count_selected_rows(selection) == 1);

    selectedRows = gtk_tree_selection_get_selected_rows(GTK_TREE_SELECTION(selection), &model);

    path = selectedRows->data;

    gtk_tree_model_get_iter(model, &iter, path);

    gtk_tree_model_get(model, &iter, FIELD_SUBJECT, &subject, -1);

    // Look at the parent

    gtk_tree_model_iter_parent(model, &parent, &iter);

    gtk_tree_model_get(model, &parent, FIELD_COLLECTION_NAME, &collection_name, -1);

    gtk_tree_model_get(model, &iter, FIELD_REAL_FILENAME, &real_filename, -1);

    g_return_if_fail(real_filename != NULL);

    opts = nntpgrab_config_get_opts(glue);

    full_filename = g_strdup_printf("%s%s%s%s%s", opts.download_directory, G_DIR_SEPARATOR_S, collection_name, G_DIR_SEPARATOR_S, real_filename);

    open_file(full_filename, FALSE);

    g_free(full_filename);

    g_free(subject);

    g_free(real_filename);

    g_free(collection_name);

    g_list_foreach (selectedRows, (GFunc) gtk_tree_path_free, NULL);

    g_list_free (selectedRows);

}

typedef enum {

    MOVE_DIRECTION_TOP,

    MOVE_DIRECTION_UP,

    MOVE_DIRECTION_DOWN,

    MOVE_DIRECTION_BOTTOM

} move_direction;

static void

task_moved_cb(NNTPGrabGlue *glue, const char *orig_collection_name, const char *subject, const char *new_collection_name, int old_position, int new_position, gpointer data)

{

    GtkWidget *treeDownloadQueue;

    GtkTreeModel *store;

    GtkTreeIter parent, orig_iter, new_iter;

    int i;

    int num_items;

#if 0 

    g_print("%s: orig_collection_name = %s\n", __PRETTY_FUNCTION__, orig_collection_name);

    g_print("%s: subject = %s\n", __PRETTY_FUNCTION__, subject);

    g_print("%s: new_collection_name = %s\n", __PRETTY_FUNCTION__, new_collection_name);

    g_print("%s: old_position = %i\n", __PRETTY_FUNCTION__, old_position);

    g_print("%s: new_position = %i\n", __PRETTY_FUNCTION__, new_position);

#endif

    treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");

    store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeDownloadQueue));

    g_return_if_fail(find_iter_by_collection_name(GTK_TREE_MODEL(store), new_collection_name, &parent));

    g_return_if_fail(find_iter_by_subject(GTK_TREE_MODEL(store), parent, subject, &orig_iter));

    num_items = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store), &parent);

    if (num_items == 1) {

        /* List only contains one element so we don't need to move anything */

        return;

    }

    if (new_position == -1) {

        i = 1;

        gtk_tree_model_iter_children(GTK_TREE_MODEL(store), &new_iter, &parent);

        while (i != num_items) {

            gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &new_iter);

            i++;

        }

        gtk_tree_store_move_after(GTK_TREE_STORE(store), &orig_iter, &new_iter);

    } else {

        i = 0;

        gtk_tree_model_iter_children(GTK_TREE_MODEL(store), &new_iter, &parent);

        while (i != new_position) {

            gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &new_iter);

            i++;

        }

        if (old_position < new_position) {

            gtk_tree_store_move_after(GTK_TREE_STORE(store), &orig_iter, &new_iter);

        } else {

            gtk_tree_store_move_before(GTK_TREE_STORE(store), &orig_iter, &new_iter);

        }

    }

}

static void

collection_moved_cb(NNTPGrabGlue *glue, const char *collection_name, int old_position, int new_position)

{

    GtkWidget *treeDownloadQueue;

    GtkTreeModel *store;

    GtkTreeIter orig_iter, new_iter;

    int i;

#if 0 

    g_print("%s: collection_name = %s\n", __PRETTY_FUNCTION__, collection_name);

    g_print("%s: old_position = %i\n", __PRETTY_FUNCTION__, old_position);

    g_print("%s: new_position = %i\n", __PRETTY_FUNCTION__, new_position);

#endif

    treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");

    store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeDownloadQueue));

    g_return_if_fail(find_iter_by_collection_name(GTK_TREE_MODEL(store), collection_name, &orig_iter));

    g_return_if_fail(new_position <= (gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store), NULL)));

    if (new_position == -1) {

        new_position = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store), NULL);

        i = 1;

        gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &new_iter);

        while (i != new_position) {

            gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &new_iter);

            i++;

        }

        gtk_tree_store_move_after(GTK_TREE_STORE(store), &orig_iter, &new_iter);

    } else {

        i = 0;

        gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &new_iter);

        while (i != new_position) {

            gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &new_iter);

            i++;

        }

        if (old_position < new_position) {

            gtk_tree_store_move_after(GTK_TREE_STORE(store), &orig_iter, &new_iter);

        } else {

            gtk_tree_store_move_before(GTK_TREE_STORE(store), &orig_iter, &new_iter);

        }

    }

}

static void

move_item(move_direction direction)

{

    char *collection_name = NULL;

    char *subject = NULL;

    int position = -1;

    GtkWidget *treeDownloadQueue;

    GtkTreeSelection *selection;

    GList *list, *selectedRows;

    GtkTreeModel *model;

    GList *references = NULL;

    char *errmsg = NULL;

    treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");

    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeDownloadQueue));

    g_return_if_fail(gtk_tree_selection_count_selected_rows(selection) > 0);

    // Duplicate the list with selected rows into GtkTreeRowReference's as the position of

    // selected rows can change during the loop later on

    selectedRows = gtk_tree_selection_get_selected_rows(GTK_TREE_SELECTION(selection), &model);

    list = selectedRows;

    while (list) {

        GtkTreePath *path = list->data;

        GtkTreeRowReference *ref;

        ref = gtk_tree_row_reference_new(model, path);

        references = g_list_append(references, ref);

        list = g_list_next(list);

    }

    g_list_foreach (selectedRows, (GFunc) gtk_tree_path_free, NULL);

    g_list_free (selectedRows);

    if (direction == MOVE_DIRECTION_DOWN || direction == MOVE_DIRECTION_TOP) {

        references = g_list_reverse(references);

    }

    list = references;

    while (list) {

        GtkTreeRowReference *ref = list->data;

        GtkTreePath *path;

        GtkTreeIter iter;

        char *path_str;

        char **values;

        gboolean is_child = FALSE;

        if (collection_name) {

            g_free(collection_name);

            collection_name = NULL;

        }

        if (subject) {

            g_free(subject);

            subject = NULL;

        }

        path = gtk_tree_row_reference_get_path(ref);

        if (!path) {

            list = g_list_next(list);

            gtk_tree_row_reference_free(ref);

            continue;

        }

        gtk_tree_model_get_iter(model, &iter, path);

        gtk_tree_model_get(model, &iter, FIELD_COLLECTION_NAME, &collection_name, FIELD_SUBJECT, &subject, -1);

        path_str = gtk_tree_path_to_string(path);

        values = g_strsplit(path_str, ":", 0);

        g_return_if_fail(values != NULL);

        if (values[0]) {

            position = atoi(values[0]);

            if (values[1]) {

                position = atoi(values[1]);

            }

        }

        g_strfreev(values);

        g_free(path_str);

        if (collection_name == NULL || strlen(collection_name) == 0) {

            GtkTreeIter parent;

            // Look at the parent

            gtk_tree_model_iter_parent(model, &parent, &iter);

            gtk_tree_model_get(model, &parent, FIELD_COLLECTION_NAME, &collection_name, -1);

            is_child = TRUE;

        }

        g_assert(collection_name);

        switch (direction) {

            case MOVE_DIRECTION_TOP:

                if (is_child) {

                    g_return_if_fail(nntpgrab_schedular_move_task(glue, collection_name, subject, collection_name, 0));

                } else {

                    g_return_if_fail(nntpgrab_schedular_move_collection(glue, collection_name, 0));

                }

                break;

            case MOVE_DIRECTION_UP:

                if (position == 0) {

                    break;

                }

                if (is_child) {

                    g_return_if_fail(nntpgrab_schedular_move_task(glue, collection_name, subject, collection_name, position - 1));

                } else {

                    g_return_if_fail(nntpgrab_schedular_move_collection(glue, collection_name, position - 1));

                }

                break;

            case MOVE_DIRECTION_DOWN:

                if (is_child) {

                    g_return_if_fail(nntpgrab_schedular_move_task(glue, collection_name, subject, collection_name, position + 1));

                } else {

                    g_return_if_fail(nntpgrab_schedular_move_collection(glue, collection_name, position + 1));

                }

                break;

            case MOVE_DIRECTION_BOTTOM:

                if (is_child) {

                    g_return_if_fail(nntpgrab_schedular_move_task(glue, collection_name, subject, collection_name, -1));

                } else {

                    g_return_if_fail(nntpgrab_schedular_move_collection(glue, collection_name, -1));

                }

                break;

            default:

                break;

        }

        list = g_list_next(list);

        gtk_tree_path_free(path);

        gtk_tree_row_reference_free(ref);

    }

    g_list_free(references);

    if (!nntpgrab_schedular_save_queue(glue, &errmsg)) {

        GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

        char msg[1024];

        memset(&msg, 0, sizeof(msg));

        snprintf(msg, sizeof(msg) - 1, _("Download queue could not be saved:\n%s"), errmsg);

        nntpgrab_gui_base_dialog_show(windowMain, msg, GTK_MESSAGE_INFO, GTK_BUTTONS_OK);

        g_free(errmsg);

    }

    if (collection_name) {

        g_free(collection_name);

    }

    if (subject) {

        g_free(subject);

    }

}

G_MODULE_EXPORT void

on_menuitemMoveToTop_activate(GtkWidget *caller, gpointer data)

{

    move_item(MOVE_DIRECTION_TOP);

}

G_MODULE_EXPORT void

on_menuitemMoveUp_activate(GtkWidget *caller, gpointer data)

{

    move_item(MOVE_DIRECTION_UP);

}

G_MODULE_EXPORT void

on_menuitemMoveDown_activate(GtkWidget *caller, gpointer data)

{

    move_item(MOVE_DIRECTION_DOWN);

}

G_MODULE_EXPORT void

on_menuitemMoveToBottom_activate(GtkWidget *caller, gpointer data)

{

    move_item(MOVE_DIRECTION_BOTTOM);

}

G_MODULE_EXPORT void

on_btnRemoveItemFromQueue_clicked(GtkWidget *caller, gpointer data)

{

    GtkWidget *treeDownloadQueue;

    GtkTreeSelection *selection;

    GList *list, *selectedRows, *list_new;

    GtkTreeModel *model;

    char *errmsg = NULL;

    treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");

    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeDownloadQueue));

    g_return_if_fail(gtk_tree_selection_count_selected_rows(selection) > 0);

    selectedRows = gtk_tree_selection_get_selected_rows(GTK_TREE_SELECTION(selection), &model);

    // Duplicate the list and transform the items to GtkTreeRowReferences

    // This is because we are going to delete items in the tree

    list = selectedRows;

    list_new = NULL;

    while (list) {

        GtkTreePath *path = list->data;

        list_new = g_list_append(list_new, gtk_tree_row_reference_new(model, path));

        list = g_list_next(list);

    }

    g_list_foreach (selectedRows, (GFunc) gtk_tree_path_free, NULL);

    g_list_free (selectedRows);

    // Now loop trough all the items and remove the downloads tasks

    list = list_new;

    while (list) {

        GtkTreeRowReference *ref = list->data;

        if (gtk_tree_row_reference_valid(ref)) {

            GtkTreePath *path = gtk_tree_row_reference_get_path(ref);

            GtkTreeIter iter, parent;

            GList *list_tmp;

            char *collection_name = NULL;

            char *subject = NULL;

            gboolean item_is_already_removed = FALSE;

            /* Did we already try to remove the parent of the active item? */

            list_tmp = g_list_previous(list);

            while (list_tmp) {

                GtkTreeRowReference *ref_tmp = list_tmp->data;

                GtkTreePath *path_tmp = gtk_tree_row_reference_get_path(ref_tmp);

                if (gtk_tree_path_is_ancestor(path_tmp, path)) {

                    /* Hey, the collection itself is already removed! */

                    item_is_already_removed = TRUE;

                }

                gtk_tree_path_free(path_tmp);

                list_tmp = g_list_previous(list_tmp);

            }

            gtk_tree_model_get_iter(model, &iter, path);

            gtk_tree_path_free(path);

            if (item_is_already_removed) {

                list = g_list_next(list);

                continue;

            }

            if (!gtk_tree_model_iter_parent(model, &parent, &iter)) {

                // Item contains no parent, delete the whole collection

                gtk_tree_model_get(model, &iter, FIELD_COLLECTION_NAME, &collection_name, -1);

                if (!nntpgrab_schedular_del_task_from_queue(glue, collection_name, NULL, &errmsg)) {

                    GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

                    char msg[1024];

                    memset(&msg, 0, sizeof(msg));

                    snprintf(msg, sizeof(msg) - 1, _("Error occured while removing collection(s):\n%s"), errmsg);

                    nntpgrab_gui_base_dialog_show(windowMain, msg, GTK_MESSAGE_INFO, GTK_BUTTONS_OK);

                    g_free(errmsg);

                }

                g_free(collection_name);

            } else {

                // Delete one item from the collection

                gtk_tree_model_get(model, &parent, FIELD_COLLECTION_NAME, &collection_name, -1);

                gtk_tree_model_get(model, &iter, FIELD_SUBJECT, &subject, -1);

                if (!nntpgrab_schedular_del_task_from_queue(glue, collection_name, subject, &errmsg)) {

                    GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

                    char msg[1024];

                    memset(&msg, 0, sizeof(msg));

                    snprintf(msg, sizeof(msg) - 1, _("Error occured while removing file(s):\n%s"), errmsg);

                    nntpgrab_gui_base_dialog_show(windowMain, msg, GTK_MESSAGE_INFO, GTK_BUTTONS_OK);

                    g_free(errmsg);

                }

                g_free(collection_name);

                g_free(subject);

            }

        }

        list = g_list_next(list);

    }

    /* Traverse the list again to free all the row references */

    list = list_new;

    while (list) {

        gtk_tree_row_reference_free((GtkTreeRowReference*) list->data);

        list = g_list_next(list);

    }

    g_list_free(list_new);

    if (!nntpgrab_schedular_save_queue(glue, &errmsg)) {

        GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

        char msg[1024];

        memset(&msg, 0, sizeof(msg));

        snprintf(msg, sizeof(msg) - 1, _("Download queue could not be saved:\n%s"), errmsg);

        nntpgrab_gui_base_dialog_show(windowMain, msg, GTK_MESSAGE_INFO, GTK_BUTTONS_OK);

        g_free(errmsg);

    }

}

static void

generate_stamp(time_t stamp, char *buf, int buf_len)

{

    struct tm *now;

    if ((now = localtime(&stamp)) == NULL) {

        // Date could not be parted

        buf[0] = '\0';

    }

    strftime(buf, buf_len, "%c", now);

}

static int

calculate_progress(guint64 file_size, guint64 file_size_remaining)

{

    double progress;

    int progress_int;

    // Prevent a division by zero

    if (file_size_remaining == 0) {

        return 100;

    }

    progress = (double) file_size - file_size_remaining;

    progress /= file_size;

    progress *= 100;

    progress_int = (int) progress;

    if (progress_int > 100) {

        g_print(__FILE__ ":%i progress overflow!\n", __LINE__);

        g_print("file_size = %"G_GUINT64_FORMAT"\n", file_size);

        g_print("file_size_remaining = %"G_GUINT64_FORMAT"\n", file_size_remaining);

        progress_int = 100;

    }

    if (progress < 0) {

        g_print(__FILE__ ":%i progress underflow!\n", __LINE__);

        g_print("file_size = %"G_GUINT64_FORMAT"\n", file_size);

        g_print("file_size_remaining = %"G_GUINT64_FORMAT"\n", file_size_remaining);

        progress_int = 0;

    }

    return progress_int;

}

static void

file_download_state_update (NNTPGrabGlue *glue, const char *collection_name, const char *subject, int num_parts_total, int num_parts_done, int num_parts_failed, guint64 file_size, guint64 file_size_remaining, guint64 total_file_size, guint64 total_file_size_remaining, gpointer data)

{

    GtkWidget *treeDownloadQueue;

    GtkTreeModel *store;

    GtkTreeIter iter, parent;

    int progress;

    char size_remaining[64];

    treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");

    store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeDownloadQueue));

    g_return_if_fail(find_iter_by_collection_name(GTK_TREE_MODEL(store), collection_name, &parent));

    g_return_if_fail(find_iter_by_subject(GTK_TREE_MODEL(store), parent, subject, &iter));

    // Update the parent

    progress = calculate_progress(total_file_size, total_file_size_remaining);

    memset(&size_remaining, 0, sizeof(size_remaining));

    nntpgrab_utils_calculate_file_size(total_file_size_remaining, size_remaining, sizeof(size_remaining) - 1);

    gtk_tree_store_set(GTK_TREE_STORE(store), &parent,  FIELD_PROGRESS, progress,

                                                        FIELD_FILESIZE_REMAINING, total_file_size_remaining,

                                                        FIELD_FILESIZE_REMAINING_STR, size_remaining, -1);

    // Update the child

    progress = calculate_progress(file_size, file_size_remaining);

    memset(&size_remaining, 0, sizeof(size_remaining));

    nntpgrab_utils_calculate_file_size(file_size_remaining, size_remaining, sizeof(size_remaining) - 1);

    gtk_tree_store_set(GTK_TREE_STORE(store), &iter,    FIELD_PROGRESS, progress,

                                                        FIELD_PARTS_DONE, num_parts_done,

                                                        FIELD_PARTS_FAILED, num_parts_failed,

                                                        FIELD_FILESIZE_REMAINING, file_size_remaining,

                                                        FIELD_FILESIZE_REMAINING_STR, size_remaining, -1);

}

static void

collection_added (NNTPGrabGlue *glue, const char *collection_name, const char *poster)

{

    GtkWidget *treeDownloadQueue;

    GtkTreeModel *store;

    GtkTreeIter iter;

    treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");

    store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeDownloadQueue));

    gtk_tree_store_append(GTK_TREE_STORE(store), &iter, NULL);

    gtk_tree_store_set(GTK_TREE_STORE(store), &iter,    FIELD_COLLECTION_NAME, collection_name,

                                                        FIELD_COLLECTION_NAME_HASH, g_str_hash(collection_name),

                                                        FIELD_SUBJECT, collection_name,

                                                        FIELD_SUBJECT_HASH, g_str_hash(collection_name),

                                                        FIELD_POSTER, poster,

                                                        FIELD_STATE_STR, NULL, -1);

}

static void

collection_removed (NNTPGrabGlue *glue, const char *collection_name)

{

    GtkWidget *treeDownloadQueue;

    GtkTreeModel *store;

    GtkTreeIter iter;

    treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");

    store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeDownloadQueue));

    g_return_if_fail(find_iter_by_collection_name(store, collection_name, &iter));

    gtk_tree_store_remove(GTK_TREE_STORE(store), &iter);

}

static void

collection_modified (NNTPGrabGlue *glue, const char *collection_name, const char *poster)

{

    GtkWidget *treeDownloadQueue;

    GtkTreeModel *store;

    GtkTreeIter iter;

    treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");

    store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeDownloadQueue));

    g_return_if_fail(find_iter_by_collection_name(store, collection_name, &iter));

    gtk_tree_store_set(GTK_TREE_STORE(store), &iter, FIELD_POSTER, poster, -1);

}

static void

file_added (NNTPGrabGlue *glue, const char *collection_name, const char *subject, const char *poster, guint64 stamp, guint64 file_size, guint64 total_file_size, guint64 total_file_size_remaining, NGTaskState state, int num_parts, GList *groups)

{

    GtkWidget *treeDownloadQueue;

    GtkTreeModel *store;

    GtkTreeIter parent, iter;

    char size[64];

    char size_remaining[64];

    char total_groups[256];

    char stamp_str[64];

    GList *list;

    int progress;

    treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");

    store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeDownloadQueue));

    g_return_if_fail(find_iter_by_collection_name(GTK_TREE_MODEL(store), collection_name, &parent));

    g_return_if_fail(file_size > 0);

    list = groups;

    memset(&total_groups, 0, sizeof(total_groups));

    while (list) {

        if (total_groups[0] != '\0') {

            char tmp[256];

            memset(tmp, 0, sizeof(tmp));

            snprintf(tmp, sizeof(tmp) - 1, "%s, %s", total_groups, (const char *) list->data);

            strcpy(total_groups, tmp);

        } else {

            strncpy(total_groups, list->data, sizeof(total_groups) - 1);

        }

        list = g_list_next(list);

    }

    memset(size, 0, sizeof(size));

    nntpgrab_utils_calculate_file_size(file_size, size, sizeof(size) - 1);

    memset(&stamp_str, 0, sizeof(stamp_str));

    generate_stamp(stamp, stamp_str, sizeof(stamp_str) - 1);

    gtk_tree_store_append(GTK_TREE_STORE(store), &iter, &parent);

    gtk_tree_store_set(GTK_TREE_STORE(store), &iter,    FIELD_SUBJECT, subject,

                                                        FIELD_SUBJECT_HASH, g_str_hash(subject),

                                                        FIELD_POSTER, poster,

                                                        FIELD_GROUPS, total_groups,

                                                        FIELD_STAMP_STR, stamp_str,

                                                        FIELD_FILESIZE, file_size,

                                                        FIELD_FILESIZE_STR, size,

                                                        FIELD_FILESIZE_REMAINING, file_size,

                                                        FIELD_FILESIZE_REMAINING_STR, size,

                                                        FIELD_NUM_PARTS, num_parts,

                                                        FIELD_STATE_STR, NULL, -1);

    if (state == TASK_STATE_SKIPPED) {

        gtk_tree_store_set(GTK_TREE_STORE(store), &iter,    FIELD_STATE_STR, _("Skipped"),

                                                            FIELD_FILESIZE_REMAINING, (guint64) 0,

                                                            FIELD_FILESIZE_REMAINING_STR, NULL, -1);

    }

    // Update the parent

    memset(size, 0, sizeof(size));

    nntpgrab_utils_calculate_file_size(total_file_size, size, sizeof(size) - 1);

    memset(size_remaining, 0, sizeof(size_remaining));

    nntpgrab_utils_calculate_file_size(total_file_size_remaining, size_remaining, sizeof(size_remaining) - 1);

    progress = calculate_progress(total_file_size, total_file_size_remaining);

    gtk_tree_store_set(GTK_TREE_STORE(store), &parent,  FIELD_FILESIZE_STR, size,

                                                        FIELD_FILESIZE, total_file_size,

                                                        FIELD_FILESIZE_REMAINING_STR, size_remaining,

                                                        FIELD_FILESIZE_REMAINING, total_file_size_remaining,

                                                        FIELD_PROGRESS, progress, -1);

}

static void

file_removed (NNTPGrabGlue *glue, const char *collection_name, const char *subject, guint64 total_file_size, guint64 total_file_size_remaining, gpointer data)

{

    GtkWidget *treeDownloadQueue;

    GtkTreeModel *store;

    GtkTreeIter iter, parent;

    int progress;

    char size[64];

    char size_remaining[64];

    treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");

    store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeDownloadQueue));

    g_return_if_fail(find_iter_by_collection_name(GTK_TREE_MODEL(store), collection_name, &parent));

    g_return_if_fail(find_iter_by_subject(GTK_TREE_MODEL(store), parent, subject, &iter));

    memset(&size, 0, sizeof(size));

    nntpgrab_utils_calculate_file_size(total_file_size, size, sizeof(size) - 1);

    memset(size_remaining, 0, sizeof(size_remaining));

    nntpgrab_utils_calculate_file_size(total_file_size_remaining, size_remaining, sizeof(size_remaining) - 1);

    progress = calculate_progress(total_file_size, total_file_size_remaining);

    gtk_tree_store_set(GTK_TREE_STORE(store), &parent,  FIELD_FILESIZE_STR, size,

                                                        FIELD_FILESIZE, total_file_size,

                                                        FIELD_FILESIZE_REMAINING_STR, size_remaining,

                                                        FIELD_FILESIZE_REMAINING, total_file_size_remaining,

                                                        FIELD_PROGRESS, progress, -1);

    gtk_tree_store_remove(GTK_TREE_STORE(store), &iter);

}

static void

file_state_changed (NNTPGrabGlue *glue, const char *collection_name, const char *subject, const char *real_filename, NGTaskState old_state, NGTaskState new_state)

{

    GtkWidget *treeDownloadQueue;

    GtkTreeModel *store;

    GtkTreeIter iter, parent;

    int progress;

    guint64 file_size;

    guint64 file_size_remaining;

    guint64 total_size;

    guint64 total_size_remaining;

    char size_remaining[64];

    treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");

    store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeDownloadQueue));

    g_return_if_fail(find_iter_by_collection_name(GTK_TREE_MODEL(store), collection_name, &parent));

    g_return_if_fail(find_iter_by_subject(GTK_TREE_MODEL(store), parent, subject, &iter));

    switch(new_state) {

        case TASK_STATE_WAITING_FOR_DOWNLOAD:       // The file was restarted

            // Update the row itself

            gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,    FIELD_FILESIZE, &file_size,

                                                                FIELD_FILESIZE_REMAINING, &file_size_remaining, -1);

            memset(size_remaining, 0, sizeof(size_remaining));

            nntpgrab_utils_calculate_file_size(file_size, size_remaining, sizeof(size_remaining) - 1);

            gtk_tree_store_set(GTK_TREE_STORE(store), &iter,    FIELD_PARTS_DONE, (int) 0,

                                                                FIELD_PARTS_FAILED, (int) 0,

                                                                FIELD_PROGRESS, (int) 0,

                                                                FIELD_STATE_STR, NULL,

                                                                FIELD_FILESIZE_REMAINING, file_size,

                                                                FIELD_FILESIZE_REMAINING_STR, size_remaining, -1);

            // Update the parent

            gtk_tree_model_get(GTK_TREE_MODEL(store), &parent,  FIELD_FILESIZE, &total_size,

                                                                FIELD_FILESIZE_REMAINING, &total_size_remaining, -1);

            total_size_remaining += file_size - file_size_remaining;

            progress = calculate_progress(total_size, total_size_remaining);

            memset(size_remaining, 0, sizeof(size_remaining));

            nntpgrab_utils_calculate_file_size(total_size_remaining, size_remaining, sizeof(size_remaining) - 1);

            gtk_tree_store_set(GTK_TREE_STORE(store), &parent,  FIELD_PROGRESS, progress,

                                                                FIELD_FILESIZE_REMAINING, total_size_remaining,

                                                                FIELD_FILESIZE_REMAINING_STR, size_remaining, -1);

            break;

        case TASK_STATE_DOWNLOADING:

            gtk_tree_store_set(GTK_TREE_STORE(store), &iter,    FIELD_PROGRESS, (int) 0,

                                                                FIELD_STATE_STR, NULL, -1);     // The state message should be NULL. In that case the value of the progress bar will be shown

            break;

        case TASK_STATE_WAITING_FOR_DECODE:

            memset(size_remaining, 0, sizeof(size_remaining));

            nntpgrab_utils_calculate_file_size((guint64) 0, size_remaining, sizeof(size_remaining) - 1);

            gtk_tree_store_set(GTK_TREE_STORE(store), &iter,    FIELD_PROGRESS, (int) 100,

                                                                FIELD_FILESIZE_REMAINING_STR, size_remaining,

                                                                FIELD_STATE_STR, _("Waiting"), -1);

            break;

        case TASK_STATE_DECODING:

            gtk_tree_store_set(GTK_TREE_STORE(store), &iter,    FIELD_PROGRESS, (int) 100,

                                                                FIELD_STATE_STR, _("Decoding"), -1);

            break;

        case TASK_STATE_FINISHED_COMPLETE:

            // Do we need to update the parent

            g_return_if_fail(real_filename != NULL);

            gtk_tree_store_set(GTK_TREE_STORE(store), &iter,    FIELD_STATE_STR, _("Done"),

                                                                FIELD_REAL_FILENAME, real_filename, -1);

            break;

        case TASK_STATE_FINISHED_INCOMPLETE:

            g_return_if_fail(real_filename != NULL);

            gtk_tree_store_set(GTK_TREE_STORE(store), &iter,    FIELD_STATE_STR, _("Incomplete"),

                                                                FIELD_REAL_FILENAME, real_filename, -1);

            break;

        case TASK_STATE_FINISHED_NO_PARTS_AVAIL:

            gtk_tree_store_set(GTK_TREE_STORE(store), &iter,    FIELD_STATE_STR, _("Not available"), -1);

            break;

        case TASK_STATE_SKIPPED:

            gtk_tree_store_set(GTK_TREE_STORE(store), &iter,    FIELD_STATE_STR, _("Skipped"),

                                                                FIELD_FILESIZE_REMAINING, (guint64) 0,

                                                                FIELD_FILESIZE_REMAINING_STR, NULL, -1);

            break;

    };

}

static void

foreach_collection_func (const char *collection_name, const char *poster, nguint64 total_size, nguint64 total_size_remaining, int position, gpointer data)

{

    GtkTreeStore *store = GTK_TREE_STORE(data);

    GtkTreeIter iter;

    char size[64];

    char size_remaining[64];

    int progress;

    memset(&size, 0, sizeof(size));

    nntpgrab_utils_calculate_file_size(total_size, size, sizeof(size) - 1);

    memset(&size_remaining, 0, sizeof(size_remaining));

    nntpgrab_utils_calculate_file_size(total_size_remaining, size_remaining, sizeof(size_remaining) - 1);

    progress = calculate_progress(total_size, total_size_remaining);

    gtk_tree_store_append(store, &iter, NULL);

    gtk_tree_store_set(store, &iter,    FIELD_COLLECTION_NAME, collection_name,

                                        FIELD_COLLECTION_NAME_HASH, g_str_hash(collection_name),

                                        FIELD_SUBJECT, collection_name,

                                        FIELD_SUBJECT_HASH, g_str_hash(collection_name),

                                        FIELD_POSTER, poster,

                                        FIELD_FILESIZE_STR, size,

                                        FIELD_FILESIZE, total_size,

                                        FIELD_FILESIZE_REMAINING_STR, size_remaining,

                                        FIELD_FILESIZE_REMAINING, total_size_remaining,

                                        FIELD_STATE_STR, NULL,

                                        FIELD_PROGRESS, progress,

                                        FIELD_POSITION, position, -1);

}

static gboolean

find_iter_by_collection_name(GtkTreeModel *model, const char *collection_name, GtkTreeIter *iter)

{

    unsigned int hash1, hash2;

    hash1 = g_str_hash(collection_name);

    if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), iter)) {

        do {

            gtk_tree_model_get(GTK_TREE_MODEL(model), iter, FIELD_COLLECTION_NAME_HASH, &hash2, -1);

            if (hash1 == hash2) {

                char *name = NULL;

                gtk_tree_model_get(GTK_TREE_MODEL(model), iter, FIELD_COLLECTION_NAME, &name, -1);

                if (!strcmp(collection_name, name)) {

                    g_free(name);

                    return TRUE;

                }

                g_free(name);

            }

        } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(model), iter));

    }

    return FALSE;

}

static gboolean

find_iter_by_subject(GtkTreeModel *model, GtkTreeIter parent, const char *subject, GtkTreeIter *iter)