path: root/e-util/e-stock-request.c

/*
 * e-stock-request.c
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) version 3.
 *
 * 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 */

#define LIBSOUP_USE_UNSTABLE_REQUEST_API

#include "e-stock-request.h"

#include <stdlib.h>
#include <gtk/gtk.h>
#include <libsoup/soup.h>

#include <string.h>

#define E_STOCK_REQUEST_GET_PRIVATE(obj) \
    (G_TYPE_INSTANCE_GET_PRIVATE \
    ((obj), E_TYPE_STOCK_REQUEST, EStockRequestPrivate))

struct _EStockRequestPrivate {
    gchar *content_type;
    gint content_length;
};

static const gchar *data_schemes[] = { "gtk-stock", NULL };

G_DEFINE_TYPE (EStockRequest, e_stock_request, SOUP_TYPE_REQUEST)

static gboolean
handle_stock_request_idle_cb (gpointer user_data)
{
    EStockRequestPrivate *priv;
    GSimpleAsyncResult *simple;
    GObject *object;
    SoupURI *uri;
    GHashTable *query = NULL;
    GtkStyleContext *context;
    GtkWidgetPath *path;
    GtkIconSet *icon_set;
    gssize size = GTK_ICON_SIZE_BUTTON;
    gchar *a_size;
    gchar *buffer = NULL;
    gsize buff_len = 0;
    GError *local_error = NULL;

    simple = G_SIMPLE_ASYNC_RESULT (user_data);

    /* This returns a new reference. */
    object = g_async_result_get_source_object (G_ASYNC_RESULT (simple));

    priv = E_STOCK_REQUEST_GET_PRIVATE (object);

    uri = soup_request_get_uri (SOUP_REQUEST (object));
    if (uri->query != NULL)
        query = soup_form_decode (uri->query);

    if (query != NULL) {
        a_size = g_hash_table_lookup (query, "size");
        if (a_size != NULL)
            size = atoi (a_size);
        g_hash_table_destroy (query);
    }

    /* Try style context first */
    context = gtk_style_context_new ();
    path = gtk_widget_path_new ();
    gtk_widget_path_append_type (path, GTK_TYPE_WINDOW);
    gtk_widget_path_append_type (path, GTK_TYPE_BUTTON);
    gtk_style_context_set_path (context, path);
    gtk_widget_path_free (path);

    icon_set = gtk_style_context_lookup_icon_set (context, uri->host);
    if (icon_set != NULL) {
        GdkPixbuf *pixbuf;

        pixbuf = gtk_icon_set_render_icon_pixbuf (
            icon_set, context, size);
        gdk_pixbuf_save_to_buffer (
            pixbuf, &buffer, &buff_len,
            "png", &local_error, NULL);
        g_object_unref (pixbuf);

    /* Fallback to icon theme */
    } else {
        GtkIconTheme *icon_theme;
        GtkIconInfo *icon_info;
        const gchar *filename;

        icon_theme = gtk_icon_theme_get_default ();

        icon_info = gtk_icon_theme_lookup_icon (
            icon_theme, uri->host, size,
            GTK_ICON_LOOKUP_USE_BUILTIN);

        filename = gtk_icon_info_get_filename (icon_info);
        if (filename != NULL) {
            g_file_get_contents (
                filename, &buffer, &buff_len, &local_error);
            priv->content_type =
                g_content_type_guess (filename, NULL, 0, NULL);

        } else {
            GdkPixbuf *pixbuf;

            pixbuf = gtk_icon_info_get_builtin_pixbuf (icon_info);
            if (pixbuf != NULL) {
                gdk_pixbuf_save_to_buffer (
                    pixbuf, &buffer, &buff_len,
                    "png", &local_error, NULL);
                g_object_unref (pixbuf);
            }
        }

        gtk_icon_info_free (icon_info);
    }

    /* Sanity check */
    g_return_val_if_fail (
        ((buffer != NULL) && (local_error == NULL)) ||
        ((buffer == NULL) && (local_error != NULL)), FALSE);

    if (priv->content_type == NULL)
        priv->content_type = g_strdup ("image/png");
    priv->content_length = buff_len;

    if (buffer != NULL) {
        GInputStream *stream;

        stream = g_memory_input_stream_new_from_data (
            buffer, buff_len, (GDestroyNotify) g_free);
        g_simple_async_result_set_op_res_gpointer (
            simple, g_object_ref (stream),
            (GDestroyNotify) g_object_unref);
        g_object_unref (stream);
    }

    if (local_error != NULL)
        g_simple_async_result_take_error (simple, local_error);

    g_simple_async_result_complete_in_idle (simple);

    g_object_unref (context);
    g_object_unref (object);

    return FALSE;
}

static void
stock_request_finalize (GObject *object)
{
    EStockRequestPrivate *priv;

    priv = E_STOCK_REQUEST_GET_PRIVATE (object);

    g_free (priv->content_type);

    /* Chain up to parent's finalize() method. */
    G_OBJECT_CLASS (e_stock_request_parent_class)->finalize (object);
}

static gboolean
stock_request_check_uri (SoupRequest *request,
                         SoupURI *uri,
                         GError **error)
{
    return (strcmp (uri->scheme, "gtk-stock") == 0);
}

static void
stock_request_send_async (SoupRequest *request,
                          GCancellable *cancellable,
                          GAsyncReadyCallback callback,
                          gpointer user_data)
{
    GSimpleAsyncResult *simple;

    simple = g_simple_async_result_new (
        G_OBJECT (request), callback, user_data,
        stock_request_send_async);

    g_simple_async_result_set_check_cancellable (simple, cancellable);

    /* Need to run this operation in an idle callback rather
     * than a worker thread, since we're making all kinds of
     * GdkPixbuf/GTK+ calls. */
    g_idle_add_full (
        G_PRIORITY_HIGH_IDLE,
        handle_stock_request_idle_cb,
        g_object_ref (simple),
        (GDestroyNotify) g_object_unref);

    g_object_unref (simple);
}

static GInputStream *
stock_request_send_finish (SoupRequest *request,
                           GAsyncResult *result,
                           GError **error)
{
    GSimpleAsyncResult *simple;
    GInputStream *stream;

    simple = G_SIMPLE_ASYNC_RESULT (result);
    stream = g_simple_async_result_get_op_res_gpointer (simple);

    if (g_simple_async_result_propagate_error (simple, error))
        return NULL;

    /* Reset the stream before passing it back to WebKit. */
    if (G_IS_SEEKABLE (stream))
        g_seekable_seek (
            G_SEEKABLE (stream), 0,
            G_SEEK_SET, NULL, NULL);

    if (stream != NULL)
        return g_object_ref (stream);

    return g_memory_input_stream_new ();
}

static goffset
stock_request_get_content_length (SoupRequest *request)
{
    EStockRequestPrivate *priv;

    priv = E_STOCK_REQUEST_GET_PRIVATE (request);

    return priv->content_length;
}

static const gchar *
stock_request_get_content_type (SoupRequest *request)
{
    EStockRequestPrivate *priv;

    priv = E_STOCK_REQUEST_GET_PRIVATE (request);

    return priv->content_type;
}

static void
e_stock_request_class_init (EStockRequestClass *class)
{
    GObjectClass *object_class;
    SoupRequestClass *request_class;

    g_type_class_add_private (class, sizeof (EStockRequestPrivate));

    object_class = G_OBJECT_CLASS (class);
    object_class->finalize = stock_request_finalize;

    request_class = SOUP_REQUEST_CLASS (class);
    request_class->schemes = data_schemes;
    request_class->check_uri = stock_request_check_uri;
    request_class->send_async = stock_request_send_async;
    request_class->send_finish = stock_request_send_finish;
    request_class->get_content_length = stock_request_get_content_length;
    request_class->get_content_type = stock_request_get_content_type;
}

static void
e_stock_request_init (EStockRequest *request)
{
    request->priv = E_STOCK_REQUEST_GET_PRIVATE (request);
}