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 

#include 

#include 

#include "gui.h"

#include "config_gui.h"

#include "donate.xpm"

#ifdef HAVE_LIBPEAS

#include 

#endif

#ifdef DARWIN

#include 

#endif

#ifdef WIN32

#include 

#endif

NntpgrabGlue *glue = NULL;

#if GTK_CHECK_VERSION(3,0,0)

static GtkApplication *app = NULL;

#endif

void debug_initialize(void);

void info_initialize(void);

void config_initialize(void);

void config_gui_initialize(void);

void config_display_initialize(void);

void queue_initialize(void);

void callbacks_initialize(void);

void nzb_initialize(void);

void connections_initialize(void);

void notify_initialize(void);

void monitor_initialize(void);

void gui_par2_initialize(void);

void nzbcreator_initialize(void);

void auto_import_initialize(void);

void autoshutdown_initialize(void);

void gui_plugins_initialize(void);

void gui_plugins_cleanup(void);

// auto_import.c

void    disable_auto_import(void);

static const char *nzb_file = NULL;

static gboolean initialized = FALSE;

G_MODULE_EXPORT void

on_btnQuit_clicked(GtkWidget *caller, gpointer data)

{

    GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

    gtk_widget_hide(windowMain);

#if GTK_CHECK_VERSION(3,0,0)

    gtk_application_remove_window(app, GTK_WINDOW(windowMain));

#else

    gtk_main_quit();

#endif

}

static void

load_auto_load_plugins(void)

{

    ConfigGUIOpts opts = config_gui_get_opts();

    NNTPGrabPluginInfo info;

    GList *list;

    list = opts.auto_load_plugins;

    while (list) {

        char *errmsg = NULL;

        const char *plugin_name = list->data;

        if (!nntpgrab_glue_plugins_get_plugin_info(glue, plugin_name, &info) ||

            info.is_loaded == TRUE) {

            /* Plugin isn't found or is already loaded. Ignore */

            list = g_list_next(list);

            continue;

        }

        if (!nntpgrab_glue_plugins_load_plugin(glue, plugin_name, &errmsg)) {

            GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

            char msg[1024];

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

            snprintf(msg, sizeof(msg) - 1, _("Unable to load plugin '%s': %s"), plugin_name, errmsg);

            nntpgrab_gui_base_dialog_show(windowMain, msg, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK);

            g_free(errmsg);

        }

        list = g_list_next(list);

    }

}

static void

bring_to_front_cb(void *user_data)

{

    GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

    gtk_window_deiconify(GTK_WINDOW(windowMain));

    gtk_widget_show(windowMain);

    gtk_window_present(GTK_WINDOW(windowMain));

}

static gboolean

register_frontend(void)

{

    char *errmsg = NULL;

    /* Try to register this NNTPGrab instance */

    if (!nntpgrab_utils_register_frontend(do_open_nzb_file, bring_to_front_cb, NULL, &errmsg)) {

        /* Find out whether there's already another NNTPGrab frontend active */

        ngboolean is_running = FALSE;

        char *errmsg2 = NULL;

        if (nntpgrab_utils_test_is_frontend_already_running(&is_running, &errmsg2)) {

            if (is_running) {

                /* Another NNTPGrab frontend is already running, close this instance */

                return FALSE;

            } else {

                /* No NNTPGrab was already running, show the error and continue without IPC support */

                GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

                nntpgrab_gui_base_dialog_show(windowMain, errmsg, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK);

            }

        } else {

            /* The check failed, show the error and continue without IPC support */

            GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

            nntpgrab_gui_base_dialog_show(windowMain, errmsg2, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK);

            g_free(errmsg2);

        }

    }

    return TRUE;

}

static gboolean

initialisation_inside_mainloop(gpointer data)

{

    GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

    GtkWidget *windowConnect = nntpgrab_gui_base_get_widget("windowConnect");

    char *errmsg = NULL;

    GtkWidget *cmbConnectHostname;

    GtkWidget *spinConnectPort;

    char *hostname;

    int port;

    char *warnings = NULL;

#if GTK_CHECK_VERSION(2,90,0)

    GtkTreeIter iter;

    GtkTreeModel *model;

#endif

#ifdef WIN32

    WORD wVersionRequested;

    WSADATA wsaData;

    int ret;

    // Initialise Winsock

    wVersionRequested = MAKEWORD(2, 2);

    ret = WSAStartup(wVersionRequested, &wsaData);

    if (ret != 0) {

        /* Tell the user that we could not find a usable */

        /* WinSock DLL. */

        g_error(_("Winsock could not be initialised"));

        return -1;

    }

    /* Confirm that the WinSock DLL supports 2.2. */

    /* Note that if the DLL supports versions greater */

    /* than 2.2 in addition to 2.2, it will still return */

    /* 2.2 in wVersion since that is the version we */

    /* requested. */

    if (LOBYTE( wsaData.wVersion ) != 2 ||

        HIBYTE( wsaData.wVersion ) != 2) {

        /* Tell the user that we could not find a usable */

        /* WinSock DLL. */

        WSACleanup();

        g_error(_("Winsock 2.2 or higher is required for this program"));

        return -1;

    }

#endif

    gtk_widget_show(windowMain);

#if GTK_CHECK_VERSION(3,0,0)

    gtk_application_add_window(app, GTK_WINDOW(windowMain));

    gtk_application_remove_window(app, GTK_WINDOW(windowConnect));

#endif

    cmbConnectHostname = nntpgrab_gui_base_get_widget("cmbConnectHostname");

    spinConnectPort = nntpgrab_gui_base_get_widget("spinConnectPort");

    hostname = g_strdup(gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(cmbConnectHostname)))));

    port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spinConnectPort));

    glue = nntpgrab_glue_new();

    if (!nntpgrab_glue_init(glue, NNTPGRAB_GLUE_VERSION, &errmsg)) {

        nntpgrab_glue_destroy(glue);

        glue = NULL;

        g_free(hostname);

        g_critical(_("NNTPGrab Initialisation FAILED:\n%s\n"), errmsg);

        g_free(errmsg);

        g_idle_add((GSourceFunc) gtk_main_quit, NULL);

        return FALSE;

    }

    if (GPOINTER_TO_INT(data) == 0) {       // Standalone mode

        GObject *menuitemKillServer = nntpgrab_gui_base_get_object("menuitemKillServer");

        GValue val;

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

        g_value_init(&val, G_TYPE_BOOLEAN);

        g_value_set_boolean (&val, FALSE);

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

        if (hostname) {

            g_free(hostname);

            hostname = NULL;

        }

    }

    if (!nntpgrab_glue_connect(glue, hostname, port, NULL, NULL, FALSE, &errmsg, &warnings)) {

        if (warnings) {

            GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

            nntpgrab_gui_base_dialog_show(windowMain, warnings, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK);

            g_free(warnings);

        }

        g_free(hostname);

        g_critical(_("Unable to connect to NNTPGrab server:\n%s"), errmsg);

        g_free(errmsg);

        g_idle_add((GSourceFunc) gtk_main_quit, NULL);

        return FALSE;

    }

    if (warnings) {

        GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

        nntpgrab_gui_base_dialog_show(windowMain, warnings, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK);

        g_free(warnings);

    }

    g_free(hostname);

    gtk_widget_destroy(windowConnect);

#if !defined(DARWIN)

    if (!register_frontend()) {

        /* Another NNTPGrab frontend is already running, close this instance */

        g_idle_add((GSourceFunc) gtk_main_quit, NULL);

        return FALSE;

    }

#endif

    debug_initialize();

    callbacks_initialize();

    config_initialize();

    config_display_initialize();

#ifndef DARWIN

    nzb_initialize();

#endif

    connections_initialize();

    queue_initialize();

    notify_initialize();

    monitor_initialize();

    gui_par2_initialize();

    nzbcreator_initialize();

    auto_import_initialize();

    autoshutdown_initialize();

    gui_plugins_initialize();

    /* Load any optional plugins which need to be auto-loaded */

    load_auto_load_plugins();

    // Did we receive a NZB file on the command line ?

    if (nzb_file) {

        do_open_nzb_file(nzb_file, NULL);

        nzb_file = NULL;

    }

    initialized = TRUE;

    return FALSE;

}

G_MODULE_EXPORT void

on_btnConnectToServer_clicked(GtkWidget *caller, gpointer data)

{

    GtkWidget *windowConnect = nntpgrab_gui_base_get_widget("windowConnect");

    // Save the hostname into the GUI Configuration

    ConfigGUIOpts opts = config_gui_get_opts();

    GtkWidget *cmbConnectHostname = nntpgrab_gui_base_get_widget("cmbConnectHostname");

    const char *hostname = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(cmbConnectHostname))));

    // Have we seen this hostname before ?

    if (!strcmp(hostname, opts.hostname1)) {

        // No need to do anything, item is already at the top of the list

    } else if (!strcmp(hostname, opts.hostname2)) {

        // Swap positions

        strncpy(opts.hostname2, opts.hostname1, sizeof(opts.hostname2));

        strncpy(opts.hostname1, hostname, sizeof(opts.hostname1));

    } else if (!strcmp(hostname, opts.hostname3)) {

        // Push items 1 and 2 one place down and set the first item to the hostname

        strncpy(opts.hostname3, opts.hostname2, sizeof(opts.hostname3));

        strncpy(opts.hostname2, opts.hostname1, sizeof(opts.hostname2));

        strncpy(opts.hostname1, hostname, sizeof(opts.hostname1));

    } else if (!strcmp(hostname, opts.hostname4)) {

        strncpy(opts.hostname4, opts.hostname3, sizeof(opts.hostname4));

        strncpy(opts.hostname3, opts.hostname2, sizeof(opts.hostname3));

        strncpy(opts.hostname2, opts.hostname1, sizeof(opts.hostname2));

        strncpy(opts.hostname1, hostname, sizeof(opts.hostname1));

    } else if (!strcmp(hostname, opts.hostname5)) {

        strncpy(opts.hostname5, opts.hostname4, sizeof(opts.hostname5));

        strncpy(opts.hostname4, opts.hostname3, sizeof(opts.hostname4));

        strncpy(opts.hostname3, opts.hostname2, sizeof(opts.hostname3));

        strncpy(opts.hostname2, opts.hostname1, sizeof(opts.hostname2));

        strncpy(opts.hostname1, hostname, sizeof(opts.hostname1));

    } else {

        // Hostname not seen at all, move all the items one place down (forget

        // about the last item) and put the hostname in front

        strncpy(opts.hostname5, opts.hostname4, sizeof(opts.hostname5));

        strncpy(opts.hostname4, opts.hostname3, sizeof(opts.hostname4));

        strncpy(opts.hostname3, opts.hostname2, sizeof(opts.hostname3));

        strncpy(opts.hostname2, opts.hostname1, sizeof(opts.hostname2));

        strncpy(opts.hostname1, hostname, sizeof(opts.hostname1));

    }

    config_gui_set_opts(opts);

    gtk_widget_set_sensitive(windowConnect, FALSE);

    g_idle_add(initialisation_inside_mainloop, GINT_TO_POINTER(1));

}

G_MODULE_EXPORT void

on_btnStartStandalone_clicked(GtkWidget *caller, gpointer data)

{

    GtkWidget *windowConnect = nntpgrab_gui_base_get_widget("windowConnect");

    gtk_widget_set_sensitive(windowConnect, FALSE);

    g_idle_add(initialisation_inside_mainloop, GINT_TO_POINTER(0));

}

G_MODULE_EXPORT void

on_btnConnectQuit_clicked(GtkWidget *caller, gpointer data)

{

    GtkWidget *windowConnect = nntpgrab_gui_base_get_widget("windowConnect");

    gtk_widget_destroy(windowConnect);

    gtk_main_quit();

}

G_MODULE_EXPORT void

on_menuitemManagePlugins_activate(GtkWidget *caller, gpointer data)

{

    GtkWidget *windowPlugins = nntpgrab_gui_base_get_widget("windowPlugins");

    gtk_window_present(GTK_WINDOW(windowPlugins));

}

G_MODULE_EXPORT void

on_menuitemKillServer_activate(GtkWidget *caller, gpointer data)

{

    nntpgrab_glue_kill_server(glue);

}

#ifdef _MSC_VER

void AppInvalidParameterHandler(const wchar_t* expression, const wchar_t* function, const wchar_t* file, unsigned int line,        uintptr_t pReserved ) {

        fprintf(

                stderr,

                "Invalid parameter detected in function %s. File: %s Line: %d\n",

                function,

                file,

                line

        );

        fprintf(

                stderr,

                "Expression: %s\n",

                expression

        );

        // Cause a Debug Breakpoint.

        DebugBreak();

}

#endif

gboolean

gui_get_is_initialized()

{

    return initialized;

}

static GtkWidget *

create_user_interface(void)

{

    GtkWidget *btnDonate;

    GtkWidget *icon;

    GdkPixbuf *pixbuf;

    GtkWidget *windowMain;

    GtkWidget *windowConnect;

    GtkWidget *cmbConnectHostname;

    GtkListStore *store;

    ConfigGUIOpts opts;

    GtkTreeIter iter;

#ifdef DARWIN

    GtkWidget *quit_menu_widget;

#endif

    /* Initialize libxml now to prevent possible race conditions */

    xmlInitGlobals();

    xmlInitParser();

    nntpgrab_gui_base_create_ui("nntpgrab_gui");

    windowMain = nntpgrab_gui_base_get_widget("windowMain");

    windowConnect = nntpgrab_gui_base_get_widget("windowConnect");

#ifdef DARWIN

    ige_mac_menu_set_global_key_handler_enabled (TRUE);

    ige_mac_menu_connect_window_key_handler (GTK_WINDOW(nntpgrab_gui_base_get_widget("windowMain")));

    quit_menu_widget = gtk_ui_manager_get_widget(GTK_UI_MANAGER(nntpgrab_gui_base_get_object("uimanager1")), "ui/menubar1/menuitem1/imagemenuitem5");

    g_warn_if_fail(quit_menu_widget != NULL);

    ige_mac_menu_set_quit_menu_item (GTK_MENU_ITEM (quit_menu_widget));

    ige_mac_menu_set_menu_bar(GTK_MENU_SHELL(nntpgrab_gui_base_get_widget("menubar1")));

    gtk_widget_hide(nntpgrab_gui_base_get_widget("menubar1"));

#endif

    // Set the donate icon of the window

    btnDonate = nntpgrab_gui_base_get_widget("btnDonate");

    pixbuf = gdk_pixbuf_new_from_xpm_data((const char **) &donate_xpm);

    icon = gtk_image_new_from_pixbuf(pixbuf);

    gtk_widget_show(icon);

    gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(btnDonate), icon);

    g_object_unref(pixbuf);

#ifdef DARWIN

    /* Due to the way file associations work on Mac OS X, we need to make 

     * sure the NZB dialog can be used before the file association is set up */

    nzb_initialize();

    /* And the file assocation needs to be set up as soon as possible.. */

    if (!register_frontend()) {

        return NULL;

    }

#endif

    // We need to have the GUI configuration loaded at this point because the

    // Network GUI requires data from it

    config_gui_initialize();

    opts = config_gui_get_opts();

    if (opts.show_connect_dialog || nntpgrab_utils_test_is_server_already_running()) {

        // Show the connect dialog so the user can enter where the NNTPGrab server is running

        windowConnect = nntpgrab_gui_base_get_widget("windowConnect");

        cmbConnectHostname = nntpgrab_gui_base_get_widget("cmbConnectHostname");

        gtk_widget_show(windowConnect);

        store = gtk_list_store_new(1, G_TYPE_STRING);

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

#if GTK_CHECK_VERSION(3,0,0)

        gtk_combo_box_set_entry_text_column(GTK_COMBO_BOX(cmbConnectHostname), 0);

#else

        gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(cmbConnectHostname), 0);

#endif

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

            gtk_list_store_append(store, &iter);

            gtk_list_store_set(store, &iter, 0, opts.hostname1, -1);

        }

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

            gtk_list_store_append(store, &iter);

            gtk_list_store_set(store, &iter, 0, opts.hostname2, -1);

        }

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

            gtk_list_store_append(store, &iter);

            gtk_list_store_set(store, &iter, 0, opts.hostname3, -1);

        }

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

            gtk_list_store_append(store, &iter);

            gtk_list_store_set(store, &iter, 0, opts.hostname4, -1);

        }

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

            gtk_list_store_append(store, &iter);

            gtk_list_store_set(store, &iter, 0, opts.hostname5, -1);

        }

        gtk_combo_box_set_active(GTK_COMBO_BOX(cmbConnectHostname), 0);

        if (!opts.show_connect_dialog) {

            /* If we got here, the user is running the NNTPGrab Server */

            GtkWidget *chkAlwaysStandalone = nntpgrab_gui_base_get_widget("chkAlwaysStandalone");

            gtk_widget_hide(chkAlwaysStandalone);

        }

        // If the NNTPGrab Server is also running on localhost, disable the 'Standalone' button

        if (nntpgrab_utils_test_is_server_already_running()) {

            GtkWidget *btnStartStandalone = nntpgrab_gui_base_get_widget("btnStartStandalone");

            GtkWidget *btnConnectToServer = nntpgrab_gui_base_get_widget("btnConnectToServer");

            gtk_widget_set_sensitive(btnStartStandalone, FALSE);

            gtk_widget_set_can_default(btnConnectToServer, TRUE);

            gtk_widget_grab_default(btnConnectToServer);

        }

    } else {

        g_idle_add(initialisation_inside_mainloop, GINT_TO_POINTER(0));

    }

    /* The update information can already be fetched now */

    info_initialize();

    if (opts.show_connect_dialog || nntpgrab_utils_test_is_server_already_running()) {

        return windowConnect;

    } else {

        return windowMain;

    }

}

#if GTK_CHECK_VERSION(3,0,0)

static void

activate(GtkApplication *app, gpointer data)

{

    GList *list;

    GtkWidget *window;

    list = gtk_application_get_windows(app);

    if (list) {

        gtk_widget_show(list->data);

        gtk_window_present(GTK_WINDOW(list->data));

    } else {

        window = create_user_interface();

        gtk_window_set_application(GTK_WINDOW(window), app);

        gtk_widget_show(window);

    }

}

static int

command_line(GtkApplication *app, GApplicationCommandLine *cmdline, gpointer data)

{

    char **argv;

    int argc;

    int i;

    argv = g_application_command_line_get_arguments(cmdline, &argc);

    for (i = 1; i < argc; i++) {

        if (g_file_test(argv[i], G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {

            if (!initialized) {

                /* No windows found yet, assume were starting up for the first time */

                if (nzb_file) {

                    g_free((char*)nzb_file);

                }

                nzb_file = g_strdup(argv[i]);

                break;

            } else {

                do_open_nzb_file(argv[i], NULL);

            }

        }

    }

    if (!initialized) {

        activate(app, data);

    }

    return 0;

}

#endif

int

main(int argc, char *argv[])

{

    int status = 0;

    char *errmsg = NULL;

    gboolean is_running = FALSE;

    int i;

#ifdef HAVE_LIBPEAS

    PeasEngine *engine;

    const char *plugin_dir;

#endif

#ifdef WIN32

#ifdef _MSC_VER

    _set_invalid_parameter_handler(AppInvalidParameterHandler);

#else

    // exchndl.dll is part of Dr. MinGW. By loading this DLL, every time the

    // program crashes a .RPT file will be created containing the backtrace

    LoadLibraryA("exchndl.dll");

#endif

#endif

    g_set_application_name("NNTPGrab");

    g_set_prgname("NNTPGrab");

    nntpgrab_utils_perform_base_initialization();

#if GTK_CHECK_VERSION(3,0,0)

    app = gtk_application_new("org.NNTPGrab.NNTPGrab.GTK3", G_APPLICATION_HANDLES_COMMAND_LINE);

    g_signal_connect(app, "activate", G_CALLBACK(activate), NULL);

    g_signal_connect (app, "command-line", G_CALLBACK (command_line), NULL);

#else

    gtk_init(&argc, &argv);

#endif

    /* Is there already another NNTPGrab instance running ? */

    if (!nntpgrab_utils_test_is_frontend_already_running(&is_running, &errmsg)) {

        /* Unable to check whether NNTPGrab is running */

        char *errmsg2 = g_strdup_printf(_("Unable to check whether NNTPGrab is already running:\n%s"), errmsg);

        nntpgrab_gui_base_dialog_show(NULL, errmsg2, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK);

        g_free(errmsg2);

        g_free(errmsg);

        return 1;

    }

    if (argc > 1) {

        /* We have an extra argument! Probably the location of a NZB file 

         * Is one our arguments really a filename ? */

        for (i = 1; i < argc; i++) {

            char *filename;

            if (!strncmp(argv[i], "--debug", 7)) {

                g_setenv("NNTPGRAB_DEBUG", "1", TRUE);

            }

#ifdef WIN32

            filename = g_convert(argv[i], -1, "utf-8", "windows-1252", NULL, NULL, NULL);

#else

            filename = g_strdup(argv[i]);

#endif

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

                nzb_file = g_strdup(filename);

            }

            g_free(filename);

        }

        if (nzb_file) {

            /* Is there already another NNTPGrab instance running ? */

            if (is_running) {

                /* Send a message to that other process and commit suicide */

                if (!nntpgrab_utils_send_open_nzb_file_request(nzb_file, &errmsg)) {

                    nntpgrab_gui_base_dialog_show(NULL, errmsg, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK);

                    g_free(errmsg);

                }

                if (!nntpgrab_utils_send_bring_to_front_request(&errmsg)) {

                    nntpgrab_gui_base_dialog_show(NULL, errmsg, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK);

                    g_free(errmsg);

                }

                return 2;

            }

            /* Nope, open the NZB Import dialog as soon as we're ready to go 

             * This will be done automatically due to the fact that nzb_file is a global variable */

        }

    }

    if (is_running) {

        /* There's already another frontend active. Stop execution of this one */

        if (!nntpgrab_utils_send_bring_to_front_request(&errmsg)) {

            char *errmsg2 = g_strdup_printf(_("Unable to send 'bring to front' request to already running NNTPGrab instance:\n%s"), errmsg);

            nntpgrab_gui_base_dialog_show(NULL, errmsg2, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK);

            g_free(errmsg2);

            g_free(errmsg);

        }

        return 3;

    }

#ifdef HAVE_LIBPEAS

    engine = peas_engine_get_default ();

    if (g_getenv("NNTPGRAB_PLUGINS_GTK_DIR")) {

        plugin_dir = g_getenv("NNTPGRAB_PLUGINS_GTK_DIR");

    } else {

        plugin_dir = PLUGIN_GTK_DIR;

    }

    peas_engine_add_search_path (engine, plugin_dir, plugin_dir);

    peas_engine_enable_loader(engine, "gjs");

    peas_engine_enable_loader(engine, "python");

    peas_engine_enable_loader(engine, "seed");

#endif

#if GTK_CHECK_VERSION(3,0,0)

    status = g_application_run(G_APPLICATION(app), argc, argv);

    g_object_unref(app);

#else

    if (!create_user_interface()) {

        return 4;

    }

    /* start the event loop */

    gtk_main();

#endif

    if (nntpgrab_gui_base_tray_icon_get_is_shown()) {

        nntpgrab_gui_base_tray_destroy();

    }

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

    gui_plugins_cleanup();

    if (glue) {

        // Always try to disable the auto import even if it isn't in use

        if (initialized) {

            disable_auto_import();

        }

        nntpgrab_glue_destroy(glue);

    }

    if (initialized) {

        gtk_widget_destroy(nntpgrab_gui_base_get_widget("windowMain"));

        gtk_widget_destroy(nntpgrab_gui_base_get_widget("windowConfig"));

        gtk_widget_destroy(nntpgrab_gui_base_get_widget("windowNZB"));

        gtk_widget_destroy(nntpgrab_gui_base_get_widget("windowDebug"));

        gtk_widget_destroy(nntpgrab_gui_base_get_widget("windowSetCollectionName"));

        gtk_widget_destroy(nntpgrab_gui_base_get_widget("windowPlugins"));

        nntpgrab_gui_base_destroy_ui();

    }

    return status;

}

#ifdef WIN32

static HINSTANCE instance = NULL;

HINSTANCE

get_hinstance(void)

{

    return instance;

}

int _stdcall

WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, char *lpszCmdLine, int nCmdShow)

{

    instance = hInstance;

    return main(__argc, __argv);

}

#endif