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"

#include "config_gui.h"

#include "nntpgrab_utils.h"

#include "nntpgrab_automation.h"

#if GLIB_CHECK_VERSION(2,16,0)

#include 

#endif

static NNTPGrabNZB *nzbfile = NULL;

static char *collection_name = NULL;

static gboolean quick_import = FALSE;

static GtkWidget *filechooserNZB = NULL;

G_MODULE_EXPORT void    on_btnNZBImport_clicked(GtkWidget *caller, gpointer data);

G_MODULE_EXPORT void    on_filechooserNZB_file_set(GtkWidget *caller, gpointer data);

static void

add_filters_to_filechooser(GtkFileChooser *file_chooser)

{

    GtkFileFilter *filter;

    filter = gtk_file_filter_new();

    gtk_file_filter_set_name(filter, "NZB files");

    gtk_file_filter_add_mime_type(filter, "application/x-nzb");

    gtk_file_filter_add_pattern(filter, "*.nzb");

    gtk_file_chooser_add_filter(file_chooser, filter);

    filter = gtk_file_filter_new();

    gtk_file_filter_set_name(filter, "All files");

    gtk_file_filter_add_pattern (filter, "*");

    gtk_file_chooser_add_filter(file_chooser, filter);

}

// Callbacks from the main window

G_MODULE_EXPORT void

on_btnNZBCancel_clicked(GtkWidget *caller, gpointer data)

{

    GtkWidget *windowNZB;

    windowNZB = nntpgrab_gui_base_get_widget("windowNZB");

    gtk_widget_hide(windowNZB);

    gtk_widget_destroy(filechooserNZB);

    filechooserNZB = NULL;

    if (nzbfile) {

        nntpgrab_utils_nzb_file_free(nzbfile);

        nzbfile = NULL;

    }

    if (collection_name) {

        g_free(collection_name);

        collection_name = NULL;

    }

}

G_MODULE_EXPORT void

on_btnImportNZB_clicked(GtkWidget *caller, gpointer data)

{

    GtkWidget *windowNZB;

    GtkWidget *treeNZBFiles;

    GtkWidget *btnNZBImport;

    GtkWidget *hboxNZBFile;

    GtkTreeModel *model;

    ConfigGUIOpts opts;

    windowNZB = nntpgrab_gui_base_get_widget("windowNZB");

    treeNZBFiles = nntpgrab_gui_base_get_widget("treeNZBFiles");

    btnNZBImport = nntpgrab_gui_base_get_widget("btnNZBImport");

    hboxNZBFile = nntpgrab_gui_base_get_widget("hboxNZBFile");

    model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeNZBFiles));

    gtk_list_store_clear(GTK_LIST_STORE(model));

    if (filechooserNZB != NULL) {

        on_btnNZBCancel_clicked(windowNZB, data);

    }

    g_return_if_fail(filechooserNZB == NULL);

    filechooserNZB = gtk_file_chooser_button_new(_("Import NZB"), GTK_FILE_CHOOSER_ACTION_OPEN);

    add_filters_to_filechooser(GTK_FILE_CHOOSER(filechooserNZB));

    opts = config_gui_get_opts();

    if (strlen(opts.last_used_nzb_directory) > 0) {

        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooserNZB), opts.last_used_nzb_directory);

    }

    g_signal_connect(G_OBJECT(filechooserNZB), "file_set", G_CALLBACK(on_filechooserNZB_file_set), NULL);

    gtk_box_pack_end(GTK_BOX(hboxNZBFile), filechooserNZB, TRUE, TRUE, 5);

    gtk_widget_show(filechooserNZB);

    gtk_widget_show(windowNZB);

    gtk_widget_set_sensitive(btnNZBImport, FALSE);

    quick_import = FALSE;

}

gboolean

nzb_perform_quick_import(const char *collection_name_tmp, const char *nzb_contents)

{

    GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

    char *errmsg = NULL;

    if (nzbfile) {

        nntpgrab_utils_nzb_file_free(nzbfile);

    }

    nzbfile = nntpgrab_utils_parse_nzb_file(nzb_contents, &errmsg);

    if (!nzbfile) {

        if (!errmsg) {

            errmsg = g_strdup_printf(_("Error occured while reading NZB File"));

        }

        nntpgrab_gui_base_dialog_show(windowMain, errmsg, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK);

        g_free(errmsg);

        return FALSE;

    }

    if (collection_name) {

        g_free(collection_name);

    }

    collection_name = g_strdup(collection_name_tmp);

    nntpgrab_utils_sanitize_collection_name(collection_name);

    quick_import = TRUE;

    on_btnNZBImport_clicked(NULL, NULL);

    return TRUE;

}

G_MODULE_EXPORT void

on_btnQuickImportNZB_clicked(GtkWidget *caller, gpointer data)

{

    GtkWidget *windowMain;

    GtkWidget *dialog;

    ConfigGUIOpts opts = config_gui_get_opts();

    windowMain = nntpgrab_gui_base_get_widget("windowMain");

    dialog = gtk_file_chooser_dialog_new ("Open File",

                        GTK_WINDOW(windowMain),

                        GTK_FILE_CHOOSER_ACTION_OPEN,

                        GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,

                        GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,

                        NULL);

    add_filters_to_filechooser(GTK_FILE_CHOOSER(dialog));

    if (strlen(opts.last_used_nzb_directory) > 0) {

        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), opts.last_used_nzb_directory);

    }

    if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)

    {

        char *filename = NULL;

        char *uri;

        char *contents = NULL;

        char *collection_name;

        char *dirname;

        GError *err = NULL;

        gboolean ret;

#if GTK_CHECK_VERSION(2,10,0)

        GtkRecentManager *recent_manager;

#endif

#if GLIB_CHECK_VERSION(2,16,0)

        GFile *file;

#endif

        uri = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(dialog));

        filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));

#if GLIB_CHECK_VERSION(2,16,0)

        file = g_file_new_for_uri(uri);

        ret = g_file_load_contents(file, NULL, &contents, NULL, NULL, &err);

        g_object_unref(file);

        if (!ret) {

            char *msg = g_strdup_printf("Unable to open uri '%s':\n%s", uri, err->message);

#else

        ret = g_file_get_contents(filename, &contents, NULL, &err);

        if (!ret) {

            char *msg = g_strdup_printf("Unable to open file '%s':\n%s", filename, err->message);

#endif

            nntpgrab_gui_base_dialog_show(windowMain, msg, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK);

            g_free(msg);

            g_error_free(err);

            g_free(uri);

            g_free(filename);

            gtk_widget_destroy (dialog);

            return;

        }

        collection_name = g_path_get_basename(filename);

        nntpgrab_utils_sanitize_text(collection_name, strlen(collection_name));

        nntpgrab_utils_strip_nzb_extension(collection_name);

        if (!nzb_perform_quick_import(collection_name, contents)) {

            g_free(uri);

            g_free(filename);

            g_free(contents);

            gtk_widget_destroy (dialog);

            return;

        }

#if GTK_CHECK_VERSION(2,10,0)

        // Add the filename to the recently used files list

        recent_manager = gtk_recent_manager_get_default();

        gtk_recent_manager_add_item(recent_manager, uri);

#endif

        dirname = g_path_get_dirname(filename);

        if (strlen(dirname) > 1) {

            ConfigGUIOpts opts = config_gui_get_opts();

            strncpy(opts.last_used_nzb_directory, dirname, sizeof(opts.last_used_nzb_directory) - 1);

            config_gui_set_opts(opts);

        }

        g_free(dirname);

        g_free (uri);

        g_free (filename);

    }

    gtk_widget_destroy (dialog);

}

static gboolean

nzb_model_foreach_add_func (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)

{

    NNTPGrabNZBFile *file;

    gboolean flag;

    GtkWidget *windowNZB;

    char *errmsg = NULL;

    gtk_tree_model_get(model, iter, 5, &flag, 6, &file, -1);

    if (!flag) {

        return FALSE;

    }

    if (!nntpgrab_glue_schedular_add_task_to_queue(glue, collection_name, file->subject, file->poster, file->stamp, file->filesize, file->groups, file->segments, &errmsg)) {

        char *msg;

        if (errmsg) {

            msg = g_strdup_printf(_("File could not be added to the download queue:\n%s"), errmsg);

            g_free(errmsg);

        } else {

            msg = g_strdup_printf(_("File could not be added to the download queue"));

        }

        windowNZB = nntpgrab_gui_base_get_widget("windowNZB");

        nntpgrab_gui_base_dialog_show(windowNZB, msg, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK);

        g_free(msg);

    }

    return FALSE;

}

G_MODULE_EXPORT void

on_radioAddToNewCollection_toggled(GtkWidget *caller, gpointer data)

{

    GtkWidget *frameAddToNewCollection;

    GtkWidget *frameAddToExistingCollection;

    frameAddToNewCollection = nntpgrab_gui_base_get_widget("frameAddToNewCollection");

    frameAddToExistingCollection = nntpgrab_gui_base_get_widget("frameAddToExistingCollection");

    gtk_widget_set_sensitive(frameAddToNewCollection, TRUE);

    gtk_widget_set_sensitive(frameAddToExistingCollection, FALSE);

}

G_MODULE_EXPORT void

on_radioAddToExistingCollection_toggled(GtkWidget *caller, gpointer data)

{

    GtkWidget *frameAddToNewCollection;

    GtkWidget *frameAddToExistingCollection;

    frameAddToNewCollection = nntpgrab_gui_base_get_widget("frameAddToNewCollection");

    frameAddToExistingCollection = nntpgrab_gui_base_get_widget("frameAddToExistingCollection");

    gtk_widget_set_sensitive(frameAddToNewCollection, FALSE);

    gtk_widget_set_sensitive(frameAddToExistingCollection, TRUE);

}

G_MODULE_EXPORT void

on_btnSetCollectionNameCancel_clicked(GtkWidget *caller, gpointer data)

{

    gtk_widget_hide(nntpgrab_gui_base_get_widget("windowSetCollectionName"));

}

G_MODULE_EXPORT void

on_btnSetCollectionNameOK_clicked(GtkWidget *caller, gpointer data)

{

    GtkWidget *windowNZB;

    GtkWidget *treeNZBFiles;

    GtkWidget *radioAddToNewCollection;

    GtkWidget *entryCollectionName;

    GtkWidget *comboCollectionName;

    GtkTreeModel *store;

    char *errmsg = NULL;

    radioAddToNewCollection = nntpgrab_gui_base_get_widget("radioAddToNewCollection");

    entryCollectionName = nntpgrab_gui_base_get_widget("entryCollectionName");

    comboCollectionName = nntpgrab_gui_base_get_widget("comboCollectionName");

    // Set the right collection name

    g_free(collection_name);

    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radioAddToNewCollection))) {

        collection_name = g_strdup(gtk_entry_get_text(GTK_ENTRY(entryCollectionName)));

    } else {

        GtkTreeIter iter;

        if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(comboCollectionName), &iter)) {

            // No item selected, use the entry field

            collection_name = g_strdup(gtk_entry_get_text(GTK_ENTRY(entryCollectionName)));

            nntpgrab_utils_sanitize_text(collection_name, strlen(collection_name));

        } else {

            store = gtk_combo_box_get_model(GTK_COMBO_BOX(comboCollectionName));

            gtk_tree_model_get(store, &iter, 0, &collection_name, -1);

        }

    }

    nntpgrab_utils_sanitize_collection_name(collection_name);

    if (quick_import) {

        errmsg = NULL;

        auto_import_import_nzb_file(glue, nzbfile, collection_name, &errmsg);

        if (errmsg) {

            GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

            nntpgrab_gui_base_dialog_show(windowMain, errmsg, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK);

            g_free(errmsg);

        }

        g_free(collection_name);

        collection_name = NULL;

        nntpgrab_utils_nzb_file_free(nzbfile);

        nzbfile = NULL;

    } else {

        treeNZBFiles = nntpgrab_gui_base_get_widget("treeNZBFiles");

        store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeNZBFiles));

        gtk_tree_model_foreach(store, nzb_model_foreach_add_func, GINT_TO_POINTER(TRUE));

    }

    windowNZB = nntpgrab_gui_base_get_widget("windowNZB");

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

        char *msg;

        if (errmsg) {

            msg = g_strdup_printf(_("Download queue could not be saved:\n%s"), errmsg);

            g_free(errmsg);

        } else {

            msg = g_strdup_printf(_("Download queue could not be saved"));

        }

        nntpgrab_gui_base_dialog_show(windowNZB, msg, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK);

        g_free(msg);

    }

    gtk_widget_hide(windowNZB);

    if (filechooserNZB) {

        gtk_widget_destroy(filechooserNZB);

        filechooserNZB = NULL;

    }

    if (nzbfile) {

        nntpgrab_utils_nzb_file_free(nzbfile);

        nzbfile = NULL;

    }

    if (collection_name) {

        g_free(collection_name);

        collection_name = NULL;

    }

    gtk_widget_hide(nntpgrab_gui_base_get_widget("windowSetCollectionName"));

}

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);

}

// Callbacks from the NZB Import window

G_MODULE_EXPORT void

on_filechooserNZB_file_set(GtkWidget *caller, gpointer data)

{

    char *filename = NULL;

    char *errmsg = NULL;

    GtkWidget *windowNZB;

    GtkWidget *btnNZBImport;

    GtkWidget *treeNZBFiles;

    GtkTreeModel *store;

    NGList *list;

    GError *err = NULL;

    char *contents = NULL;

    char *uri = NULL;

    char *dirname;

#if GLIB_CHECK_VERSION(2,16,0)

    gboolean ret;

    GFile *file;

#endif

    time_t now = time(NULL);

#if GTK_CHECK_VERSION(2,10,0)

    GtkRecentManager *recent_manager;

#endif

    windowNZB = nntpgrab_gui_base_get_widget("windowNZB");

    btnNZBImport = nntpgrab_gui_base_get_widget("btnNZBImport");

    if (nzbfile) {

        nntpgrab_utils_nzb_file_free(nzbfile);

        nzbfile = NULL;

    }

    // Sometimes, the two functions here below can return NULL

    // See https://bugzilla.gnome.org/show_bug.cgi?id=538458 for details

    do {

        uri = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(caller));

        filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(caller));

        // Workaround for https://bugzilla.gnome.org/show_bug.cgi?id=355623

        if (GINT_TO_POINTER(data) == 0 && uri == NULL && filename == NULL) {

            return;

        }

        if (uri && filename) {

            break;

        }

        // Only zero or one of the two fields were found, wait a bit and try again

        if (uri) {

            g_free(uri);

        }

        if (filename) {

            g_free(filename);

        }

        while (g_main_context_iteration(NULL, FALSE));

        g_usleep(G_USEC_PER_SEC / 10);

        // If the filename is still not available after 10 seconds, timeout

        if (now + 10 < time(NULL)) {

            g_return_if_reached();

        }

    } while (TRUE);

    g_return_if_fail(uri != NULL);

    g_return_if_fail(filename != NULL);

#if GLIB_CHECK_VERSION(2,16,0)

    file = g_file_new_for_uri(uri);

    if (!file) {

        return;

    }

    ret = g_file_load_contents(file, NULL, &contents, NULL, NULL, &err);

    g_object_unref(file);

    if (!ret) {

        char *msg = g_strdup_printf("Unable to open uri '%s':\n%s", uri, err->message);

#else

    if (!g_file_get_contents(filename, &contents, NULL, &err)) {

        char *msg = g_strdup_printf("Unable to open file '%s':\n%s", filename, err->message);

#endif /* GLIB_CHECK_VERSION(2,16,0) */

        GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

        nntpgrab_gui_base_dialog_show(windowMain, msg, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK);

        g_free(msg);

        g_error_free(err);

        g_free(filename);

        g_free(uri);

        return;

    }

    nzbfile = nntpgrab_utils_parse_nzb_file(contents, &errmsg);

    g_free(contents);

    if (!nzbfile) {

        if (!errmsg) {

            errmsg = g_strdup_printf(_("Error occured while reading NZB File '%s'"), filename);

        }

        nntpgrab_gui_base_dialog_show(windowNZB, errmsg, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK);

        g_free(errmsg);

        g_free(filename);

        g_free(uri);

        return;

    }

#if GTK_CHECK_VERSION(2,10,0)

    // Add the filename to the recently used files list

    recent_manager = gtk_recent_manager_get_default();

    gtk_recent_manager_add_item(recent_manager, uri);

#endif

    collection_name = g_path_get_basename(filename);

    nntpgrab_utils_sanitize_text(collection_name, strlen(collection_name));

    nntpgrab_utils_strip_nzb_extension(collection_name);

    dirname = g_path_get_dirname(filename);

    if (strlen(dirname) > 1) {

        ConfigGUIOpts opts = config_gui_get_opts();

        strncpy(opts.last_used_nzb_directory, dirname, sizeof(opts.last_used_nzb_directory) - 1);

        config_gui_set_opts(opts);

    }

    g_free(dirname);

    g_free(filename);

    g_free(uri);

    treeNZBFiles = nntpgrab_gui_base_get_widget("treeNZBFiles");

    store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeNZBFiles));

    gtk_list_store_clear(GTK_LIST_STORE(store));

    list = nzbfile->files;

    while (list) {

        NNTPGrabNZBFile *file = list->data;

        GtkTreeIter iter;

        char stamp_str[64];

        char filesize_str[64];

        gtk_list_store_append(GTK_LIST_STORE(store), &iter);

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

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

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

        nntpgrab_utils_calculate_file_size(file->filesize, filesize_str, sizeof(filesize_str) - 1);

        gtk_list_store_set(GTK_LIST_STORE(store), &iter, 0, file->subject, 1, file->poster, 2, (file->groups == NULL ? "" : file->groups->data), 3, stamp_str, 4, filesize_str, 5, TRUE, 6, file, -1);

        list = ng_list_next(list);

    }

    gtk_widget_set_sensitive(btnNZBImport, TRUE);

}

static gboolean

nzb_model_foreach_select_func (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)

{

    gtk_list_store_set(GTK_LIST_STORE(model), iter, 5, GPOINTER_TO_INT(data), -1);

    return FALSE;

}

G_MODULE_EXPORT void

on_btnNZBSelectNone_clicked(GtkWidget *caller, gpointer data)

{

    GtkWidget *treeNZBFiles;

    GtkTreeModel *store;

    treeNZBFiles = nntpgrab_gui_base_get_widget("treeNZBFiles");

    store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeNZBFiles));

    gtk_tree_model_foreach(store, nzb_model_foreach_select_func, GINT_TO_POINTER(FALSE));

}

G_MODULE_EXPORT void

on_btnNZBSelectAll_clicked(GtkWidget *caller, gpointer data)

{

    GtkWidget *treeNZBFiles;

    GtkTreeModel *store;

    treeNZBFiles = nntpgrab_gui_base_get_widget("treeNZBFiles");

    store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeNZBFiles));

    gtk_tree_model_foreach(store, nzb_model_foreach_select_func, GINT_TO_POINTER(TRUE));

}

static void

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

{

    GtkTreeIter iter;

    gtk_list_store_append(GTK_LIST_STORE(data), &iter);

    gtk_list_store_set(GTK_LIST_STORE(data), &iter, 0, collection_name, -1);

}

G_MODULE_EXPORT void

on_btnNZBImport_clicked(GtkWidget *caller, gpointer data)

{

    GtkWidget *windowSetCollectionName;

    GtkWidget *windowMain;

    GtkWidget *frameAddToNewCollection;

    GtkWidget *entryCollectionName;

    GtkWidget *frameAddToExistingCollection;

    GtkWidget *comboCollectionName;

    GtkWidget *radioAddToNewCollection;

    GtkWidget *radioAddToExistingCollection;

    GtkTreeModel *store;

    windowSetCollectionName = nntpgrab_gui_base_get_widget("windowSetCollectionName");

    windowMain = nntpgrab_gui_base_get_widget("windowMain");

    frameAddToNewCollection = nntpgrab_gui_base_get_widget("frameAddToNewCollection");

    entryCollectionName = nntpgrab_gui_base_get_widget("entryCollectionName");

    frameAddToExistingCollection = nntpgrab_gui_base_get_widget("frameAddToExistingCollection");

    comboCollectionName = nntpgrab_gui_base_get_widget("comboCollectionName");

    radioAddToNewCollection = nntpgrab_gui_base_get_widget("radioAddToNewCollection");

    radioAddToExistingCollection = nntpgrab_gui_base_get_widget("radioAddToExistingCollection");

    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radioAddToNewCollection), TRUE);

    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radioAddToExistingCollection), FALSE);

    gtk_widget_set_sensitive(frameAddToNewCollection, TRUE);

    gtk_widget_set_sensitive(frameAddToExistingCollection, FALSE);

    gtk_entry_set_text(GTK_ENTRY(entryCollectionName), collection_name);

    // Clear the contents of the combo box

    store = gtk_combo_box_get_model(GTK_COMBO_BOX(comboCollectionName));

    gtk_list_store_clear(GTK_LIST_STORE(store));

    nntpgrab_glue_schedular_foreach_task(glue, foreach_collection_func, NULL, NULL, store);

    gtk_combo_box_set_active (GTK_COMBO_BOX (comboCollectionName), 0);

    // FIXME: Due to a possible bug in GTK it isn't possible to set another transient window

    // when one is already attached

// if (quick_import) {

        gtk_window_set_transient_for(GTK_WINDOW(windowSetCollectionName), GTK_WINDOW(windowMain));

// } else {

// gtk_window_set_transient_for(GTK_WINDOW(windowSetCollectionName), GTK_WINDOW(windowNZB));

// }

    gtk_widget_show(windowSetCollectionName);

    gtk_window_present(GTK_WINDOW(windowSetCollectionName));

}

G_MODULE_EXPORT gboolean

on_windowNZB_delete_event(GtkWidget *widget, GdkEvent *event, gpointer user_data)

{

    gtk_widget_destroy(filechooserNZB);

    filechooserNZB = NULL;

    gtk_widget_hide(widget);

    return TRUE;

}

G_MODULE_EXPORT gboolean

on_windowSetCollectionName_delete_event(GtkWidget *widget, GdkEvent *event, gpointer user_data)

{

    gtk_widget_hide(widget);

    if (nzbfile) {

        nntpgrab_utils_nzb_file_free(nzbfile);

        nzbfile = NULL;

    }

    if (collection_name) {

        g_free(collection_name);

        collection_name = NULL;

    }

    return TRUE;

}

static void

download_check_toggled(GtkWidget *caller, gchar *path, gpointer data)

{

    gboolean value;

    GtkTreeIter iter;

    GtkWidget *treeNZBFiles;

    GtkTreeModel *model;

    treeNZBFiles = nntpgrab_gui_base_get_widget("treeNZBFiles");

    model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeNZBFiles));

    if (gtk_tree_model_get_iter_from_string(model, &iter, path)) {

        gtk_tree_model_get(model, &iter, 5, &value, -1);

        if (value) {

            value = FALSE;

        } else {

            value = TRUE;

        }

        gtk_list_store_set(GTK_LIST_STORE(model), &iter, 5, value, -1);

    }

}

void

nzb_initialize()

{

    GtkWidget *treeNZBFiles;

    GtkTreeSelection *selection;

    GtkListStore *store;

    GtkCellRenderer *cellRenderer;

    GtkWidget *comboCollectionName;

    treeNZBFiles = nntpgrab_gui_base_get_widget("treeNZBFiles");

    comboCollectionName = nntpgrab_gui_base_get_widget("comboCollectionName");

    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeNZBFiles));

    gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);

    cellRenderer = gtk_cell_renderer_toggle_new();

    gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeNZBFiles), -1, _("Download"), cellRenderer, "active", 5, NULL);

    g_signal_connect((gpointer) cellRenderer, "toggled", G_CALLBACK(download_check_toggled), NULL);

    cellRenderer = gtk_cell_renderer_text_new();

    gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeNZBFiles), -1, _("Subject"), cellRenderer, "text", 0, NULL);

    cellRenderer = gtk_cell_renderer_text_new();

    gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeNZBFiles), -1, _("Poster"), cellRenderer, "text", 1, NULL);

    cellRenderer = gtk_cell_renderer_text_new();

    gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeNZBFiles), -1, _("Groups"), cellRenderer, "text", 2, NULL);

    cellRenderer = gtk_cell_renderer_text_new();

    gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeNZBFiles), -1, _("Stamp"), cellRenderer, "text", 3, NULL);

    cellRenderer = gtk_cell_renderer_text_new();

    gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeNZBFiles), -1, _("File size"), cellRenderer, "text", 4, NULL);

    store = gtk_list_store_new(7, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_POINTER);

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

    cellRenderer = gtk_cell_renderer_text_new();

    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (comboCollectionName), cellRenderer, FALSE);

    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (comboCollectionName), cellRenderer, "text", 0, NULL);

    store = gtk_list_store_new(1, G_TYPE_STRING);

    gtk_combo_box_set_model(GTK_COMBO_BOX(comboCollectionName), GTK_TREE_MODEL(store));

}

static gboolean

do_open_nzb_file_phase3(gpointer data)

{

    GtkWidget *btnImportNZB = nntpgrab_gui_base_get_widget("btnImportNZB");

    on_btnImportNZB_clicked(btnImportNZB, NULL);

    gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(filechooserNZB), (const char*) data);

    on_filechooserNZB_file_set(GTK_WIDGET(filechooserNZB), g_strdup((const char*) data));

    g_free(data);

    return FALSE;

}

static gboolean

do_open_nzb_file_phase2(gpointer data)

{

    gtk_window_deiconify(GTK_WINDOW(nntpgrab_gui_base_get_widget("windowMain")));

    gtk_window_present(GTK_WINDOW(nntpgrab_gui_base_get_widget("windowMain")));

    g_idle_add(do_open_nzb_file_phase3, data);

    return FALSE;

}

void

do_open_nzb_file(const char *nzb_file)

{

    g_idle_add(do_open_nzb_file_phase2, g_strdup(nzb_file));

}