NNTPGrab

#define NNTPGRAB_PLUGIN_API_VERSION       20111201

 * @config_get_config_folder:      Retrieve the folder where all configuration files can be stored. Needs to be free'd using ng_free

    char *(*config_get_config_folder) (void);

 * configuration_get_config_folder:

 *

 * Retrieve the folder where all configuration files can be stored

 *

 * Returns:             The folder where all configuration files can be stored. Needs to be g_free'd after use

 */

char *

configuration_get_config_folder(void)

{

    if (g_getenv("NNTPGRAB_CONFIG_DIR")) {

        return g_build_path(G_DIR_SEPARATOR_S, g_getenv("NNTPGRAB_CONFIG_DIR"), "NNTPGrab", NULL);

    } else {

        return g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), "NNTPGrab", NULL);

    }

}

/**

    char *config_folder;

    /* Free the already known settings */

    /* Try to load the config file */

    config_folder = configuration_get_config_folder();

    filename = g_build_filename(config_folder, "nntpgrab.conf", NULL);

    g_free(config_folder);

    char *config_folder;

    /* Create the folder ~/.config/NNTPGrab if it didn't exist already */

    config_folder = configuration_get_config_folder();

    g_mkdir_with_parents(config_folder, 0700);

    /* Write the configuration to disk */

    filename = g_build_filename(config_folder, "nntpgrab.conf", NULL);

    g_free(config_folder);

char            *configuration_get_config_folder(void);

    obj->core_funcs.config_get_config_folder = configuration_get_config_folder;

#include 

#include "nntpgrab_utils.h"

typedef struct _counter_server_data {

    NGConfigServer server_info;

    guint64 num_bytes_downloaded;

    guint64 num_parts_succeeded;

    guint64 num_parts_failed;

} CounterServerData;

typedef struct _counter_data {

    time_t stamp_started;

    gboolean data_changed_since_last_announce;

    GList *collected_data;     /* List contains CounterServerData elements */

} CounterData;

static void plugin_counter_free_cached_data(NGPlugin *plugin_data);

static gboolean plugin_counter_load_cached_data(NGPlugin *plugin_data, char **errmsg);

static gboolean plugin_counter_save_cached_data(NGPlugin *plugin_data, char **errmsg);

static gboolean plugin_counter_send_update_announcement(gpointer data);

static CounterServerData *plugin_counter_lookup_server(NGPlugin *plugin_data, const char *servername);

static void plugin_counter_part_done_cb(NGPlugin *plugin_data, const char *servername, int conn_id, const char *collection_name, const char *subject, int part_num, int size, gpointer data);

static void plugin_counter_part_failed_cb(NGPlugin *plugin_data, const char *servername, int conn_id, const char *collection_name, const char *subject, int part_num,int size, gboolean all_servers_tried);

    ng_plugin_create_event(plugin_data, "counter_data_changed", 0);

    ng_plugin_set_required_event(plugin_data, "part_failed");

    ng_plugin_connect_event(plugin_data, "part_done", NG_PLUGIN_FUNCTION(plugin_counter_part_done_cb), NULL);

    ng_plugin_connect_event(plugin_data, "part_failed", NG_PLUGIN_FUNCTION(plugin_counter_part_failed_cb), NULL);

    plugin_data->priv = g_slice_new0(CounterData);

    if (!plugin_counter_load_cached_data(plugin_data, errmsg)) {

        return FALSE;

    }

    /* Make sure the plugin sends update announcements every 10 seconds */

    g_timeout_add_seconds(10, plugin_counter_send_update_announcement, plugin_data);

    plugin_counter_send_update_announcement(plugin_data);

    char *errmsg = NULL;

    if (!plugin_counter_save_cached_data(plugin_data, &errmsg)) {

        ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_WARNING, errmsg);

        g_free(errmsg);

    }

    plugin_counter_free_cached_data(plugin_data);

    g_slice_free(CounterData, plugin_data->priv);

    plugin_data->priv = NULL;

static NGVariant *

get_collected_data(NGPlugin *plugin_data, NGVariant *parameters, char **errmsg)

{

    GVariant *variant_counter;

    GVariant *variant_servers;

    GVariantBuilder *builder_counter;

    GVariantBuilder *builder_servers;

    CounterData *counter_data;

    NGList *servers;

    NGList *list;

    g_return_if_fail(plugin_data != NULL);

    counter_data = (CounterData*) plugin_data->priv;

    g_return_if_fail(counter_data != NULL);

    builder_counter = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));

    g_variant_builder_add(builder_counter, "{sv}", "stamp_started", g_variant_new_uint64((guint64) counter_data->stamp_started));

    builder_servers = g_variant_builder_new(G_VARIANT_TYPE("av"));

    servers = plugin_data->core_funcs.config_get_avail_servers();

    list = servers;

    while (list) {

        const char *servername = (const char*) list->data;

        GVariant *variant_server;

        GVariantBuilder *builder_server;

        CounterServerData *server_data;

        server_data = plugin_counter_lookup_server(plugin_data, servername);

        g_return_val_if_fail(server_data != NULL, NULL);

        builder_server = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));

        g_variant_builder_add(builder_server, "{sv}", "servername", g_variant_new_string(server_data->server_info.servername));

        g_variant_builder_add(builder_server, "{sv}", "num_bytes_downloaded", g_variant_new_uint64(server_data->num_bytes_downloaded));

        g_variant_builder_add(builder_server, "{sv}", "num_parts_succeeded", g_variant_new_uint64(server_data->num_parts_succeeded));

        g_variant_builder_add(builder_server, "{sv}", "num_parts_failed", g_variant_new_uint64(server_data->num_parts_failed));

        variant_server = g_variant_builder_end(builder_server);

        g_variant_builder_add(builder_servers, "v", variant_server);

        list = ng_list_next(list);

    }

    variant_servers = g_variant_builder_end(builder_servers);

    g_variant_builder_add(builder_counter, "{sv}", "collected_data", variant_servers);

    plugin_data->core_funcs.config_free_avail_servers(servers);

    variant_counter = g_variant_builder_end(builder_counter);

    return (NGVariant*) variant_counter;

}

static NGVariant *

reset_collected_data(NGPlugin *plugin_data, NGVariant *parameters, char **errmsg)

{

    plugin_counter_free_cached_data(plugin_data);

    /* Manually emit an update announcement so that all frontends

     * will know that the collected data was reset */

    plugin_counter_send_update_announcement(plugin_data);

    return (NGVariant*) g_variant_new_boolean(TRUE);

}

    if (!g_strcmp0(method, "get_collected_data")) {

        return get_collected_data(plugin_data, parameters, errmsg);

    } else if (!g_strcmp0(method, "reset")) {

        return reset_collected_data(plugin_data, parameters, errmsg);

    } else {

        return NULL;

    }

plugin_counter_free_cached_data(NGPlugin *plugin_data)

    CounterData *counter_data;

    GList *list;

    g_return_if_fail(plugin_data != NULL);

    counter_data = (CounterData*) plugin_data->priv;

    g_return_if_fail(counter_data != NULL);

    list = counter_data->collected_data;

    while (list) {

        CounterServerData *server_data = (CounterServerData*) list->data;

        g_slice_free(CounterServerData, server_data);

        list = g_list_next(list);

    }

    g_list_free(counter_data->collected_data);

    counter_data->collected_data = NULL;

    counter_data->stamp_started = time(NULL);

    counter_data->data_changed_since_last_announce = TRUE;

static gboolean

plugin_counter_load_cached_data(NGPlugin *plugin_data, char **errmsg)

{

    CounterData *counter_data;

    GKeyFile *keyfile;

    char *config_dir;

    char *filename;

    GError *err = NULL;

    char **groups;

    int i;

    g_return_val_if_fail(plugin_data != NULL, FALSE);

    g_return_val_if_fail(errmsg != NULL, FALSE);

    counter_data = (CounterData*) plugin_data->priv;

    g_return_if_fail(counter_data != NULL);

    counter_data->stamp_started = time(NULL);

    config_dir = plugin_data->core_funcs.config_get_config_folder();

    g_return_val_if_fail(config_dir != NULL, FALSE);

    filename = g_build_filename(config_dir, "plugin_counter.conf", NULL);

    ng_free(config_dir);

    if (!g_file_test(filename, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {

        /* No cached configuration file exists yet */

        return TRUE;

    }

    /* Clean up old entries */

    plugin_counter_free_cached_data(plugin_data);

    /* Load the contents of the configuration file from disk */

    keyfile = g_key_file_new();

    if (!g_key_file_load_from_file(keyfile, filename, G_KEY_FILE_NONE, &err)) {

        *errmsg = g_strdup_printf("Unable to load file '%s': %s", filename, err->message);

        g_error_free(err);

        g_free(filename);

        return FALSE;

    }

    g_free(filename);

    groups = g_key_file_get_groups(keyfile, NULL);

    i = 0;

    while (groups && groups[i] != NULL) {

        CounterServerData *server_data;

        NGConfigServer server_info;

        /* Only read the stamp_started key from the generic group */

        if (!g_strcmp0(groups[i], "generic")) {

            if (!g_key_file_has_key(keyfile, groups[i], "stamp_started", NULL)) {

                counter_data->stamp_started = time(NULL);

            } else {

                counter_data->stamp_started = (time_t) g_key_file_get_uint64(keyfile, groups[i], "stamp_started", NULL);

            }

            i++;

            continue;

        }

        if (!g_key_file_has_key(keyfile, groups[i], "num_bytes_downloaded", NULL) ||

            !g_key_file_has_key(keyfile, groups[i], "num_parts_succeeded", NULL) ||

            !g_key_file_has_key(keyfile, groups[i], "num_parts_failed", NULL)) {

            /* One or more keys weren't found */

            ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_INFO, "Server named '%s' was found in counter plugin configuration file, but is missing some keys", groups[i]);

            i++;

            continue;

        }

        /* All required keys are found */

        if (!plugin_data->core_funcs.config_get_server_info(groups[i], &server_info)) {

            /* Server doesn't exist in current NNTPGrab configuration */

            ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_INFO, "Server named '%s' was found in counter plugin configuration file, but isn't known in the NNTPGrab configuration", groups[i]);

            i++;

            continue;

        }

        server_data = g_slice_new0(CounterServerData);

        server_data->server_info = server_info;

        server_data->num_bytes_downloaded = g_key_file_get_uint64(keyfile, groups[i], "num_bytes_downloaded", NULL);

        server_data->num_parts_succeeded = g_key_file_get_uint64(keyfile, groups[i], "num_parts_succeeded", NULL);

        server_data->num_parts_failed = g_key_file_get_uint64(keyfile, groups[i], "num_parts_failed", NULL);

        counter_data->collected_data = g_list_append(counter_data->collected_data, server_data);

        i++;

    }

    g_key_file_free(keyfile);

    return TRUE;

}

static gboolean

plugin_counter_save_cached_data(NGPlugin *plugin_data, char **errmsg)

{

    GKeyFile *keyfile;

    char *config_dir;

    char *filename;

    GError *err = NULL;

    CounterData *counter_data = (CounterData*) plugin_data->priv;

    GList *list;

    char *contents;

    g_return_val_if_fail(plugin_data != NULL, FALSE);

    g_return_val_if_fail(errmsg != NULL, FALSE);

    g_return_val_if_fail(counter_data != NULL, FALSE);

    keyfile = g_key_file_new();

    g_key_file_set_uint64(keyfile, "generic", "stamp_started", (guint64) counter_data->stamp_started);

    list = counter_data->collected_data;

    while (list) {

        CounterServerData *server_data = (CounterServerData*) list->data;

        g_key_file_set_uint64(keyfile, server_data->server_info.servername, "num_bytes_downloaded", server_data->num_bytes_downloaded);

        g_key_file_set_uint64(keyfile, server_data->server_info.servername, "num_parts_succeeded", server_data->num_parts_succeeded);

        g_key_file_set_uint64(keyfile, server_data->server_info.servername, "num_parts_failed", server_data->num_parts_failed);

        list = g_list_next(list);

    }

    contents = g_key_file_to_data(keyfile, NULL, &err);

    if (!contents) {

        *errmsg = g_strdup(err->message);

        g_error_free(err);

        g_free(contents);

        g_key_file_free(keyfile);

        return FALSE;

    }

    /* Write the configuration to disk */

    config_dir = plugin_data->core_funcs.config_get_config_folder();

    g_return_val_if_fail(config_dir != NULL, FALSE);

    filename = g_build_filename(config_dir, "plugin_counter.conf", NULL);

    g_free(config_dir);

    if (!g_file_set_contents(filename, contents, -1, &err)) {

        *errmsg = g_strdup_printf("Error while saving download counter configuration to file '%s'\n%s", filename, err->message);

        g_error_free(err);

        g_free(contents);

        g_free(filename);

        g_key_file_free(keyfile);

        return FALSE;

    }

    g_free(contents);

    g_free(filename);

    g_key_file_free(keyfile);

    return TRUE;

}

static gboolean

plugin_counter_send_update_announcement(gpointer data)

{

    static int times_been_here = 0;

    CounterData *counter_data;

    NGPlugin *plugin_data = (NGPlugin*) data;

    g_return_val_if_fail(plugin_data != NULL, FALSE);

    g_return_val_if_fail(plugin_data->priv != NULL, FALSE);

    counter_data = (CounterData*) plugin_data->priv;

    /* Only send a new announcement when something got changed */

    if (!counter_data->data_changed_since_last_announce) {

        return TRUE;

    }

    ng_plugin_emit_event(plugin_data, "counter_data_changed", NULL);

    counter_data->data_changed_since_last_announce = FALSE;

    /* Periodically (every 60 seconds) save the cached data back to disk */

    if (times_been_here % 6 == 0) {

        char *errmsg = NULL;

        if (!plugin_counter_save_cached_data(plugin_data, &errmsg)) {

            ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_WARNING, errmsg);

            g_free(errmsg);

        }

    }

    times_been_here++;

    return TRUE;

}

static CounterServerData*

plugin_counter_lookup_server(NGPlugin *plugin_data, const char *servername)

{

    CounterData *counter_data;

    CounterServerData *server_data;

    GList *list;

    g_return_val_if_fail(plugin_data != NULL, NULL);

    g_return_val_if_fail(servername != NULL, NULL);

    g_return_val_if_fail(plugin_data->priv != NULL, NULL);

    counter_data = (CounterData*) plugin_data->priv;

    list = counter_data->collected_data;

    while (list) {

        server_data = list->data;

        g_return_val_if_fail(server_data != NULL, NULL);

        if (!g_strcmp0(server_data->server_info.servername, servername)) {

            return server_data;

        }

        list = g_list_next(list);

    }

    /* If we got here then there's no entry available for this server. Add it now */

    server_data = g_slice_new0(CounterServerData);

    g_return_val_if_fail(plugin_data->core_funcs.config_get_server_info(servername, &server_data->server_info), NULL);

    server_data->num_bytes_downloaded = 0;

    server_data->num_parts_succeeded = 0;

    server_data->num_parts_failed = 0;

    counter_data->collected_data = g_list_append(counter_data->collected_data, server_data);

    return server_data;

}

plugin_counter_part_done_cb(NGPlugin *plugin_data, const char *servername, int conn_id, const char *collection_name, const char *subject, int part_num, int size, gpointer data)

    CounterData *counter_data;

    CounterServerData *server_data;

    g_return_if_fail(plugin_data != NULL);

    g_return_if_fail(servername != NULL);

    g_return_if_fail(size >= 0);

    g_return_if_fail(plugin_data->priv != NULL);

    counter_data = (CounterData*) plugin_data->priv;

    server_data = plugin_counter_lookup_server(plugin_data, servername);

    g_return_if_fail(server_data != NULL);

    counter_data->data_changed_since_last_announce = TRUE;

    server_data->num_bytes_downloaded += size;

    server_data->num_parts_succeeded++;

static void

plugin_counter_part_failed_cb(NGPlugin *plugin_data, const char *servername, int conn_id, const char *collection_name, const char *subject, int part_num,int size, gboolean all_servers_tried)

{

    CounterData *counter_data;

    CounterServerData *server_data;

    g_return_if_fail(plugin_data != NULL);

    g_return_if_fail(servername != NULL);

    g_return_if_fail(plugin_data->priv != NULL);

    counter_data = (CounterData*) plugin_data->priv;

    server_data = plugin_counter_lookup_server(plugin_data, servername);

    g_return_if_fail(server_data != NULL);

    counter_data->data_changed_since_last_announce = TRUE;

    server_data->num_parts_failed++;

}

    while (values && values[i]) {

    g_return_val_if_fail(glue != NULL, NULL);

    g_return_val_if_fail(plugin_name != NULL, NULL);

    g_return_val_if_fail(method != NULL, NULL);

    g_return_val_if_fail(parameters != NULL, NULL);

void

nntpgrab_utils_get_readable_time_stamp(time_t stamp, char *stamp_str, int stamp_str_len)

{

    struct tm *now;

    static int nugrft_once = 0;

    if (stamp <= 0) {

        stamp_str[0] = '\0';

        return;

    }

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

        // Date could not be parsed

        stamp_str[0] = '\0';

        return;

    }

    if (strftime(stamp_str, stamp_str_len, "%c", now) == 0) {

        if (!nugrft_once) {

            g_error(__FILE__ ":%i buffer too small", __LINE__);

            nugrft_once = 1;

        }

    }

}

 * nntpgrab_utils_get_readable_time_stamp:

 * @stamp:                             The time stamp which needs to be transformed to a readable notation

 * @stamp_str:                 (out):  Pointer to the location where the human readable notation (like 'Friday February 6 2009 - 22:15') can be saved

 * @stamp_str_len:                     The maximum length of the time_remaining_str buffer

 *

 * Transform a time stamp into a human readable value

 */

void             nntpgrab_utils_get_readable_time_stamp(time_t stamp, char *stamp_str, int stamp_str_len);

/**

nntpgrab_utils_get_readable_time_stamp

void

gui_plugins_cleanup(void)

{

#ifdef HAVE_LIBPEAS

    if (extension_set != NULL) {

        g_object_unref(extension_set);

        extension_set = NULL;

    }

#endif

}

#include "nntpgrab_utils.h"

#include "gui.h"

    plugin->counter_data = g_slice_new0(CounterData);

    g_slice_free(CounterData, plugin->counter_data);

static void

    NGVariant *ret;

    ret = nntpgrab_glue_plugins_call_plugin_method(plugin->glue,

                                                   PLUGIN_NAME,

                                                   "reset",

                                                   (NGVariant*) g_variant_new("()"),

                                                   &errmsg);

    g_variant_unref((GVariant*) ret);

/* Copied over from plugin_counter.c */

free_cached_data(CounterData *counter_data)

    GList *list;

    g_return_if_fail(counter_data != NULL);

    list = counter_data->collected_data;

    while (list) {

        CounterServerData *server_data = (CounterServerData*) list->data;

        g_slice_free(CounterServerData, server_data);

        list = g_list_next(list);

    }

    g_list_free(counter_data->collected_data);

    counter_data->collected_data = NULL;

}

static void

update_counter_user_interface(NntpgrabCounterPlugin *plugin)

{

    GtkWidget *lblPluginCounterMeasuredSince;

    GtkListStore *store;

    GList *list;

    char stamp[64];

    g_return_if_fail(plugin->counter_data != NULL);

    nntpgrab_utils_get_readable_time_stamp(plugin->counter_data->stamp_started, stamp, sizeof(stamp));

    lblPluginCounterMeasuredSince = nntpgrab_gui_base_get_widget("lblPluginCounterMeasuredSince");

    gtk_label_set_text(GTK_LABEL(lblPluginCounterMeasuredSince), stamp);

    store = GTK_LIST_STORE(nntpgrab_gui_base_get_object("liststorePluginCounter"));

    g_return_if_fail(store != NULL);

    gtk_list_store_clear(store);

    list = plugin->counter_data->collected_data;

    while (list) {

        CounterServerData *server_data = (CounterServerData*) list->data;

        char file_size[64];

        GtkTreeIter iter;

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

        nntpgrab_utils_calculate_file_size(server_data->num_bytes_downloaded, file_size, sizeof(file_size));

        gtk_list_store_append(store, &iter);

        gtk_list_store_set(store, &iter, 0, server_data->servername, 1, file_size, 2, server_data->num_parts_succeeded, 3, server_data->num_parts_failed, -1);

        list = g_list_next(list);

    }

}

static void

process_collected_data(CounterData *counter_data, GVariant *servers_data)

{

    GVariantIter *iter_servers;

    GVariant *variant_server_data;

    g_variant_get(servers_data, "av", &iter_servers);

    while (g_variant_iter_loop(iter_servers, "v", &variant_server_data)) {

        char *key;

        GVariant *value;

        GVariantIter *iter_server;

        CounterServerData *server_data = g_slice_new0(CounterServerData);

        g_variant_get(variant_server_data, "a{sv}", &iter_server);

        while (g_variant_iter_loop(iter_server, "{sv}", &key, &value)) {

            if (!g_strcmp0(key, "servername")) {

                strncpy(server_data->servername, g_variant_get_string(value, NULL), sizeof(server_data->servername) - 1);

            } else if (!g_strcmp0(key, "num_bytes_downloaded")) {

                server_data->num_bytes_downloaded = g_variant_get_uint64(value);

            } else if (!g_strcmp0(key, "num_parts_succeeded")) {

                server_data->num_parts_succeeded = g_variant_get_uint64(value);

            } else if (!g_strcmp0(key, "num_parts_failed")) {

                server_data->num_parts_failed = g_variant_get_uint64(value);

            } else {

                g_print(__FILE__ ":%i Invalid parameter detected in result from 'get_collected_data' call: %s\n", __LINE__, key);

            }

        }

        counter_data->collected_data = g_list_append(counter_data->collected_data, server_data);

    }

}

static void

retrieve_collected_data(NntpgrabCounterPlugin *plugin)

{

    NGVariant *ret;

    GVariantIter *iter;

    char *key;

    GVariant *value;

    char *errmsg = NULL;

                                                   (NGVariant*) g_variant_new("()"),

    free_cached_data(plugin->counter_data);

    g_variant_get((GVariant*) ret, "a{sv}", &iter);

    while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {

        if (!g_strcmp0(key, "stamp_started")) {

            plugin->counter_data->stamp_started = (time_t) g_variant_get_uint64(value);

        } else if (!g_strcmp0(key, "collected_data")) {

            process_collected_data(plugin->counter_data, value);

        } else {

            g_print(__FILE__ ":%i Invalid parameter detected in result from 'get_collected_data' call: %s\n", __LINE__, key);

        }

    }

    g_variant_iter_free(iter);

    g_variant_unref((GVariant*) ret);

menuItemDownloadCounter_clicked(GtkWidget *widget, gpointer data)

{

    NntpgrabCounterPlugin *plugin = NNTPGRAB_COUNTER_PLUGIN(data);

    g_return_if_fail(plugin != NULL);

    gtk_widget_show(plugin->windowPluginCounter);

    gtk_window_present(GTK_WINDOW(plugin->windowPluginCounter));

    retrieve_collected_data(plugin);

    update_counter_user_interface(plugin);

}

static void

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

{

    NntpgrabCounterPlugin *plugin = NNTPGRAB_COUNTER_PLUGIN(data);

    g_return_if_fail(plugin != NULL);

    if (!strcmp(plugin_name, "Download counter")) {

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

            /* Only retrieve the new statistics when the statistics window is currently visible */

            GtkWidget *windowPluginCounter = nntpgrab_gui_base_get_widget("windowPluginCounter");

            if (!gtk_widget_get_visible(windowPluginCounter)) {

                return;

            }

            retrieve_collected_data(plugin);

            update_counter_user_interface(plugin);

        }

    }

}

static void

    GtkWidget *btnCounterPluginReset;

    btnCounterPluginReset = nntpgrab_gui_base_get_widget("btnCounterPluginReset");

    g_return_if_fail(btnCounterPluginReset != NULL);

    g_signal_connect(btnCounterPluginReset, "clicked", G_CALLBACK(btnCounterPluginReset_clicked), plugin);

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

typedef struct _counter_server_data {

    char servername[128];

    guint64 num_bytes_downloaded;

    guint64 num_parts_succeeded;

    guint64 num_parts_failed;

} CounterServerData;

typedef struct _counter_data {

    time_t stamp_started;

    GList *collected_data;     /* List contains CounterServerData elements */

} CounterData;

    CounterData *counter_data;

libnntpgrab_plugin_counter_gtk_la_CFLAGS = -I$(top_srcdir)/nntpgrab_core -I$(top_srcdir)/base -I$(top_srcdir)/gui_base -I$(top_srcdir)/glue -I$(top_srcdir)/client/gui $(GLIB_CFLAGS) $(GTK3_CFLAGS) $(GTK_CFLAGS) $(LIBPEAS_CFLAGS)

    center-always

    720

    300

                True

                False

                The information shown here will be updated once every 10 seconds

                False

                True

                5

                2

void gui_plugins_cleanup(void);

    /* Unload the GUI plugins before cleaning up the NNTPGrabGlue */

    gui_plugins_cleanup();