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 "gui.h"

#include 

#ifdef HAVE_SOUP

#include 

#ifdef HAVE_SOUP_GNOME

#include 

#endif

#else

#include 

#include 

#include 

#endif

#include 

#ifdef WIN32

#include 

#endif

#if defined(WIN32) && !defined(__MINGW64__)

/* Win32 likes to add a extra _ to external variables. Workaround this */

#define __BUILD_SVN_REV _BUILD_SVN_REV

#define __BUILD_DATE _BUILD_DATE

#define __BUILD_NUMBER _BUILD_NUMBER

#endif

#ifdef DARWIN

#define GET_BUILD_SVN_REV    __BUILD_SVN_REV

#define GET_BUILD_DATE       __BUILD_DATE

#define GET_BUILD_NUMBER     __BUILD_NUMBER

#else

extern char   __BUILD_SVN_REV;

extern char   __BUILD_DATE;

extern char   __BUILD_NUMBER;

#define GET_BUILD_SVN_REV    &__BUILD_SVN_REV

#define GET_BUILD_DATE       &__BUILD_DATE

#define GET_BUILD_NUMBER     &__BUILD_NUMBER

#endif

#ifndef HAVE_SOUP

static size_t

curl_write_function(void *buffer, size_t size, size_t nmemb, void *stream)

{

    char *buf;

    GString *data = (GString *) stream;

    g_assert(data);

    /* The buffer isn't \0 terminated. Solve this by 

       using a temporary buffer */

    buf = (char *) g_slice_alloc((int) (size * nmemb) + 1);

    memcpy(buf, buffer, size * nmemb);

    buf[size * nmemb] = '\0';

    data = g_string_append(data, buf);

    g_slice_free1((size * nmemb) + 1, buf);

    return (int) (size * nmemb);

}

#endif

static gboolean

open_uri (GtkWidget *embed, const char *url_unquoted, gpointer data)

{

    if (strstr(url_unquoted, "https://")) {

        char *url = g_shell_quote(url_unquoted);

#ifdef WIN32

        GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

        ShellExecuteA(GDK_WINDOW_HWND(windowMain->window), "open", url_unquoted, NULL, NULL, SW_SHOW);

#elif defined(DARWIN)

        GError *error = NULL;

        char cmd[1024];

        snprintf(cmd, sizeof(cmd), "open %s", url);

        g_spawn_command_line_async(cmd, &error);

        if (error) {

            g_print("%s: %s\n", error->message, cmd);

        }

#else

        GError *error = NULL;

        char cmd[1024];

        if (g_find_program_in_path("xdg-open")) {

            // We hebben de desktop-onafhankelijke methode om programma's te openen

            snprintf(cmd, sizeof(cmd), "xdg-open %s", url);

        } else if (g_getenv("GNOME_DESKTOP_SESSION_ID") && g_find_program_in_path("gnome-open")) {

            // We draaien Gnome

            snprintf(cmd, sizeof(cmd), "gnome-open %s", url);

        } else if (g_getenv("KDE_FULL_SESSION") && g_find_program_in_path("kfmclient")) {

            // We draaien KDE

            snprintf(cmd, sizeof(cmd), "kfmclient openURL %s", url);

        } else if (g_getenv("BROWSER")) {

            // XFCE4 gebruikt de environment variabele BROWSER om de standaardbrowser te bepalen.

            snprintf(cmd, sizeof(cmd), "%s %s", g_getenv("BROWSER"), url);

        } else {

            // Window manager onbekend..probeer firefox, mozilla of konqueror te lanceren indien aanwezig

            if (g_find_program_in_path("firefox")) {

                snprintf(cmd, sizeof(cmd), "firefox %s", url);

            } else if (g_find_program_in_path("mozilla")) {

                snprintf(cmd, sizeof(cmd), "mozilla %s", url);

            } else if (g_find_program_in_path("konqueror")) {

            snprintf(cmd, sizeof(cmd), "konqueror %s", url);

            } else {

                GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

                nntpgrab_gui_base_dialog_show(windowMain, _("Unable to find a external webbrowser"), GTK_MESSAGE_ERROR, GTK_BUTTONS_OK);

                g_free(url);

                return FALSE;

            }

        }

        g_spawn_command_line_async(cmd, &error);

        if (error) {

            g_print("%s: %s\n", error->message, cmd);

        }

#endif

        g_free(url);

        return FALSE;

    }

    return TRUE;

}

#ifndef HAVE_SOUP

static char *

retrieve_website_info(void)

{

    char            *ret;

    CURL            *curl = NULL;

    CURLcode         curl_retval;

    GString         *serverOutput;

    char            *user_agent;

    curl_global_init(CURL_GLOBAL_WIN32);

    curl = curl_easy_init();

    if(!curl) {

        g_warning(_("retrieve_website_info(): curl_easy_init() failed\n"));

        return NULL;

    }

    serverOutput = g_string_new("");

    curl_easy_setopt(curl, CURLOPT_URL, "https://www.nntpgrab.nl/info.php");

    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_write_function);

    curl_easy_setopt(curl, CURLOPT_WRITEDATA, serverOutput);

    curl_easy_setopt(curl, CURLOPT_NOPROGRESS, TRUE);

    curl_easy_setopt(curl, CURLOPT_ENCODING, "gzip");

    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 20);

    curl_easy_setopt(curl, CURLOPT_NOSIGNAL, TRUE);

    //curl_easy_setopt(curl, CURLOPT_VERBOSE, TRUE);

    user_agent = g_strdup("NNTPGrab version " VERSION " (" OS ")");

    curl_easy_setopt(curl, CURLOPT_USERAGENT, user_agent);

#if 0 

    if (core->config->proxyHost && core->config->proxyPort) {

        curl_easy_setopt(curl, CURLOPT_PROXY, ftd_string_value(core->config->proxyHost));

        curl_easy_setopt(curl, CURLOPT_PROXYPORT, atoi(ftd_string_value(core->config->proxyPort)));

        if (core->config->proxyUser && core->config->proxyPassword) {

            int len = ftd_string_length(core->config->proxyUser) + ftd_string_length(core->config->proxyPassword) + 2;

            proxyUserPw = g_malloc (len);

            snprintf(proxyUserPw, len, "%s:%s", ftd_string_value(core->config->proxyUser), ftd_string_value(core->config->proxyPassword));

            curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, proxyUserPw);

        }

    }

#endif

    curl_retval = curl_easy_perform(curl);

    if (curl_retval == 0) {

        ret = g_strdup(serverOutput->str);

    } else {

        ret = NULL;

    }

    g_free(user_agent);

    g_string_free(serverOutput, TRUE);

    curl_easy_cleanup(curl);

    curl_global_cleanup();

    return ret;

}

#endif

typedef struct _changelog

{

    int major_version;

    int minor_version;

    int micro_version;

    GList *entries;

} ChangeLog;

typedef struct _update_info

{

    int stable_major_version;

    int stable_minor_version;

    int stable_micro_version;

    time_t date_latest_stable_version;

    char date_latest_stable_version_str[128];

    int unstable_major_version;

    int unstable_minor_version;

    int unstable_micro_version;

    time_t date_latest_unstable_version;

    char date_latest_unstable_version_str[128];

    GList *changelogs;

} UpdateInfo;

static char *xml_parser_errmsg = NULL;

static void

xml_parser_error_func (void *ctx, const char *msg, ...)

{

    va_list args;

    char *orig = xml_parser_errmsg;

    char *tmp;

    va_start(args, msg);

    tmp = g_strdup_vprintf(msg, args);

    if (orig) {

        xml_parser_errmsg = g_strdup_printf("%s %s", orig, tmp);

        g_free(orig);

        g_free(tmp);

    } else {

        xml_parser_errmsg = tmp;

    }

    va_end(args);

}

static void

parse_changelog(xmlDocPtr doc, xmlNodePtr cur, ChangeLog *changelog)

{

    gboolean translated_entry_seen = FALSE;

    const char * const *langs = g_get_language_names();

    int i = 0;

    const char *lang_requested = NULL;

    while(cur != NULL) {

        if (!xmlStrcmp(cur->name, (const xmlChar *) "VersionMajor")) {

            xmlChar *version = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);

            changelog->major_version = atoi((const gchar *) version);

            xmlFree(version);

        }

        if (!xmlStrcmp(cur->name, (const xmlChar *) "VersionMinor")) {

            xmlChar *version = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);

            changelog->minor_version = atoi((const gchar *) version);

            xmlFree(version);

        }

        if (!xmlStrcmp(cur->name, (const xmlChar *) "VersionMicro")) {

            xmlChar *version = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);

            changelog->micro_version = atoi((const gchar *) version);

            xmlFree(version);

        }

        if (!translated_entry_seen && !xmlStrcmp(cur->name, (const xmlChar *) "Entry")) {

            xmlChar *entry = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);

            changelog->entries = g_list_append(changelog->entries, g_strdup((const char *) entry));

            xmlFree(entry);

        }

        if (!xmlStrcmp(cur->name, (const xmlChar *) "Entry-i18n")) {

            xmlChar *prop = xmlNodeGetLang(cur);

            xmlChar *entry;

            if (!prop) {

                cur = cur->next;

                continue;

            }

            if (!lang_requested) {

                i = 0;

                while (langs[i]) {

                    if (!strcmp((const char *) prop, langs[i])) {

                        break;

                    }

                    i++;

                }

                /* Did we find a match? */

                if (langs[i]) {

                    lang_requested = langs[i];

                } else {

                    /* Nope, ignore the entry */

                    xmlFree(prop);

                    cur = cur->next;

                    continue;

                }

            } else if (strcmp((const char *) prop, lang_requested)) {

                /* Other language found, ignore */

                xmlFree(prop);

                cur = cur->next;

                continue;

            }

            translated_entry_seen = TRUE;

            entry = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);

            changelog->entries = g_list_append(changelog->entries, g_strdup((const char *) entry));

            xmlFree(entry);

            xmlFree(prop);

        }

        cur = cur->next;

    }

}

static void

parse_changelogs(xmlDocPtr doc, xmlNodePtr cur, UpdateInfo *info)

{

    while(cur != NULL) {

        if (!xmlStrcmp(cur->name, (const xmlChar *) "Version")) {

            ChangeLog *changelog = g_slice_new0(ChangeLog);

            info->changelogs = g_list_append(info->changelogs, changelog);

            parse_changelog(doc, cur->xmlChildrenNode, changelog);

        }

        cur = cur->next;

    }

}

static void

parse_info(xmlDocPtr doc, xmlNodePtr cur, UpdateInfo *info)

{

    while(cur != NULL) {

        // stable

        if (!xmlStrcmp(cur->name, (const xmlChar *) "LatestStableMajor")) {

            xmlChar *version = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);

            info->stable_major_version = atoi((const gchar *) version);

            xmlFree(version);

        }

        if (!xmlStrcmp(cur->name, (const xmlChar *) "LatestStableMinor")) {

            xmlChar *version = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);

            info->stable_minor_version = atoi((const gchar *) version);

            xmlFree(version);

        }

        if (!xmlStrcmp(cur->name, (const xmlChar *) "LatestStableMicro")) {

            xmlChar *version = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);

            info->stable_micro_version = atoi((const gchar *) version);

            xmlFree(version);

        }

        if (!xmlStrcmp(cur->name, (const xmlChar *) "DateLatestVersion")) {

            struct tm *now;

            xmlChar *version = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);

            info->date_latest_stable_version = atoi((const gchar *) version);

            xmlFree(version);

            if ((now = localtime(&info->date_latest_stable_version)) != NULL) {

                strftime(info->date_latest_stable_version_str, sizeof(info->date_latest_stable_version_str), "%x", now);

            }

        }

        // unstable

        if (!xmlStrcmp(cur->name, (const xmlChar *) "LatestUnstableMajor")) {

            xmlChar *version = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);

            info->unstable_major_version = atoi((const gchar *) version);

            xmlFree(version);

        }

        if (!xmlStrcmp(cur->name, (const xmlChar *) "LatestUnstableMinor")) {

            xmlChar *version = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);

            info->unstable_minor_version = atoi((const gchar *) version);

            xmlFree(version);

        }

        if (!xmlStrcmp(cur->name, (const xmlChar *) "LatestUnstableMicro")) {

            xmlChar *version = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);

            info->unstable_micro_version = atoi((const gchar *) version);

            xmlFree(version);

        }

        if (!xmlStrcmp(cur->name, (const xmlChar *) "DateLatestUnstable")) {

            struct tm *now;

            xmlChar *version = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);

            info->date_latest_unstable_version = atoi((const gchar *) version);

            xmlFree(version);

            if ((now = localtime(&info->date_latest_unstable_version)) != NULL) {

                strftime(info->date_latest_unstable_version_str, sizeof(info->date_latest_unstable_version_str), "%x", now);

            }

        }

        cur = cur->next;

    }

}

static UpdateInfo *

parse_version_info(const char *contents, char **errmsg)

{

    xmlDocPtr    doc;

    xmlNodePtr   cur;

    UpdateInfo  *info = NULL;

    xmlSetGenericErrorFunc(NULL, xml_parser_error_func);

    if (xml_parser_errmsg) {

        g_free(xml_parser_errmsg);

        xml_parser_errmsg = NULL;

    }

    doc = xmlParseMemory(contents, strlen(contents));

    cur = xmlDocGetRootElement(doc);

    if (cur == NULL) {

        if (errmsg) {

            *errmsg = g_strdup(xml_parser_errmsg);

        }

        g_free(xml_parser_errmsg);

        xml_parser_errmsg = NULL;

        xmlFreeDoc(doc);

        return NULL;

    }

    if (xmlStrcmp(cur->name, (const xmlChar *) "NNTPGrab")) {

        if (errmsg) {

            *errmsg = g_strdup("parse_version_info: document of the wrong type, root node != NNTPGrab");

        }

        xmlFreeDoc(doc);

        return FALSE;

    }

    cur = cur->xmlChildrenNode;

    if (!cur) {

        if (errmsg) {

            *errmsg = g_strdup("parse_version_info: no children of root-node!");

        }

        xmlFreeDoc(doc);

        return FALSE;

    }

    info = g_slice_new0(UpdateInfo);

    do {

        if (!xmlStrcmp(cur->name, (const xmlChar *) "VersionInfo")) {

            parse_info(doc, cur->xmlChildrenNode, info);

        }

        if (!xmlStrcmp(cur->name, (const xmlChar *) "ChangeLog")) {

            parse_changelogs(doc, cur->xmlChildrenNode, info);

        }

    } while ((cur=cur->next));

    xmlFreeDoc(doc);

    return info;

}

static void

insert_link(GtkTextBuffer *buffer, GtkTextIter *iter, gchar *text)

{

    GtkTextTag *tag;

    tag = gtk_text_buffer_create_tag (buffer, NULL, "foreground", "blue", "underline", PANGO_UNDERLINE_SINGLE, "justification", GTK_JUSTIFY_CENTER, NULL);

    g_object_set_data (G_OBJECT (tag), "is_link", GINT_TO_POINTER (1));

    gtk_text_buffer_insert_with_tags (buffer, iter, text, -1, tag, NULL);

}

static void

follow_if_link(GtkWidget *text_view, GtkTextIter *iter)

{

    GSList *tags = NULL, *tagp = NULL;

    tags = gtk_text_iter_get_tags (iter);

    for (tagp = tags;  tagp != NULL;  tagp = tagp->next) {

        GtkTextTag *tag = tagp->data;

        gboolean is_link = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tag), "is_link"));

        if (is_link) {

            open_uri(NULL, "https://www.nntpgrab.nl", NULL);

            break;

        }

    }

    if (tags) {

        g_slist_free (tags);

    }

}

static gboolean

event_after(GtkWidget *text_view, GdkEvent  *ev)

{

    GtkTextIter start, end, iter;

    GtkTextBuffer *buffer;

    GdkEventButton *event;

    gint x, y;

    if (ev->type != GDK_BUTTON_RELEASE) {

        return FALSE;

    }

    event = (GdkEventButton *)ev;

    if (event->button != 1) {

        return FALSE;

    }

    buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));

    /* we shouldn't follow a link if the user has selected something */

    gtk_text_buffer_get_selection_bounds (buffer, &start, &end);

    if (gtk_text_iter_get_offset (&start) != gtk_text_iter_get_offset (&end)) {

        return FALSE;

    }

    gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (text_view), GTK_TEXT_WINDOW_WIDGET, event->x, event->y, &x, &y);

    gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (text_view), &iter, x, y);

    follow_if_link (text_view, &iter);

    return FALSE;

}

static gboolean hovering_over_link = FALSE;

static GdkCursor *hand_cursor = NULL;

static GdkCursor *regular_cursor = NULL;

/* Looks at all tags covering the position (x, y) in the text view, 

 * and if one of them is a link, change the cursor to the "hands" cursor

 * typically used by web browsers.

 */

static void

set_cursor_if_appropriate(GtkTextView *text_view, gint x, gint y)

{

    GSList *tags = NULL, *tagp = NULL;

    GtkTextIter iter;

    gboolean hovering = FALSE;

    gtk_text_view_get_iter_at_location (text_view, &iter, x, y);

    tags = gtk_text_iter_get_tags (&iter);

    for (tagp = tags;  tagp != NULL;  tagp = tagp->next) {

        GtkTextTag *tag = tagp->data;

        gboolean is_link = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tag), "is_link"));

        if (is_link != 0) {

            hovering = TRUE;

            break;

        }

    }

    if (hovering != hovering_over_link) {

        hovering_over_link = hovering;

        if (hovering_over_link) {

            gdk_window_set_cursor (gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT), hand_cursor);

        } else {

            gdk_window_set_cursor (gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT), regular_cursor);

        }

    }

    if (tags) {

        g_slist_free (tags);

    }

}

/* Update the cursor image if the pointer moved. 

 */

static gboolean

motion_notify_event (GtkWidget *text_view, GdkEventMotion *event)

{

    gint x, y;

    gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW (text_view), GTK_TEXT_WINDOW_WIDGET, event->x, event->y, &x, &y);

    set_cursor_if_appropriate (GTK_TEXT_VIEW (text_view), x, y);

#if GTK_CHECK_VERSION(2,14,0)

    gdk_window_get_pointer (gtk_widget_get_window(text_view), NULL, NULL, NULL);

#else

    gdk_window_get_pointer (text_view->window, NULL, NULL, NULL);

#endif

    return FALSE;

}

/* Also update the cursor image if the window becomes visible 

 * (e.g. when a window covering it got iconified).

 */

static gboolean

visibility_notify_event (GtkWidget *text_view, GdkEventVisibility *event)

{

    gint wx, wy, bx, by;

#if GTK_CHECK_VERSION(2,14,0)

    gdk_window_get_pointer (gtk_widget_get_window(text_view), &wx, &wy, NULL);

#else

    gdk_window_get_pointer (text_view->window, &wx, &wy, NULL);

#endif

    gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (text_view), GTK_TEXT_WINDOW_WIDGET, wx, wy, &bx, &by);

    set_cursor_if_appropriate (GTK_TEXT_VIEW (text_view), bx, by);

    return FALSE;

}

#define CHECK_VERSION_IS_OLDER(major,minor,micro)    \

    (MAJOR_VERSION < (major) || \

     (MAJOR_VERSION == (major) && MINOR_VERSION < (minor)) || \

     (MAJOR_VERSION == (major) && MINOR_VERSION == (minor) && \

      MICRO_VERSION < (micro)))

#define CHECK_IS_VERSION(major,minor,micro)    \

     (MAJOR_VERSION == (major) && MINOR_VERSION == (minor) && MICRO_VERSION == (micro))

static GtkWidget *

generate_version_table(UpdateInfo *info)

{

    GtkWidget *table;

    GtkWidget *label;

    char tmp[64];

    gboolean unstable_available;

    if (info->unstable_major_version > 0 ||

        info->unstable_minor_version > 0 ||

        info->unstable_micro_version > 0) {

        table = gtk_table_new(3, 2, FALSE);

        unstable_available = TRUE;

    } else {

        table = gtk_table_new(2, 2, FALSE);

        unstable_available = FALSE;

    }

    /* Active version */

    label = gtk_label_new(_("You are using version:"));

    gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, 0, 5, 1);

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

    snprintf(tmp, sizeof(tmp) - 1, "%i.%i.%i", MAJOR_VERSION, MINOR_VERSION, MICRO_VERSION);

    label = gtk_label_new(tmp);

    gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, 0, 5, 1);

    /* Latest available stable */

    if (unstable_available) {

        label = gtk_label_new(_("The latest available stable version is:"));

    } else {

        label = gtk_label_new(_("The latest available version is:"));

    }

    gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, 0, 5, 1);

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

    snprintf(tmp, sizeof(tmp) - 1, "%i.%i.%i", info->stable_major_version, info->stable_minor_version, info->stable_micro_version);

    label = gtk_label_new(tmp);

    gtk_table_attach(GTK_TABLE(table), label, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, 0, 5, 1);

    /* Latest available unstable */

    if (unstable_available) {

        label = gtk_label_new(_("The latest available unstable version is:"));

        gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, 0, 5, 1);

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

        snprintf(tmp, sizeof(tmp) - 1, "%i.%i.%i", info->unstable_major_version, info->unstable_minor_version, info->unstable_micro_version);

        label = gtk_label_new(tmp);

        gtk_table_attach(GTK_TABLE(table), label, 1, 2, 2, 3, GTK_EXPAND | GTK_FILL, 0, 5, 1);

    }

    gtk_widget_show_all(table);

    return table;

}

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wpointer-to-int-cast"

static void

generate_html(UpdateInfo *info)

{

    GtkWidget *textview;

    GtkTextBuffer *buffer;

    GtkTextIter iter;

    GtkTextIter iter2;

    GtkWidget *table;

    GtkTextChildAnchor *anchor;

    char *data;

    textview = nntpgrab_gui_base_get_widget("htmlInformation");

    buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));

    gtk_text_buffer_get_end_iter(buffer, &iter);

    table = generate_version_table(info);

    anchor = gtk_text_buffer_create_child_anchor (buffer, &iter);

    gtk_text_view_add_child_at_anchor(GTK_TEXT_VIEW(textview), table, anchor);

    iter2 = iter;

    gtk_text_iter_backward_char(&iter2);

    gtk_text_buffer_apply_tag_by_name(buffer, "center", &iter2, &iter);

    gtk_text_buffer_insert(buffer, &iter, "\n\n", -1);

    if (info->unstable_major_version < 0 && CHECK_IS_VERSION(info->stable_major_version, info->stable_minor_version, info->stable_micro_version)) {

        gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, _("You are using the latest version of NNTPGrab"), -1, "center", NULL);

        gtk_text_buffer_insert(buffer, &iter, "\n", -1);

        gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,  _("For more information, go to our website "), -1, "center", NULL);

        insert_link(buffer, &iter, "https://www.nntpgrab.nl");

    } else if (CHECK_IS_VERSION(info->unstable_major_version, info->unstable_minor_version, info->unstable_micro_version)) {

        data = g_strdup_printf("%s\n%s\n\n", _("You are using the latest unstable version of NNTPGrab"), _("If you find any bugs with this version, please report these"));

        gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, data, -1, "center", NULL);

        g_free(data);

        gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,  _("For more information, go to our website "), -1, "center", NULL);

        insert_link(buffer, &iter, "https://www.nntpgrab.nl");

    } else if ((info->unstable_major_version < 0 && !(CHECK_VERSION_IS_OLDER(info->stable_major_version, info->stable_minor_version, info->stable_micro_version))) ||

               (info->unstable_major_version >=0 && !(CHECK_VERSION_IS_OLDER(info->unstable_major_version, info->unstable_minor_version, info->unstable_micro_version)))) {

        data = g_strdup_printf("%s\n%s %"G_GUINT64_FORMAT" (%s %"G_GUINT64_FORMAT") %s %"G_GUINT64_FORMAT"\n\n", _("You are using a snapshot version of NNTPGrab"), _("This is subversion revision"), (guint64) GET_BUILD_SVN_REV, _("build"), (guint64) GET_BUILD_NUMBER, _("which was built on "), (guint64) GET_BUILD_DATE);

        gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, data, -1, "center", NULL);

        g_free(data);

        gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,  _("For more information, go to our website "), -1, "center", NULL);

        insert_link(buffer, &iter, "https://www.nntpgrab.nl");

    } else {

        GList *list;

        GList *list2;

        if (info->unstable_major_version >= 0) {

            gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, _("A new unstable version of NNTPGrab is available!"), -1, "center", "x-large", "bold", NULL);

            data = g_strdup_printf("\n\n%s %i.%i.%i %s %s %s\n\n", _("Version"), info->unstable_major_version, info->unstable_minor_version, info->unstable_micro_version, _("is released on"), info->date_latest_unstable_version_str, _("and contains the following changes :"));

        } else {

            gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, _("A new version of NNTPGrab is available!"), -1, "center", "x-large", "bold", NULL);

            data = g_strdup_printf("\n\n%s %i.%i.%i %s %s %s\n\n", _("Version"), info->stable_major_version, info->stable_minor_version, info->stable_micro_version, _("is released on"), info->date_latest_stable_version_str, _("and contains the following changes :"));

        }

        gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, data, -1, "center", NULL);

        g_free(data);

        list = info->changelogs;

        while (list) {

            ChangeLog *changelog = list->data;

            if (!CHECK_VERSION_IS_OLDER(changelog->major_version, changelog->minor_version, changelog->micro_version)) {

                list = g_list_next(list);

                continue;

            }

            data = g_strdup_printf("%s %i.%i.%i:\n\n", _("Changes in version"), changelog->major_version, changelog->minor_version, changelog->micro_version);

            gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, data, -1, "underline", "bold", NULL);

            g_free(data);

            list2 = changelog->entries;

            while (list2) {

                char *entry = list2->data;

                data = g_strdup_printf("• %s\n", entry);

                gtk_text_buffer_insert(buffer, &iter, data, -1);

                g_free(data);

                list2 = g_list_next(list2);

            }

            gtk_text_buffer_insert(buffer, &iter, "\n", -1);

            list = g_list_next(list);

        }

        gtk_text_buffer_insert(buffer, &iter, "\n", -1);

        if (info->unstable_major_version >= 0) {

            gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, _("Please note that the unstable version may still contain bugs, so only use the unstable version when you want to help out testing"), -1, "center", "bold", NULL);

            gtk_text_buffer_insert(buffer, &iter, "\n\n", -1);

        }

        gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, _("To retrieve the latest version and for more information, go to our website "), -1, "center", NULL);

        insert_link(buffer, &iter, "https://www.nntpgrab.nl");

    }

}

#pragma GCC diagnostic pop

static gboolean

process_update_info(gpointer data)

{

    UpdateInfo *info;

    GList *list;

    char *errmsg = NULL;

    char *contents = (char*) data;

    if (!contents) {

        // Update check failed

        GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

        nntpgrab_gui_base_dialog_show(windowMain, _("Update check failed"), GTK_MESSAGE_ERROR, GTK_BUTTONS_OK);

        return FALSE;

    }

    info = parse_version_info(contents, &errmsg);

    g_free(contents);

    if (!info) {

        // Invalid data received

        char *msg;

        GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

        msg = g_strdup_printf(_("Update check failed due to invalid data:\n%s"), errmsg);

        nntpgrab_gui_base_dialog_show(windowMain, msg, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK);

        g_free(msg);

        g_free(errmsg);

        return FALSE;

    }

    generate_html(info);

    list = info->changelogs;

    while (list) {

        ChangeLog *changelog = list->data;

        GList *list2;

        list2 = changelog->entries;

        while (list2) {

            g_free(list2->data);

            list2 = g_list_next(list2);

        }

        g_list_free(changelog->entries);

        g_slice_free(ChangeLog, list->data);

        list = g_list_next(list);

    }

    g_list_free(info->changelogs);

    g_slice_free(UpdateInfo, info);

    return FALSE;

}

#ifdef HAVE_SOUP

static void

update_info_received(SoupSession *session, SoupMessage *msg, gpointer data)

{

    if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {

        process_update_info(NULL);

        //g_object_unref(session);

        return;

    }

    process_update_info(g_strdup(msg->response_body->data));

    //g_object_unref(session);

}

#else

static gpointer

check_for_updates(gpointer data)

{

    char *contents;

    contents = retrieve_website_info();

    g_idle_add(process_update_info, contents);

    return NULL;

}

#endif

void

info_initialize()

{

    GtkWidget *textview;

    GtkTextBuffer *buffer;

    GtkTextIter iter;

    textview = nntpgrab_gui_base_get_widget("htmlInformation");

    buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));

    gtk_text_buffer_create_tag (buffer, "extra_top_margin", "pixels-above-lines", 5, "pixels-above-lines-set", TRUE, NULL);

    gtk_text_buffer_create_tag (buffer, "underline", "underline", PANGO_UNDERLINE_SINGLE, "underline_set", TRUE, NULL);

    gtk_text_buffer_create_tag (buffer, "bold", "weight", PANGO_WEIGHT_BOLD, NULL);

    gtk_text_buffer_create_tag (buffer, "center", "justification", GTK_JUSTIFY_CENTER, NULL);

    gtk_text_buffer_create_tag (buffer, "x-large", "scale", PANGO_SCALE_X_LARGE, NULL);

    gtk_text_buffer_create_tag (buffer, "xx-large", "scale", PANGO_SCALE_XX_LARGE, NULL);

    gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);

    gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, _("Welcome to NNTPGrab"), -1, "extra_top_margin", "center", "xx-large", "bold", NULL);

    gtk_text_buffer_insert(buffer, &iter, "\n\n", -1);

    g_signal_connect (textview, "event-after", G_CALLBACK (event_after), NULL);

    g_signal_connect (textview, "motion-notify-event", G_CALLBACK (motion_notify_event), NULL);

    g_signal_connect (textview, "visibility-notify-event", G_CALLBACK (visibility_notify_event), NULL);

    hand_cursor = gdk_cursor_new (GDK_HAND2);

    regular_cursor = gdk_cursor_new (GDK_XTERM);

#ifndef HAVE_SOUP

    /* cURL doesn't support async transfers so we spawn a seperate thread for it */

    g_thread_create(check_for_updates, NULL, TRUE, NULL);

#else

    SoupSession *session = soup_session_sync_new();

    SoupMessage *msg;

    char *user_agent;

#if 0 

    SoupLogger *logger = soup_logger_new(SOUP_LOGGER_LOG_BODY, -1);

    soup_session_add_feature(session, SOUP_SESSION_FEATURE(logger));

    g_object_unref(logger);

#endif

#ifdef HAVE_SOUP_GNOME

    /* Enable proxy support when using GNOME 2.26.0 or higher */

    soup_session_add_feature_by_type(session, SOUP_TYPE_GNOME_FEATURES_2_26);

#endif

#ifdef HAVE_SOUP_GZIP

    /* Enable gzip compression */

    soup_session_add_feature_by_type(session, SOUP_TYPE_CONTENT_DECODER);

#endif

    msg = soup_message_new ("GET", "https://www.nntpgrab.nl/info.php");

    user_agent = g_strdup("NNTPGrab version " VERSION " (" OS ")");

    soup_message_headers_append(msg->request_headers, "User-Agent", user_agent);

    g_free(user_agent);

    soup_message_headers_append(msg->request_headers, "Keep-Alive", "30");

    soup_message_headers_append(msg->request_headers, "Connection", "Keep-alive");

    soup_session_queue_message(session, msg, update_info_received, NULL);

#endif

}

G_MODULE_EXPORT void

on_btnDonate_clicked(GtkWidget *caller, gpointer data)

{

    open_uri(NULL, "https://www.nntpgrab.nl/donate.php", NULL);

}