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

*/

#include 

#include "gui.h"

static GtkWidget *treeviewPAR2AndUnpack = NULL;

static GtkTreeStore *store = NULL;

static GList *items_to_pulse = NULL;

enum {

    ACTION_PAR2,

    ACTION_UNPACK,

};

enum {

    FIELD_COLLECTION_NAME,

    FIELD_COLLECTION_NAME_HASH,

    FIELD_ACTION,

    FIELD_ACTION_STR,

    FIELD_PAR2_OR_UNPACK_FILENAME,

    FIELD_FILENAME,

    FIELD_FILENAME_HASH,

    FIELD_PROGRESS_VALUE,

    FIELD_PROGRESS_STR,

    FIELD_PROGRESS_PULSE,

    LAST_FIELD,

};

static gboolean

lookup_collection(const char *collection_name, GtkTreeIter *collection_iter)

{

    GtkTreeIter iter;

    guint hash;

    if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter)) {

        return FALSE;

    }

    hash = g_str_hash(collection_name);

    do {

        guint hash_row = 0;

        gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, FIELD_COLLECTION_NAME_HASH, &hash_row, -1);

        if (hash == hash_row) {

            /* Also verify the collection name itself to be sure */

            char *collection_name_row = NULL;

            gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, FIELD_COLLECTION_NAME, &collection_name_row, -1);

            if (!strcmp(collection_name, collection_name_row)) {

                *collection_iter = iter;

                g_free(collection_name_row);

                return TRUE;

            }

            g_free(collection_name_row);

        }

    } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter));

    return FALSE;

}

static gboolean

lookup_filename(GtkTreeIter parent_iter, const char *filename, GtkTreeIter *filename_iter)

{

    GtkTreeIter iter;

    guint hash;

    if (!gtk_tree_model_iter_children(GTK_TREE_MODEL(store), &iter, &parent_iter)) {

        return FALSE;

    }

    hash = g_str_hash(filename);

    do {

        guint hash_row = 0;

        gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, FIELD_FILENAME_HASH, &hash_row, -1);

        if (hash == hash_row) {

            /* Also verify the filename itself to be sure */

            char *filename_row = NULL;

            gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, FIELD_FILENAME, &filename_row, -1);

            if (!strcmp(filename, filename_row)) {

                *filename_iter = iter;

                g_free(filename_row);

                return TRUE;

            }

            g_free(filename_row);

        }

    } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter));

    return FALSE;

}

static void

scroll_to_bottom(GtkTreeIter iter)

{

    GtkTreePath *path;

    gtk_tree_view_expand_all(GTK_TREE_VIEW(treeviewPAR2AndUnpack));

    path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);

    gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(treeviewPAR2AndUnpack), path, NULL, FALSE, 0.0, 0.0);

    gtk_tree_path_free(path);

}

static void

par2_begin_verify (NntpgrabGlue *obj, const char *collection_name, const char *active_par2_filename, gpointer data)

{

    GtkTreeIter collection_iter;

    GtkTreeIter par2set_iter;

    GtkTreePath *path;

    char *filename = g_path_get_basename(active_par2_filename);

    if (!lookup_collection(collection_name, &collection_iter)) {

        /* Collection not found yet, create a new entry */

        gtk_tree_store_append(store, &collection_iter, NULL);

        gtk_tree_store_set(store, &collection_iter, FIELD_COLLECTION_NAME, collection_name,

                                                    FIELD_COLLECTION_NAME_HASH, g_str_hash(collection_name),

                                                    FIELD_FILENAME, collection_name,

                                                    FIELD_PROGRESS_PULSE, 1,

                                                    FIELD_PROGRESS_STR, "",

                                                    -1);

        path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &collection_iter);

        items_to_pulse = g_list_prepend(items_to_pulse, gtk_tree_row_reference_new(GTK_TREE_MODEL(store), path));

        gtk_tree_path_free(path);

    }

    if (lookup_filename(collection_iter, filename, &par2set_iter)) {

        /* PAR2 set was already found, clear all the previous contents */

        gtk_tree_store_remove(store, &par2set_iter);

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

    }

    gtk_tree_store_append(store, &par2set_iter, &collection_iter);

    scroll_to_bottom(par2set_iter);

    gtk_tree_store_set(store, &par2set_iter,    FIELD_FILENAME, filename,

                                                FIELD_FILENAME_HASH, g_str_hash(filename),

                                                FIELD_PAR2_OR_UNPACK_FILENAME, filename,

                                                FIELD_ACTION, ACTION_PAR2,

                                                FIELD_ACTION_STR, _("PAR2 repair"),

                                                FIELD_PROGRESS_STR, _("Now verifying files"),

                                                FIELD_PROGRESS_PULSE, 1,

                                                -1);

    path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &par2set_iter);

    items_to_pulse = g_list_prepend(items_to_pulse, gtk_tree_row_reference_new(GTK_TREE_MODEL(store), path));

    gtk_tree_path_free(path);

    g_free(filename);

}

static void

par2_load_progress_update (NntpgrabGlue *obj, const char *collection_name, const char *active_par2_filename, const char *filename, double progress, gpointer data)

{

    GtkTreeIter collection_iter;

    GtkTreeIter par2set_iter;

    GtkTreeIter filename_iter;

    char *par2_filename = g_path_get_basename(active_par2_filename);

    if (!lookup_collection(collection_name, &collection_iter)) {

        par2_begin_verify(glue, collection_name, active_par2_filename, data);

        g_return_if_fail(lookup_collection(collection_name, &collection_iter));

    }

    if (!lookup_filename(collection_iter, par2_filename, &par2set_iter)) {

        par2_begin_verify(glue, collection_name, active_par2_filename, data);

        g_return_if_fail(lookup_filename(collection_iter, par2_filename, &par2set_iter));

    }

    if (lookup_filename(par2set_iter, filename, &filename_iter)) {

        /* Update the contents of the row */

        gtk_tree_store_set(store, &filename_iter, FIELD_PROGRESS_VALUE, (int) (progress), -1);

    } else {

        gtk_tree_store_append(store, &filename_iter, &par2set_iter);

        scroll_to_bottom(filename_iter);

        gtk_tree_store_set(store, &filename_iter,   FIELD_FILENAME, filename,

                                                    FIELD_FILENAME_HASH, g_str_hash(filename),

                                                    FIELD_PROGRESS_VALUE, (int) (progress),

                                                    FIELD_PROGRESS_PULSE, -1,

                                                    -1);

    }

    g_free(par2_filename);

}

static void

par2_recovery_file_loaded (NntpgrabGlue *obj, const char *collection_name, const char *active_par2_filename, const char *filename, int num_new_packets, int num_blocks_found, gpointer data)

{

    GtkTreeIter collection_iter;

    GtkTreeIter par2set_iter;

    GtkTreeIter filename_iter;

    char *msg;

    char *par2_filename = g_path_get_basename(active_par2_filename);

    if (!lookup_collection(collection_name, &collection_iter)) {

        par2_begin_verify(glue, collection_name, active_par2_filename, data);

        g_return_if_fail(lookup_collection(collection_name, &collection_iter));

    }

    g_return_if_fail(lookup_filename(collection_iter, par2_filename, &par2set_iter));

    msg = g_strdup_printf(_("%i new PAR2 recovery blocks found"), num_blocks_found);

    if (lookup_filename(par2set_iter, filename, &filename_iter)) {

        /* Update the contents of the row */

        gtk_tree_store_set(store, &filename_iter,   FIELD_PROGRESS_VALUE, 100,

                                                    FIELD_PROGRESS_STR, msg,

                                                    -1);

    } else {

        gtk_tree_store_append(store, &filename_iter, &par2set_iter);

        scroll_to_bottom(filename_iter);

        gtk_tree_store_set(store, &filename_iter,   FIELD_FILENAME, filename,

                                                    FIELD_FILENAME_HASH, g_str_hash(filename),

                                                    FIELD_PROGRESS_VALUE, 100,

                                                    FIELD_PROGRESS_STR, msg,

                                                    FIELD_PROGRESS_PULSE, -1,

                                                    -1);

    }

    g_free(msg);

    g_free(par2_filename);

    // TODO: Process num_new_packets

}

static void

par2_file_loaded (NntpgrabGlue *obj, const char *collection_name, const char *active_par2_filename, const char *filename, const char *state, int num_blocks_found, int num_blocks_expected, gpointer data)

{

    GtkTreeIter collection_iter;

    GtkTreeIter par2set_iter;

    GtkTreeIter filename_iter;

    char *msg;

    int progress;

    char *par2_filename = g_path_get_basename(active_par2_filename);

    if (!lookup_collection(collection_name, &collection_iter)) {

        par2_begin_verify(glue, collection_name, active_par2_filename, data);

        g_return_if_fail(lookup_collection(collection_name, &collection_iter));

    }

    g_return_if_fail(lookup_filename(collection_iter, par2_filename, &par2set_iter));

    if (!strcmp(state, "MISSING")) {

        msg = g_strdup(_("File is missing"));

        progress = 0;

    } else if (!strcmp(state, "NO_NEW_BLOCKS_FOUND")) {

        msg = g_strdup(_("No new blocks found"));

        progress = 100;

    } else if (num_blocks_expected == num_blocks_found) {

        progress = 100;

        msg = g_strdup(_("File is complete"));

    } else {

        double progress_tmp = num_blocks_found;

        progress_tmp /= num_blocks_expected;

        progress_tmp *= 100.0;

        progress = (int) progress_tmp;

        msg = g_strdup_printf(_("%i blocks found (expected: %i)"), num_blocks_found, num_blocks_expected);

    }

    if (lookup_filename(par2set_iter, filename, &filename_iter)) {

        /* Update the contents of the row */

        gtk_tree_store_set(store, &filename_iter,   FIELD_PROGRESS_VALUE, progress,

                                                    FIELD_PROGRESS_STR, msg,

                                                    FIELD_PROGRESS_PULSE, -1,

                                                    -1);

    } else {

        gtk_tree_store_append(store, &filename_iter, &par2set_iter);

        scroll_to_bottom(filename_iter);

        gtk_tree_store_set(store, &filename_iter,   FIELD_FILENAME, filename,

                                                    FIELD_FILENAME_HASH, g_str_hash(filename),

                                                    FIELD_PROGRESS_VALUE, progress,

                                                    FIELD_PROGRESS_STR, msg,

                                                    FIELD_PROGRESS_PULSE, -1,

                                                    -1);

    }

    g_free(msg);

    g_free(par2_filename);

    // TODO: Update the row of the PAR2 set itself with the new progress

}

static void

par2_repair_progress_update (NntpgrabGlue *obj, const char *collection_name, const char *active_par2_filename, double progress, gpointer data)

{

    GtkTreeIter collection_iter;

    GtkTreeIter par2set_iter;

    char *par2_filename = g_path_get_basename(active_par2_filename);

    if (!lookup_collection(collection_name, &collection_iter)) {

        par2_begin_verify(glue, collection_name, active_par2_filename, data);

        g_return_if_fail(lookup_collection(collection_name, &collection_iter));

    }

    g_return_if_fail(lookup_filename(collection_iter, par2_filename, &par2set_iter));

    gtk_tree_store_set(store, &par2set_iter,    FIELD_PROGRESS_VALUE, (int) (progress),

                                                FIELD_PROGRESS_STR, _("Repairing"),

                                                FIELD_PROGRESS_PULSE, -1,

                                                -1);

    g_free(par2_filename);

}

static void

par2_repair_failure (NntpgrabGlue *obj, const char *collection_name, const char *active_par2_filename, const char *message, int num_blocks_more_required, gpointer data)

{

    GtkTreeIter collection_iter;

    GtkTreeIter par2set_iter;

    char *msg;

    char *par2_filename = g_path_get_basename(active_par2_filename);

    if (!lookup_collection(collection_name, &collection_iter)) {

        par2_begin_verify(glue, collection_name, active_par2_filename, data);

        g_return_if_fail(lookup_collection(collection_name, &collection_iter));

    }

    gtk_tree_store_set(store, &collection_iter, FIELD_PROGRESS_PULSE, -1, -1);

    g_return_if_fail(lookup_filename(collection_iter, par2_filename, &par2set_iter));

    if (num_blocks_more_required == -1) {

        msg = g_strdup(message);

    } else {

        msg = g_strdup_printf(_("PAR2 repair failed: %i more blocks required"), num_blocks_more_required);

    }

    gtk_tree_store_set(store, &par2set_iter,    FIELD_PROGRESS_VALUE, 100,

                                                FIELD_PROGRESS_STR, msg,

                                                FIELD_PROGRESS_PULSE, -1,

                                                -1);

    g_free(msg);

    g_free(par2_filename);

}

static void

par2_repair_success (NntpgrabGlue *obj, const char *collection_name, const char *active_par2_filename, gpointer data)

{

    GtkTreeIter collection_iter;

    GtkTreeIter par2set_iter;

    char *par2_filename = g_path_get_basename(active_par2_filename);

    if (!lookup_collection(collection_name, &collection_iter)) {

        par2_begin_verify(glue, collection_name, active_par2_filename, data);

        g_return_if_fail(lookup_collection(collection_name, &collection_iter));

    }

    gtk_tree_store_set(store, &collection_iter, FIELD_PROGRESS_PULSE, -1, -1);

    g_return_if_fail(lookup_filename(collection_iter, par2_filename, &par2set_iter));

    gtk_tree_store_set(store, &par2set_iter,    FIELD_PROGRESS_VALUE, 100,

                                                FIELD_PROGRESS_STR, _("PAR2 repair succeeded"),

                                                FIELD_PROGRESS_PULSE, -1,

                                                -1);

    g_free(par2_filename);

}

static void

par2_no_repair_required (NntpgrabGlue *obj, const char *collection_name, const char *active_par2_filename, gpointer data)

{

    GtkTreeIter collection_iter;

    GtkTreeIter par2set_iter;

    char *par2_filename = g_path_get_basename(active_par2_filename);

    if (!lookup_collection(collection_name, &collection_iter)) {

        par2_begin_verify(glue, collection_name, active_par2_filename, data);

        g_return_if_fail(lookup_collection(collection_name, &collection_iter));

    }

    gtk_tree_store_set(store, &collection_iter, FIELD_PROGRESS_PULSE, -1, -1);

    g_return_if_fail(lookup_filename(collection_iter, par2_filename, &par2set_iter));

    gtk_tree_store_set(store, &par2set_iter,    FIELD_PROGRESS_VALUE, 100,

                                                FIELD_PROGRESS_STR, _("No repair needed"),

                                                FIELD_PROGRESS_PULSE, -1,

                                                -1);

    g_free(par2_filename);

}

static void

unpack_progress_update (NntpgrabGlue *obj, const char *collection_name, const char *filename, double progress, gpointer data)

{

    GtkTreeIter collection_iter;

    GtkTreeIter filename_iter;

    int pulse = -1;

    char *unpack_filename = g_path_get_basename(filename);

    if (!lookup_collection(collection_name, &collection_iter)) {

        /* Collection not found yet, create a new entry */

        gtk_tree_store_append(store, &collection_iter, NULL);

        gtk_tree_store_set(store, &collection_iter, FIELD_COLLECTION_NAME, collection_name,

                                                    FIELD_COLLECTION_NAME_HASH, g_str_hash(collection_name),

                                                    FIELD_FILENAME, collection_name,

                                                    FIELD_PROGRESS_STR, "",

                                                    -1);

    }

    if (progress <= 0 ) {

        GtkTreePath *path;

        progress = 0;

        pulse = 1;

        gtk_tree_store_set(store, &collection_iter, FIELD_PROGRESS_PULSE, pulse, -1);

        path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &collection_iter);

        items_to_pulse = g_list_prepend(items_to_pulse, gtk_tree_row_reference_new(GTK_TREE_MODEL(store), path));

        gtk_tree_path_free(path);

    }

    if (progress == 1.0) {

        gtk_tree_store_set(store, &collection_iter, FIELD_PROGRESS_PULSE, -1, -1);

    }

    if (lookup_filename(collection_iter, unpack_filename, &filename_iter)) {

        /* Unpack file was already found yet, update it */

        gtk_tree_store_set(store, &filename_iter,   FIELD_PROGRESS_VALUE, (int) (progress * 100),

                                                    FIELD_PROGRESS_PULSE, pulse,

                                                    -1);

        if (progress == 1.0) {

            gtk_tree_store_set(store, &filename_iter, FIELD_PROGRESS_STR, _("Unpack completed"), -1);

        }

    } else {

        /* Create a new entry */

        gtk_tree_store_append(store, &filename_iter, &collection_iter);

        scroll_to_bottom(filename_iter);

        gtk_tree_store_set(store, &filename_iter,   FIELD_FILENAME, unpack_filename,

                                                    FIELD_FILENAME_HASH, g_str_hash(unpack_filename),

                                                    FIELD_PAR2_OR_UNPACK_FILENAME, unpack_filename,

                                                    FIELD_ACTION, ACTION_UNPACK,

                                                    FIELD_ACTION_STR, _("Unpack"),

                                                    FIELD_PROGRESS_VALUE, (int) (progress * 100),

                                                    FIELD_PROGRESS_STR, _("Now unpacking"),

                                                    FIELD_PROGRESS_PULSE, pulse,

                                                    -1);

    }

    if (pulse > 0) {

        GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &filename_iter);

        items_to_pulse = g_list_prepend(items_to_pulse, gtk_tree_row_reference_new(GTK_TREE_MODEL(store), path));

        gtk_tree_path_free(path);

    }

    g_free(unpack_filename);

}

static void

unpack_message_received (NntpgrabGlue *obj, const char *collection_name, const char *filename, const char *message, gpointer data)

{

    GtkTreeIter collection_iter;

    GtkTreeIter filename_iter;

    char *unpack_filename = g_path_get_basename(filename);

    if (!lookup_collection(collection_name, &collection_iter)) {

        /* Collection not found yet, create a new entry */

        gtk_tree_store_append(store, &collection_iter, NULL);

        gtk_tree_store_set(store, &collection_iter, FIELD_COLLECTION_NAME, collection_name,

                                                    FIELD_COLLECTION_NAME_HASH, g_str_hash(collection_name),

                                                    FIELD_FILENAME, collection_name,

                                                    FIELD_PROGRESS_STR, "",

                                                    -1);

    }

    if (lookup_filename(collection_iter, unpack_filename, &filename_iter)) {

        /* Unpack file was already found yet, update it */

        gtk_tree_store_set(store, &filename_iter, FIELD_PROGRESS_STR, message, -1);

    } else {

        /* Create a new entry */

        gtk_tree_store_append(store, &filename_iter, &collection_iter);

        scroll_to_bottom(filename_iter);

        gtk_tree_store_set(store, &filename_iter,   FIELD_FILENAME, unpack_filename,

                                                    FIELD_FILENAME_HASH, g_str_hash(unpack_filename),

                                                    FIELD_PAR2_OR_UNPACK_FILENAME, unpack_filename,

                                                    FIELD_ACTION, ACTION_UNPACK,

                                                    FIELD_ACTION_STR, _("Unpack"),

                                                    FIELD_PROGRESS_STR, message,

                                                    -1);

    }

    g_free(unpack_filename);

}

static void

unpack_working_archive_changed (NntpgrabGlue *obj, const char *collection_name, const char *filename, const char *working_archive, gpointer data)

{

    GtkTreeIter collection_iter;

    GtkTreeIter filename_iter;

    char *msg;

    char *unpack_filename = g_path_get_basename(filename);

    if (!lookup_collection(collection_name, &collection_iter)) {

        /* Collection not found yet, create a new entry */

        gtk_tree_store_append(store, &collection_iter, NULL);

        gtk_tree_store_set(store, &collection_iter, FIELD_COLLECTION_NAME, collection_name,

                                                    FIELD_COLLECTION_NAME_HASH, g_str_hash(collection_name),

                                                    FIELD_FILENAME, collection_name,

                                                    FIELD_PROGRESS_STR, "",

                                                    -1);

    }

    msg = g_strdup_printf(_("Now unpacking archive '%s'"), working_archive);

    if (lookup_filename(collection_iter, unpack_filename, &filename_iter)) {

        /* Unpack file was already found yet, update it */

        gtk_tree_store_set(store, &filename_iter, FIELD_PROGRESS_STR, msg, -1);

    } else {

        /* Create a new entry */

        gtk_tree_store_append(store, &filename_iter, &collection_iter);

        scroll_to_bottom(filename_iter);

        gtk_tree_store_set(store, &filename_iter,   FIELD_FILENAME, unpack_filename,

                                                    FIELD_FILENAME_HASH, g_str_hash(unpack_filename),

                                                    FIELD_PAR2_OR_UNPACK_FILENAME, unpack_filename,

                                                    FIELD_ACTION, ACTION_UNPACK,

                                                    FIELD_ACTION_STR, _("Unpack"),

                                                    FIELD_PROGRESS_STR, msg,

                                                    -1);

    }

    g_free(msg);

    g_free(unpack_filename);

}

static void

plugin_event_cb(NntpgrabGlue *obj, const char *plugin_name, const char *event_name, const char **values, gpointer data)

{

    if (!strcmp(plugin_name, "PAR2")) {

        if (!strcmp(event_name, "par2_begin_verify")) {

            par2_begin_verify(glue, values[0], values[1], data);

        } else if (!strcmp(event_name, "par2_load_progress_update")) {

            par2_load_progress_update(glue, values[0], values[1], values[2], g_ascii_strtod(values[3], NULL), data);

        } else if (!strcmp(event_name, "par2_recovery_file_loaded")) {

            par2_recovery_file_loaded(glue, values[0], values[1], values[2], atoi(values[3]), atoi(values[4]), data);

        } else if (!strcmp(event_name, "par2_file_loaded")) {

            par2_file_loaded(glue, values[0], values[1], values[2], values[3], atoi(values[4]), atoi(values[5]), data);

        } else if (!strcmp(event_name, "par2_repair_progress_update")) {

            par2_repair_progress_update(glue, values[0], values[1], g_ascii_strtod(values[2], NULL), data);

        } else if (!strcmp(event_name, "par2_repair_failure")) {

            par2_repair_failure(glue, values[0], values[1], values[2], atoi(values[3]), data);

        } else if (!strcmp(event_name, "par2_repair_success")) {

            par2_repair_success(glue, values[0], values[1], data);

        } else if (!strcmp(event_name, "par2_no_repair_required")) {

            par2_no_repair_required(glue, values[0], values[1], data);

        } else {

            g_warning("Unknown plugin event received from %s plugin: %s\n", plugin_name, event_name);

        }

    } else if (!strcmp(plugin_name, "Unpack")) {

        if (!strcmp(event_name, "unpack_progress_update")) {

            unpack_progress_update(glue, values[0], values[1], g_ascii_strtod(values[2], NULL), data);

        } else if (!strcmp(event_name, "unpack_message_received")) {

            unpack_message_received(glue, values[0], values[1], values[2], data);

        } else if (!strcmp(event_name, "unpack_working_archive_changed")) {

            unpack_working_archive_changed(glue, values[0], values[1], values[2], data);

        } else if (!strcmp(event_name, "unpack_success")) {

            // already handled in unpack_progress_update

        } else if (!strcmp(event_name, "unpack_failure")) {

            // already handled in unpack_progress_update

        } else {

            g_warning("Unknown plugin event received from %s plugin: %s\n", plugin_name, event_name);

        }

    }

}

static gboolean

update_items_to_pulse(gpointer data)

{

    GList *list = items_to_pulse;

    while (list) {

        GtkTreeRowReference *ref = list->data;

        GtkTreeIter iter;

        GtkTreePath *path;

        int pulse_val;

        if (!gtk_tree_row_reference_valid(ref)) {

            items_to_pulse = list = g_list_remove(items_to_pulse, ref);

            gtk_tree_row_reference_free(ref);

            continue;

        }

        path = gtk_tree_row_reference_get_path(ref);

        gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iter, path);

        gtk_tree_path_free(path);

        gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, FIELD_PROGRESS_PULSE, &pulse_val, -1);

        if (pulse_val == -1) {

            items_to_pulse = list = g_list_remove(items_to_pulse, ref);

            gtk_tree_row_reference_free(ref);

            continue;

        }

        pulse_val++;

        gtk_tree_store_set(store, &iter, FIELD_PROGRESS_PULSE, pulse_val, -1);

        list = g_list_next(list);

    }

    /* Come back here in a few moments*/

    return TRUE;

}

void

gui_par2_initialize(void)

{

    GtkCellRenderer *cellRenderer;

    GtkTreeViewColumn *col;

    treeviewPAR2AndUnpack = nntpgrab_gui_base_get_widget("treeviewPAR2AndUnpack");

    cellRenderer = gtk_cell_renderer_text_new();

    col = gtk_tree_view_column_new_with_attributes(_("Filename"), cellRenderer, "text", 5, NULL);

    gtk_tree_view_column_set_resizable(col, TRUE);

    gtk_tree_view_column_set_reorderable(col, TRUE);

    gtk_tree_view_insert_column(GTK_TREE_VIEW(treeviewPAR2AndUnpack), col, -1);

    cellRenderer = gtk_cell_renderer_text_new();

    col = gtk_tree_view_column_new_with_attributes(_("Action"), cellRenderer, "text", 3, NULL);

    gtk_tree_view_column_set_resizable(col, TRUE);

    gtk_tree_view_column_set_reorderable(col, TRUE);

    gtk_tree_view_insert_column(GTK_TREE_VIEW(treeviewPAR2AndUnpack), col, -1);

    cellRenderer = gtk_cell_renderer_progress_new();

#if GTK_CHECK_VERSION(2,12,0)

    col = gtk_tree_view_column_new_with_attributes(_("Progress"), cellRenderer, "value", 7, "text", 8, "pulse", 9, NULL);

#else

    col = gtk_tree_view_column_new_with_attributes(_("Progress"), cellRenderer, "value", 7, "text", 8, NULL);

#endif

    gtk_tree_view_column_set_resizable(col, TRUE);

    gtk_tree_view_column_set_reorderable(col, TRUE);

    gtk_tree_view_insert_column(GTK_TREE_VIEW(treeviewPAR2AndUnpack), col, -1);

    store = gtk_tree_store_new (LAST_FIELD,

                                G_TYPE_STRING,  /* FIELD_COLLECTION_NAME */

                                G_TYPE_UINT,    /* FIELD_COLLECTION_NAME_HASH */

                                G_TYPE_INT,     /* FIELD_ACTION */

                                G_TYPE_STRING,  /* FIELD_ACTION_STR */

                                G_TYPE_STRING,  /* FIELD_PAR2_OR_UNPACK_FILENAME */

                                G_TYPE_STRING,  /* FIELD_FILENAME */

                                G_TYPE_UINT,    /* FIELD_FILENAME_HASH */

                                G_TYPE_INT,     /* FIELD_PROGRESS_VALUE */

                                G_TYPE_STRING,  /* FIELD_PROGRESS_STR */

                                G_TYPE_UINT    /* FIELD_PROGRESS_PULSE */

                               );

    gtk_tree_view_set_model(GTK_TREE_VIEW(treeviewPAR2AndUnpack), GTK_TREE_MODEL(store));

    nntpgrab_glue_signal_connect(glue, "plugin_event", NG_CALLBACK(plugin_event_cb), NULL);

    g_timeout_add(500, update_items_to_pulse, NULL);

}