From 5c69e0269dc591fbecf948481982ddea2fd57a55 Mon Sep 17 00:00:00 2001 From: Christian Dywan Date: Fri, 24 Oct 2008 00:09:12 +0200 Subject: [PATCH] Implement KatzeNet as a generic URI loader KatzeNet can from now on be used where URIs are handled and one would have used libSoup and/ or local file handling as appropriate, whereas KatzeNet does both. Since we are displaying icons in several places KatzeNet also provides an icon loader that saves us from doublicating even more code. All bookmarks and also history items have icons now, since KatzeNet makes that incredibly easy. Search engines are also using favicons now, and right now custom icons don't work, we still need to fix that. Note that only icons are cached, nothing else and the code is known to have a hidden, hard to reproduce crasher which may appear when an icon is newly loaded. --- katze/Makefile.am | 3 +- katze/katze-arrayaction.c | 27 +- katze/katze-net.c | 511 +++++++++++++++++++++++++++++++++++ katze/katze-net.h | 86 ++++++ katze/katze-utils.c | 53 ++++ katze/katze-utils.h | 6 + katze/katze.h | 1 + katze/wscript_build | 2 +- midori/midori-browser.c | 122 ++++----- midori/midori-searchaction.c | 66 +++-- midori/midori-source.c | 96 ++----- midori/midori-view.c | 151 +---------- 12 files changed, 804 insertions(+), 320 deletions(-) create mode 100644 katze/katze-net.c create mode 100644 katze/katze-net.h diff --git a/katze/Makefile.am b/katze/Makefile.am index a6b17545..7729d067 100644 --- a/katze/Makefile.am +++ b/katze/Makefile.am @@ -19,4 +19,5 @@ libkatze_la_SOURCES = \ katze-item.c katze-item.h \ katze-list.c katze-list.h \ katze-array.c katze-array.h \ - katze-arrayaction.c katze-arrayaction.h + katze-arrayaction.c katze-arrayaction.h \ + katze-net.c katze-net.h diff --git a/katze/katze-arrayaction.c b/katze/katze-arrayaction.c index 2dfebb53..f0287362 100644 --- a/katze/katze-arrayaction.c +++ b/katze/katze-arrayaction.c @@ -11,6 +11,7 @@ #include "katze-arrayaction.h" +#include "katze-net.h" #include "katze-utils.h" #include @@ -21,6 +22,7 @@ struct _KatzeArrayAction GtkAction parent_instance; KatzeArray* array; + KatzeNet* net; }; struct _KatzeArrayActionClass @@ -130,6 +132,7 @@ static void katze_array_action_init (KatzeArrayAction* array_action) { array_action->array = NULL; + array_action->net = katze_net_new (); } static void @@ -137,8 +140,8 @@ katze_array_action_finalize (GObject* object) { KatzeArrayAction* array_action = KATZE_ARRAY_ACTION (object); - if (array_action->array) - g_object_unref (array_action->array); + katze_object_assign (array_action->array, NULL); + katze_object_assign (array_action->net, NULL); G_OBJECT_CLASS (katze_array_action_parent_class)->finalize (object); } @@ -209,6 +212,15 @@ katze_array_action_menu_item_activate_cb (GtkWidget* proxy, g_signal_emit (array_action, signals[ACTIVATE_ITEM], 0, item); } +static void +katze_array_action_icon_cb (GdkPixbuf* icon, + GtkWidget* menuitem) +{ + GtkWidget* image = gtk_image_new_from_pixbuf (icon); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image); + g_object_unref (menuitem); +} + static void katze_array_action_menu_item_select_cb (GtkWidget* proxy, KatzeArrayAction* array_action) @@ -242,9 +254,14 @@ katze_array_action_menu_item_select_cb (GtkWidget* proxy, } menuitem = katze_image_menu_item_new_ellipsized ( katze_item_get_name (item)); - pixbuf = gtk_widget_render_icon (menuitem, - KATZE_IS_ARRAY (item) ? GTK_STOCK_DIRECTORY : GTK_STOCK_FILE, - GTK_ICON_SIZE_MENU, NULL); + if (KATZE_IS_ARRAY (item)) + pixbuf = gtk_widget_render_icon (menuitem, + GTK_STOCK_DIRECTORY, GTK_ICON_SIZE_MENU, NULL); + else + pixbuf = katze_net_load_icon (array_action->net, + katze_item_get_uri (item), + (KatzeNetIconCb)katze_array_action_icon_cb, + proxy, g_object_ref (menuitem)); icon = gtk_image_new_from_pixbuf (pixbuf); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), icon); g_object_unref (pixbuf); diff --git a/katze/katze-net.c b/katze/katze-net.c new file mode 100644 index 00000000..fdbf938a --- /dev/null +++ b/katze/katze-net.c @@ -0,0 +1,511 @@ +/* + Copyright (C) 2008 Christian Dywan + + This library 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.1 of the License, or (at your option) any later version. + + See the file COPYING for the full license text. +*/ + +#if HAVE_CONFIG_H + #include +#endif + +#include "katze-net.h" + +#if HAVE_LIBSOUP + #include +#endif + +struct _KatzeNet +{ + GObject parent_instance; + + gchar* cache_path; + guint cache_size; + + #if HAVE_LIBSOUP + SoupSession* session; + #endif +}; + +struct _KatzeNetClass +{ + GObjectClass parent_class; +}; + +G_DEFINE_TYPE (KatzeNet, katze_net, G_TYPE_OBJECT) + +static void +katze_net_finalize (GObject* object); + +static void +katze_net_class_init (KatzeNetClass* class) +{ + GObjectClass* gobject_class; + + gobject_class = G_OBJECT_CLASS (class); + gobject_class->finalize = katze_net_finalize; +} + +static void +katze_net_init (KatzeNet* net) +{ + net->cache_path = g_build_filename (g_get_user_cache_dir (), + PACKAGE_NAME, NULL); + + #if HAVE_LIBSOUP + net->session = soup_session_async_new (); + #endif +} + +static void +katze_net_finalize (GObject* object) +{ + KatzeNet* net = KATZE_NET (object); + + katze_assign (net->cache_path, NULL); + + G_OBJECT_CLASS (katze_net_parent_class)->finalize (object); +} + +/** + * katze_net_new: + * + * Instantiates a new #KatzeNet singleton. + * + * Subsequent calls will ref the initial instance. + * + * Return value: a new #KatzeNet + **/ +KatzeNet* +katze_net_new (void) +{ + KatzeNet* net = g_object_new (KATZE_TYPE_NET, + NULL); + + return net; +} + +typedef struct +{ + KatzeNet* net; + KatzeNetStatusCb status_cb; + KatzeNetTransferCb transfer_cb; + gpointer user_data; + KatzeNetRequest* request; +} KatzeNetPriv; + +static void +katze_net_priv_free (KatzeNetPriv* priv) +{ + KatzeNetRequest* request; + + request = priv->request; + + g_free (request->uri); + g_free (request->mime_type); + g_free (request->data); + + g_free (request); + g_free (priv); +} + +static gchar* +katze_net_get_cached_path (KatzeNet* net, + const gchar* uri, + const gchar* subfolder) +{ + gchar* cache_path; + gchar* checksum; + gchar* extension; + gchar* cached_filename; + gchar* cached_path; + + if (subfolder) + cache_path = g_build_filename (net->cache_path, subfolder, NULL); + else + cache_path = net->cache_path; + g_mkdir_with_parents (cache_path, 0755); + #if GLIB_CHECK_VERSION (2, 16, 0) + checksum = g_compute_checksum_for_string (G_CHECKSUM_MD5, uri, -1); + #else + checksum = g_strdup_printf ("%u", g_str_hash (uri)); + #endif + + extension = g_strrstr (uri, "."); + cached_filename = g_strdup_printf ("%s%s%s", checksum, + extension ? "." : "", extension ? extension : ""); + g_free (checksum); + cached_path = g_build_filename (cache_path, cached_filename, NULL); + g_free (cached_filename); + if (subfolder) + g_free (cache_path); + return cached_path; +} + +#if HAVE_LIBSOUP +static void +katze_net_got_headers_cb (SoupMessage* msg, + KatzeNetPriv* priv) +{ + KatzeNetRequest* request; + + request = priv->request; + + switch (msg->status_code) + { + case 200: + request->status = KATZE_NET_VERIFIED; + break; + case 301: + request->status = KATZE_NET_MOVED; + break; + default: + request->status = KATZE_NET_NOT_FOUND; + } + + if (!priv->status_cb (request, priv->user_data)) + soup_session_cancel_message (priv->net->session, msg, msg->status_code); +} + +static void +katze_net_got_body_cb (SoupMessage* msg, + KatzeNetPriv* priv) +{ + KatzeNetRequest* request; + #if 0 + gchar* filename; + FILE* fp; + #endif + + request = priv->request; + + if (msg->response_body->length > 0) + { + #if 0 + /* FIXME: Caching */ + filename = katze_net_get_cached_path (net, request->uri, NULL); + if ((fp = fopen (filename, "wb"))) + { + fwrite (msg->response_body->data, + 1, msg->response_body->length, fp); + fclose (fp); + } + g_free (filename); + #endif + request->data = g_memdup (msg->response_body->data, + msg->response_body->length); + request->length = msg->response_body->length; + } + + priv->transfer_cb (request, priv->user_data); + katze_net_priv_free (priv); +} +#endif + +gboolean +katze_net_local_cb (KatzeNetPriv* priv) +{ + KatzeNetRequest* request; + gchar* filename; + gchar* contents; + gsize length; + + request = priv->request; + filename = g_filename_from_uri (request->uri, NULL, NULL); + + if (!filename || !g_file_test (filename, G_FILE_TEST_EXISTS)) + { + request->status = KATZE_NET_NOT_FOUND; + if (priv->status_cb) + priv->status_cb (request, priv->user_data); + katze_net_priv_free (priv); + return FALSE; + } + request->status = KATZE_NET_VERIFIED; + if (priv->status_cb && !priv->status_cb (request, priv->user_data)) + { + katze_net_priv_free (priv); + return FALSE; + } + + if (!priv->transfer_cb) + { + katze_net_priv_free (priv); + return FALSE; + } + + contents = NULL; + if (!g_file_get_contents (filename, &contents, &length, NULL)) + { + request->status = KATZE_NET_FAILED; + priv->transfer_cb (request, priv->user_data); + katze_net_priv_free (priv); + return FALSE; + } + + request->status = KATZE_NET_DONE; + request->data = contents; + request->length = length; + priv->transfer_cb (request, priv->user_data); + katze_net_priv_free (priv); + return FALSE; +} + +gboolean +katze_net_default_cb (KatzeNetPriv* priv) +{ + KatzeNetRequest* request; + + request = priv->request; + request->status = KATZE_NET_NOT_FOUND; + if (priv->status_cb) + priv->status_cb (request, priv->user_data); + katze_net_priv_free (priv); + return FALSE; +} + +/** + * katze_net_load_uri: + * @net: a #KatzeNet + * @uri: an URI string + * @status_cb: function to call for status information + * @transfer_cb: function to call upon transfer + * @user_data: data to pass to the callback + * + * Requests a transfer of @uri. + * + * @status_cb will be called when the status of @uri + * is verified. The specified callback may be called + * multiple times unless cancelled. + * + * @transfer_cb will be called when the data @uri is + * pointing to was transferred. Note that even a failed + * transfer may transfer data. + * + * @status_cb will always to be called at least once. + **/ +void +katze_net_load_uri (KatzeNet* net, + const gchar* uri, + KatzeNetStatusCb status_cb, + KatzeNetTransferCb transfer_cb, + gpointer user_data) +{ + KatzeNetRequest* request; + KatzeNetPriv* priv; + #if HAVE_LIBSOUP + SoupMessage* msg; + #endif + + g_return_if_fail (KATZE_IS_NET (net)); + g_return_if_fail (uri != NULL); + + if (!status_cb && !transfer_cb) + return; + + request = g_new0 (KatzeNetRequest, 1); + request->uri = g_strdup (uri); + request->mime_type = NULL; + request->data = NULL; + + priv = g_new0 (KatzeNetPriv, 1); + priv->net = net; + priv->status_cb = status_cb; + priv->transfer_cb = transfer_cb; + priv->user_data = user_data; + priv->request = request; + + #if HAVE_LIBSOUP + if (g_str_has_prefix (uri, "http://") || g_str_has_prefix (uri, "https://")) + { + msg = soup_message_new ("GET", uri); + if (status_cb) + g_signal_connect (msg, "got-headers", + G_CALLBACK (katze_net_got_headers_cb), priv); + if (transfer_cb) + g_signal_connect (msg, "got-body", + G_CALLBACK (katze_net_got_body_cb), priv); + soup_session_queue_message (net->session, msg, NULL, NULL); + return; + } + #endif + + if (g_str_has_prefix (uri, "file://")) + { + g_idle_add ((GSourceFunc)katze_net_local_cb, priv); + return; + } + + g_idle_add ((GSourceFunc)katze_net_default_cb, priv); +} + +typedef struct +{ + KatzeNet* net; + gchar* icon_file; + KatzeNetIconCb icon_cb; + GtkWidget* widget; + gpointer user_data; +} KatzeNetIconPriv; + +static void +katze_net_icon_priv_free (KatzeNetIconPriv* priv) +{ + g_free (priv->icon_file); + g_object_unref (priv->widget); + g_free (priv); +} + +static gboolean +katze_net_icon_status_cb (KatzeNetRequest* request, + KatzeNetIconPriv* priv) +{ + switch (request->status) + { + case KATZE_NET_VERIFIED: + if (request->mime_type && + !g_str_has_prefix (request->mime_type, "image/")) + { + katze_net_icon_priv_free (priv); + return FALSE; + } + break; + case KATZE_NET_MOVED: + break; + default: + katze_net_icon_priv_free (priv); + return FALSE; + } + + return TRUE; +} + +static void +katze_net_icon_transfer_cb (KatzeNetRequest* request, + KatzeNetIconPriv* priv) +{ + GdkPixbuf* pixbuf; + FILE* fp; + GdkPixbuf* pixbuf_scaled; + gint icon_width, icon_height; + + pixbuf = NULL; + if (request->data) + { + if ((fp = fopen (priv->icon_file, "wb"))) + { + fwrite (request->data, 1, request->length, fp); + fclose (fp); + pixbuf = gdk_pixbuf_new_from_file (priv->icon_file, NULL); + } + else if (priv->icon_cb) + pixbuf = katze_pixbuf_new_from_buffer ((guchar*)request->data, + request->length, request->mime_type, NULL); + } + + if (!priv->icon_cb) + { + katze_net_icon_priv_free (priv); + return; + } + + if (!pixbuf) + pixbuf = gtk_widget_render_icon (priv->widget, + GTK_STOCK_FILE, GTK_ICON_SIZE_MENU, NULL); + gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &icon_width, &icon_height); + pixbuf_scaled = gdk_pixbuf_scale_simple (pixbuf, icon_width, icon_height, + GDK_INTERP_BILINEAR); + g_object_unref (pixbuf); + + priv->icon_cb (pixbuf_scaled, priv->user_data); + katze_net_icon_priv_free (priv); +} + +/** + * katze_net_load_icon: + * @net: a #KatzeNet + * @uri: an URI string, or %NULL + * @icon_cb: function to call upon completion + * @widget: a related #GtkWidget + * @user_data: data to pass to the callback + * + * Requests a transfer of an icon for @uri. This is + * implemented by looking for a favicon.ico, an + * image according to the file type or even a + * generated icon. The provided icon is intended + * for user interfaces and not guaranteed to be + * the same over multiple requests, plus it may + * be scaled to fit the menu icon size. + * + * The @widget is needed for theming information. + * + * The caller is expected to use the returned icon + * and update it if @icon_cb is called. + * + * Depending on whether the icon was previously + * cached or @uri is a local resource, the returned + * icon may already be the final one. + **/ +GdkPixbuf* +katze_net_load_icon (KatzeNet* net, + const gchar* uri, + KatzeNetIconCb icon_cb, + GtkWidget* widget, + gpointer user_data) +{ + guint i; + KatzeNetIconPriv* priv; + gchar* icon_uri; + gchar* icon_file; + GdkPixbuf* pixbuf; + gint icon_width, icon_height; + GdkPixbuf* pixbuf_scaled; + + g_return_val_if_fail (KATZE_IS_NET (net), NULL); + + pixbuf = NULL; + if (uri && g_str_has_prefix (uri, "http://")) + { + i = 8; + while (uri[i] != '\0' && uri[i] != '/') + i++; + if (uri[i] == '/') + { + icon_uri = g_strdup (uri); + icon_uri[i] = '\0'; + icon_uri = g_strdup_printf ("%s/favicon.ico", icon_uri); + icon_file = katze_net_get_cached_path (net, icon_uri, "icons"); + + if (g_file_test (icon_file, G_FILE_TEST_EXISTS)) + pixbuf = gdk_pixbuf_new_from_file (icon_file, NULL); + else + { + priv = g_new0 (KatzeNetIconPriv, 1); + priv->net = net; + priv->icon_file = icon_file; + priv->icon_cb = icon_cb; + priv->widget = g_object_ref (widget); + priv->user_data = user_data; + + katze_net_load_uri (net, icon_uri, + (KatzeNetStatusCb)katze_net_icon_status_cb, + (KatzeNetTransferCb)katze_net_icon_transfer_cb, priv); + } + g_free (icon_uri); + } + } + + if (!pixbuf) + pixbuf = gtk_widget_render_icon (widget, + GTK_STOCK_FILE, GTK_ICON_SIZE_MENU, NULL); + gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &icon_width, &icon_height); + pixbuf_scaled = gdk_pixbuf_scale_simple (pixbuf, icon_width, icon_height, + GDK_INTERP_BILINEAR); + g_object_unref (pixbuf); + + return pixbuf_scaled; +} diff --git a/katze/katze-net.h b/katze/katze-net.h new file mode 100644 index 00000000..2b6f78c8 --- /dev/null +++ b/katze/katze-net.h @@ -0,0 +1,86 @@ +/* + Copyright (C) 2008 Christian Dywan + + This library 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.1 of the License, or (at your option) any later version. + + See the file COPYING for the full license text. +*/ + +#ifndef __KATZE_NET_H__ +#define __KATZE_NET_H__ + +#include "katze-utils.h" + +#include + +G_BEGIN_DECLS + +#define KATZE_TYPE_NET \ + (katze_net_get_type ()) +#define KATZE_NET(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), KATZE_TYPE_NET, KatzeNet)) +#define KATZE_NET_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), KATZE_TYPE_NET, KatzeNetClass)) +#define KATZE_IS_NET(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), KATZE_TYPE_NET)) +#define KATZE_IS_NET_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), KATZE_TYPE_NET)) +#define KATZE_NET_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), KATZE_TYPE_NET, KatzeNetClass)) + +typedef struct _KatzeNet KatzeNet; +typedef struct _KatzeNetClass KatzeNetClass; + +GType +katze_net_get_type (void); + +KatzeNet* +katze_net_new (void); + +typedef enum +{ + KATZE_NET_VERIFIED, + KATZE_NET_MOVED, + KATZE_NET_NOT_FOUND, + KATZE_NET_FAILED, + KATZE_NET_DONE +} KatzeNetStatus; + +typedef struct +{ + gchar* uri; + KatzeNetStatus status; + gchar* mime_type; + gchar* data; + gsize length; +} KatzeNetRequest; + +typedef gboolean (*KatzeNetStatusCb) (KatzeNetRequest* request, + gpointer user_data); + +typedef void (*KatzeNetTransferCb) (KatzeNetRequest* request, + gpointer user_data); + +void +katze_net_load_uri (KatzeNet* net, + const gchar* uri, + KatzeNetStatusCb status_cb, + KatzeNetTransferCb transfer_cb, + gpointer user_data); + +typedef void (*KatzeNetIconCb) (GdkPixbuf* icon, + gpointer user_data); + +GdkPixbuf* +katze_net_load_icon (KatzeNet* net, + const gchar* uri, + KatzeNetIconCb icon_cb, + GtkWidget* widget, + gpointer user_data); + +G_END_DECLS + +#endif /* __KATZE_NET_H__ */ diff --git a/katze/katze-utils.c b/katze/katze-utils.c index ce619781..f91542e1 100644 --- a/katze/katze-utils.c +++ b/katze/katze-utils.c @@ -463,3 +463,56 @@ katze_image_menu_item_new_ellipsized (const gchar* label) return menuitem; } + +/** + * katze_pixbuf_new_from_buffer: + * @buffer: Buffer with image data + * @length: Length of the buffer + * @mime_type: a MIME type, or %NULL + * @error: return location for a #GError, or %NULL + * + * Creates a new #GdkPixbuf out of the specified buffer. + * + * You can specify a MIME type if looking at the buffer + * is not enough to determine the right type. + * + * Return value: A newly-allocated #GdkPixbuf + **/ +GdkPixbuf* +katze_pixbuf_new_from_buffer (const guchar* buffer, + gsize length, + const gchar* mime_type, + GError** error) +{ + /* Proposed for inclusion in GdkPixbuf + See http://bugzilla.gnome.org/show_bug.cgi?id=74291 */ + GdkPixbufLoader* loader; + GdkPixbuf* pixbuf; + + g_return_val_if_fail (buffer != NULL, NULL); + g_return_val_if_fail (length > 0, NULL); + + if (mime_type) + { + loader = gdk_pixbuf_loader_new_with_mime_type (mime_type, error); + if (!loader) + return NULL; + } + else + loader = gdk_pixbuf_loader_new (); + if (!gdk_pixbuf_loader_write (loader, buffer, length, error)) + { + g_object_unref (loader); + return NULL; + } + if (!gdk_pixbuf_loader_close (loader, error)) + { + g_object_unref (loader); + return NULL; + } + + pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); + g_object_ref (pixbuf); + g_object_unref (loader); + return pixbuf; +} diff --git a/katze/katze-utils.h b/katze/katze-utils.h index 52ac45a8..97e5b8dc 100644 --- a/katze/katze-utils.h +++ b/katze/katze-utils.h @@ -78,6 +78,12 @@ katze_widget_popup (GtkWidget* widget, GtkWidget* katze_image_menu_item_new_ellipsized (const gchar* label); +GdkPixbuf* +katze_pixbuf_new_from_buffer (const guchar* buffer, + gsize length, + const gchar* mime_type, + GError** error); + G_END_DECLS #endif /* __KATZE_UTILS_H__ */ diff --git a/katze/katze.h b/katze/katze.h index eb4e2c40..a4cf626a 100644 --- a/katze/katze.h +++ b/katze/katze.h @@ -18,5 +18,6 @@ #include "katze-list.h" #include "katze-array.h" #include "katze-arrayaction.h" +#include "katze-net.h" #endif /* __KATZE_H__ */ diff --git a/katze/wscript_build b/katze/wscript_build index b3145552..ca4dddfb 100644 --- a/katze/wscript_build +++ b/katze/wscript_build @@ -7,7 +7,7 @@ obj.name = 'katze' obj.target = 'katze' obj.includes = '.' obj.find_sources_in_dirs ('.') -obj.uselib = 'GTK LIBXML' +obj.uselib = 'LIBSOUP GTK LIBXML' obj.inst_var = 0 # FIXME: Do not install this static lib diff --git a/midori/midori-browser.c b/midori/midori-browser.c index abc6a8fc..f89b78fb 100644 --- a/midori/midori-browser.c +++ b/midori/midori-browser.c @@ -39,10 +39,6 @@ #include #endif -#if HAVE_LIBSOUP - #include -#endif - struct _MidoriBrowser { GtkWindow parent_instance; @@ -80,9 +76,7 @@ struct _MidoriBrowser KatzeArray* search_engines; KatzeArray* history; - #if HAVE_LIBSOUP - SoupSession* session; - #endif + KatzeNet* net; }; G_DEFINE_TYPE (MidoriBrowser, midori_browser, GTK_TYPE_WINDOW) @@ -1654,31 +1648,24 @@ _action_zoom_normal_activate (GtkAction* action, midori_view_set_zoom_level (MIDORI_VIEW (view), 1.0f); } -#if HAVE_LIBSOUP static void -midori_browser_got_body_cb (SoupMessage* msg, - MidoriBrowser* browser) +midori_browser_transfer_cb (KatzeNetRequest* request, + MidoriBrowser* browser) { - SoupURI* soup_uri; - gchar* uri; gchar* filename; gchar* unique_filename; gchar* text_editor; gint fd; FILE* fp; - if (msg->response_body->length > 0) + if (request->data) { - soup_uri = soup_message_get_uri (msg); - uri = soup_uri_to_string (soup_uri, FALSE); - filename = g_strdup_printf ("%uXXXXXX", g_str_hash (uri)); - g_free (uri); + filename = g_strdup_printf ("%uXXXXXX", g_str_hash (request->uri)); if (((fd = g_file_open_tmp (filename, &unique_filename, NULL)) != -1)) { if ((fp = fdopen (fd, "w"))) { - fwrite (msg->response_body->data, - 1, msg->response_body->length, fp); + fwrite (request->data, 1, request->length, fp); fclose (fp); g_object_get (browser->settings, "text-editor", &text_editor, NULL); @@ -1691,20 +1678,14 @@ midori_browser_got_body_cb (SoupMessage* msg, g_free (filename); } } -#endif static void _action_source_view_activate (GtkAction* action, MidoriBrowser* browser) { gchar* text_editor; - const gchar* current_uri; - #if HAVE_LIBSOUP - SoupMessage* msg; - #endif GtkWidget* view; GtkWidget* source_view; - gchar* filename; gchar* uri; gint n; @@ -1714,24 +1695,11 @@ _action_source_view_activate (GtkAction* action, g_object_get (browser->settings, "text-editor", &text_editor, NULL); if (text_editor && *text_editor) { - current_uri = midori_view_get_display_uri (MIDORI_VIEW (view)); - #if HAVE_LIBSOUP - if (g_str_has_prefix (current_uri, "http://") || - g_str_has_prefix (current_uri, "https://")) - { - msg = soup_message_new ("GET", current_uri); - g_signal_connect (msg, "got-body", - G_CALLBACK (midori_browser_got_body_cb), browser); - soup_session_queue_message (browser->session, msg, NULL, NULL); - g_free (text_editor); - return; - } - #endif - if (g_str_has_prefix (current_uri, "file://")) - { - filename = g_filename_from_uri (current_uri, NULL, NULL); - sokoke_spawn_program (text_editor, filename); - } + katze_net_load_uri (browser->net, + midori_view_get_display_uri (MIDORI_VIEW (view)), + NULL, (KatzeNetTransferCb)midori_browser_transfer_cb, browser); + g_free (text_editor); + return; } else { @@ -2299,8 +2267,10 @@ midori_browser_bookmarks_item_render_icon_cb (GtkTreeViewColumn* column, pixbuf = gtk_widget_render_icon (treeview, GTK_STOCK_DIRECTORY, GTK_ICON_SIZE_MENU, NULL); else if (katze_item_get_uri (item)) - pixbuf = gtk_widget_render_icon (treeview, STOCK_BOOKMARK, - GTK_ICON_SIZE_MENU, NULL); + /* FIXME: Implement icon_cb */ + pixbuf = katze_net_load_icon ( + MIDORI_BROWSER (gtk_widget_get_toplevel (treeview))->net, + katze_item_get_uri (item), NULL, treeview, treeview); g_object_set (renderer, "pixbuf", pixbuf, NULL); if (pixbuf) g_object_unref (pixbuf); @@ -2394,7 +2364,8 @@ _midori_browser_create_bookmark_menu (MidoriBrowser* browser, const gchar* title; GtkWidget* menuitem; GtkWidget* submenu; - GtkWidget* icon; + GtkWidget* image; + GdkPixbuf* icon; n = katze_array_get_length (array); for (i = 0; i < n; i++) @@ -2419,9 +2390,16 @@ _midori_browser_create_bookmark_menu (MidoriBrowser* browser, else if (katze_item_get_uri (item)) { menuitem = sokoke_image_menu_item_new_ellipsized (title); - icon = gtk_image_new_from_stock (STOCK_BOOKMARK, GTK_ICON_SIZE_MENU); - gtk_widget_show (icon); - gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), icon); + image = gtk_image_new (); + /* FIXME: Implement icon_cb */ + icon = katze_net_load_icon (browser->net, + katze_item_get_uri (item), + NULL /*(KatzeNetIconCb)midori_browser_bookmark_icon_cb*/, + GTK_WIDGET (browser), NULL /*g_object_ref (image)*/); + gtk_image_set_from_pixbuf (GTK_IMAGE (image), icon); + g_object_unref (icon); + gtk_widget_show (image); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image); g_signal_connect (menuitem, "activate", G_CALLBACK (midori_browser_menu_bookmarks_item_activate_cb), browser); @@ -2466,8 +2444,10 @@ midori_browser_history_render_icon_cb (GtkTreeViewColumn* column, pixbuf = gtk_widget_render_icon (treeview, GTK_STOCK_DIRECTORY, GTK_ICON_SIZE_MENU, NULL); else - pixbuf = gtk_widget_render_icon (treeview, GTK_STOCK_FILE, - GTK_ICON_SIZE_MENU, NULL); + /* FIXME: Implement icon_cb */ + pixbuf = katze_net_load_icon ( + MIDORI_BROWSER (gtk_widget_get_toplevel (treeview))->net, + katze_item_get_uri (item), NULL, treeview, treeview); g_object_set (renderer, "pixbuf", pixbuf, NULL); @@ -3341,9 +3321,7 @@ midori_browser_init (MidoriBrowser* browser) GtkRcStyle* rcstyle; GtkAction* action; - #if HAVE_LIBSOUP - browser->session = soup_session_async_new (); - #endif + browser->net = katze_net_new (); browser->settings = midori_web_settings_new (); browser->proxy_array = katze_array_new (KATZE_TYPE_ARRAY); @@ -3829,20 +3807,13 @@ midori_browser_finalize (GObject* object) g_free (browser->statusbar_text); - if (browser->settings) - g_object_unref (browser->settings); - if (browser->bookmarks) - g_object_unref (browser->bookmarks); - if (browser->trash) - g_object_unref (browser->trash); - if (browser->search_engines) - g_object_unref (browser->search_engines); - if (browser->history) - g_object_unref (browser->history); + katze_object_assign (browser->settings, NULL); + katze_object_assign (browser->bookmarks, NULL); + katze_object_assign (browser->trash, NULL); + katze_object_assign (browser->search_engines, NULL); + katze_object_assign (browser->history, NULL); - #if HAVE_LIBSOUP - g_object_unref (browser->session); - #endif + katze_object_assign (browser->net, NULL); G_OBJECT_CLASS (midori_browser_parent_class)->finalize (object); } @@ -4047,6 +4018,8 @@ midori_browser_load_bookmarks (MidoriBrowser* browser) KatzeItem* item; const gchar* title; const gchar* desc; + GtkWidget* image; + GdkPixbuf* icon; GtkToolItem* toolitem; GtkTreeModel* treestore; @@ -4080,8 +4053,15 @@ midori_browser_load_bookmarks (MidoriBrowser* browser) } else if (katze_item_get_uri (item)) { - toolitem = gtk_tool_button_new_from_stock (STOCK_BOOKMARK); - gtk_tool_button_set_label (GTK_TOOL_BUTTON (toolitem), title); + image = gtk_image_new (); + /* FIXME: Implement icon_cb */ + icon = katze_net_load_icon (browser->net, + katze_item_get_uri (item), + NULL /*(KatzeNetIconCb)midori_browser_bookmark_icon_cb*/, + GTK_WIDGET (browser), NULL /*g_object_ref (image)*/); + gtk_image_set_from_pixbuf (GTK_IMAGE (image), icon); + g_object_unref (icon); + toolitem = gtk_tool_button_new (image, title); gtk_tool_item_set_is_important (toolitem, TRUE); g_signal_connect (toolitem, "clicked", G_CALLBACK (midori_browser_menu_bookmarks_item_activate_cb), @@ -4152,6 +4132,7 @@ midori_browser_new_history_item (MidoriBrowser* browser, gboolean found; time_t now; gint64 date; + time_t date_; if (!sokoke_object_get_boolean (browser->settings, "remember-last-visited-pages")) return; @@ -4168,7 +4149,8 @@ midori_browser_new_history_item (MidoriBrowser* browser, { gtk_tree_model_get (treemodel, &iter, 0, &parent, -1); date = katze_item_get_added (KATZE_ITEM (parent)); - if (sokoke_same_day (&now, &date)) + date_ = (time_t)date; + if (sokoke_same_day (&now, &date_)) { found = TRUE; break; diff --git a/midori/midori-searchaction.c b/midori/midori-searchaction.c index 465efa79..296c9ed3 100644 --- a/midori/midori-searchaction.c +++ b/midori/midori-searchaction.c @@ -25,6 +25,8 @@ struct _MidoriSearchAction KatzeItem* current_item; gchar* text; + KatzeNet* net; + GtkWidget* last_proxy; GtkWidget* dialog; @@ -205,6 +207,8 @@ midori_search_action_init (MidoriSearchAction* search_action) search_action->current_item = NULL; search_action->text = NULL; + search_action->net = katze_net_new (); + search_action->last_proxy = NULL; search_action->dialog = NULL; @@ -218,7 +222,9 @@ midori_search_action_finalize (GObject* object) { MidoriSearchAction* search_action = MIDORI_SEARCH_ACTION (object); - g_free (search_action->text); + katze_assign (search_action->text, NULL); + + katze_object_assign (search_action->net, NULL); G_OBJECT_CLASS (midori_search_action_parent_class)->finalize (object); } @@ -419,8 +425,8 @@ midori_search_action_icon_released_cb (GtkWidget* entry, guint n, i; GtkWidget* menuitem; KatzeItem* item; - GdkPixbuf* pixbuf; - GtkWidget* icon; + GdkPixbuf* icon; + GtkWidget* image; search_engines = MIDORI_SEARCH_ACTION (action)->search_engines; menu = gtk_menu_new (); @@ -432,11 +438,15 @@ midori_search_action_icon_released_cb (GtkWidget* entry, item = katze_array_get_nth_item (search_engines, i); menuitem = gtk_image_menu_item_new_with_label ( katze_item_get_name (item)); - pixbuf = sokoke_web_icon (katze_item_get_icon (item), - GTK_ICON_SIZE_MENU, menuitem); - icon = gtk_image_new_from_pixbuf (pixbuf); - gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), icon); - g_object_unref (pixbuf); + image = gtk_image_new (); + /* FIXME: Implement icon_cb */ + icon = katze_net_load_icon (MIDORI_SEARCH_ACTION (action)->net, + katze_item_get_uri (item), + NULL /*(KatzeNetIconCb)midori_browser_bookmark_icon_cb*/, + entry, NULL /*g_object_ref (image)*/); + gtk_image_set_from_pixbuf (GTK_IMAGE (image), icon); + g_object_unref (icon); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); g_object_set_data (G_OBJECT (menuitem), "engine", item); g_signal_connect (menuitem, "activate", @@ -456,8 +466,8 @@ midori_search_action_icon_released_cb (GtkWidget* entry, gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Manage Search Engines")); - icon = gtk_image_new_from_stock (GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU); - gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), icon); + image = gtk_image_new_from_stock (GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); g_signal_connect (menuitem, "activate", G_CALLBACK (midori_search_action_manage_activate_cb), action); @@ -656,7 +666,7 @@ midori_search_action_set_current_item (MidoriSearchAction* search_action, GSList* proxies; GtkWidget* alignment; GtkWidget* entry; - GdkPixbuf* pixbuf; + GdkPixbuf* icon; g_return_if_fail (MIDORI_IS_SEARCH_ACTION (search_action)); g_return_if_fail (!item || KATZE_IS_ITEM (item)); @@ -677,11 +687,14 @@ midori_search_action_set_current_item (MidoriSearchAction* search_action, alignment = gtk_bin_get_child (GTK_BIN (proxies->data)); entry = gtk_bin_get_child (GTK_BIN (alignment)); - pixbuf = sokoke_web_icon (item ? katze_item_get_icon (item) : NULL, - GTK_ICON_SIZE_MENU, entry); + /* FIXME: Implement icon_cb */ + icon = katze_net_load_icon (search_action->net, + katze_item_get_uri (item), + NULL /*(KatzeNetIconCb)midori_browser_bookmark_icon_cb*/, + entry, NULL /*g_object_ref (entry)*/); gtk_icon_entry_set_icon_from_pixbuf (GTK_ICON_ENTRY (entry), - GTK_ICON_ENTRY_PRIMARY, pixbuf); - g_object_unref (pixbuf); + GTK_ICON_ENTRY_PRIMARY, icon); + g_object_unref (icon); if (item) sokoke_entry_set_default_text (GTK_ENTRY (entry), katze_item_get_name (item)); @@ -698,22 +711,21 @@ midori_search_action_dialog_render_icon_cb (GtkTreeViewColumn* column, GtkTreeIter* iter, GtkWidget* treeview) { + KatzeNet* net; KatzeItem* item; - const gchar* icon; - GdkPixbuf* pixbuf; + GdkPixbuf* icon; gtk_tree_model_get (model, iter, 0, &item, -1); - icon = katze_item_get_icon (item); - if (icon) - { - pixbuf = sokoke_web_icon (icon, GTK_ICON_SIZE_DND, treeview); - g_object_set (renderer, "pixbuf", pixbuf, NULL); - if (pixbuf) - g_object_unref (pixbuf); - } - else - g_object_set (renderer, "pixbuf", NULL, NULL); + /* FIXME: Use the net of the MidoriSearchAction */ + net = katze_net_new (); + /* FIXME: Implement icon_cb */ + icon = katze_net_load_icon (net, katze_item_get_uri (item), + NULL /*(KatzeNetIconCb)midori_search_action_dialog_icon_cb*/, + treeview, NULL /*g_object_ref (treeview)*/); + g_object_set (renderer, "pixbuf", icon, NULL); + g_object_unref (icon); + g_object_unref (net); } static void diff --git a/midori/midori-source.c b/midori/midori-source.c index f08975f4..9b8cbd93 100644 --- a/midori/midori-source.c +++ b/midori/midori-source.c @@ -15,20 +15,16 @@ #include "midori-source.h" +#include + #include #include -#if HAVE_LIBSOUP - #include -#endif - struct _MidoriSource { GtkTextView parent_instance; - #if HAVE_LIBSOUP - SoupSession* session; - #endif + KatzeNet* net; }; struct _MidoriSourceClass @@ -59,17 +55,13 @@ midori_source_init (MidoriSource* source) gtk_text_view_set_buffer (GTK_TEXT_VIEW (source), buffer); gtk_text_view_set_editable (GTK_TEXT_VIEW (source), FALSE); - #if HAVE_LIBSOUP - source->session = soup_session_async_new (); - #endif + source->net = katze_net_new (); } static void midori_source_finalize (GObject* object) { - #if HAVE_LIBSOUP - g_object_unref (MIDORI_SOURCE (object)->session); - #endif + katze_object_assign (MIDORI_SOURCE (object)->net, NULL); G_OBJECT_CLASS (midori_source_parent_class)->finalize (object); } @@ -93,97 +85,49 @@ midori_source_new (const gchar* uri) return GTK_WIDGET (source); } -#if HAVE_LIBSOUP static void -midori_source_got_body_cb (SoupMessage* msg, - MidoriSource* source) +midori_source_transfer_cb (KatzeNetRequest* request, + MidoriSource* source) { - const gchar* contents; - const gchar* mime; gchar** mimev; gchar* charset; gchar* contents_utf8; GtkTextBuffer* buffer; - if (msg->response_body->length > 0) + if (request->data) { - contents = msg->response_body->data; - if (contents && !g_utf8_validate (contents, -1, NULL)) + if (!g_utf8_validate (request->data, request->length, NULL)) { charset = NULL; - if (msg->response_headers) + if (request->mime_type) { - mime = soup_message_headers_get (msg->response_headers, - "content-type"); - if (mime) - { - mimev = g_strsplit (mime, " ", 2); - if (mimev[0] && mimev[1] && - g_str_has_prefix (mimev[1], "charset=")) - charset = g_strdup (&mimev[1][8]); - g_strfreev (mimev); - } + mimev = g_strsplit (request->mime_type, " ", 2); + if (mimev[0] && mimev[1] && + g_str_has_prefix (mimev[1], "charset=")) + charset = g_strdup (&mimev[1][8]); + g_strfreev (mimev); } - contents_utf8 = g_convert (contents, -1, "UTF-8", + contents_utf8 = g_convert (request->data, -1, "UTF-8", charset ? charset : "ISO-8859-1", NULL, NULL, NULL); } else - contents_utf8 = (gchar*)contents; + contents_utf8 = (gchar*)request->data; buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source)); if (contents_utf8) gtk_text_buffer_set_text (buffer, contents_utf8, -1); g_object_unref (buffer); - if (contents != contents_utf8) + if (contents_utf8 != request->data) g_free (contents_utf8); } } -#endif void midori_source_set_uri (MidoriSource* source, const gchar* uri) { - gchar* contents; - gchar* contents_utf8; - GtkTextBuffer* buffer; - #if HAVE_LIBSOUP - SoupMessage* msg; - #endif - gchar* filename; - g_return_if_fail (MIDORI_IS_SOURCE (source)); g_return_if_fail (uri != NULL); - contents = NULL; - - #if HAVE_LIBSOUP - if (g_str_has_prefix (uri, "http://") || g_str_has_prefix (uri, "https://")) - { - msg = soup_message_new ("GET", uri); - g_signal_connect (msg, "got-body", - G_CALLBACK (midori_source_got_body_cb), source); - soup_session_queue_message (source->session, msg, NULL, NULL); - return; - } - #endif - if (g_str_has_prefix (uri, "file://")) - { - contents = NULL; - filename = g_filename_from_uri (uri, NULL, NULL); - if (!filename || !g_file_get_contents (filename, &contents, NULL, NULL)) - return; - if (contents && !g_utf8_validate (contents, -1, NULL)) - { - contents_utf8 = g_convert (contents, -1, "UTF-8", "ISO-8859-1", - NULL, NULL, NULL); - g_free (contents); - } - else - contents_utf8 = contents; - buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source)); - if (contents_utf8) - gtk_text_buffer_set_text (buffer, contents_utf8, -1); - g_object_unref (buffer); - g_free (contents_utf8); - } + katze_net_load_uri (source->net, uri, + NULL, (KatzeNetTransferCb)midori_source_transfer_cb, source); } diff --git a/midori/midori-view.c b/midori/midori-view.c index f4b06382..8ef42b88 100644 --- a/midori/midori-view.c +++ b/midori/midori-view.c @@ -27,10 +27,6 @@ #include #include -#if HAVE_LIBSOUP - #include -#endif - /* This is unstable API, so we need to declare it */ gchar* webkit_web_view_get_selected_text (WebKitWebView* web_view); @@ -66,9 +62,7 @@ struct _MidoriView GtkWidget* tab_close; KatzeItem* item; - #if HAVE_LIBSOUP - SoupSession* session; - #endif + KatzeNet* net; }; struct _MidoriViewClass @@ -439,142 +433,23 @@ midori_view_notify_icon_cb (MidoriView* view, gtk_image_new_from_pixbuf (view->icon)); } -#if HAVE_LIBSOUP static void -midori_view_got_headers_cb (SoupMessage* msg, - MidoriView* view) +midori_view_icon_cb (GdkPixbuf* icon, + MidoriView* view) { - const gchar* mime; - - switch (msg->status_code) - { - case 200: - mime = soup_message_headers_get (msg->response_headers, "content-type"); - if (!g_str_has_prefix (mime, "image/")) - soup_session_cancel_message (view->session, msg, 200); - break; - case 301: - break; - default: - soup_session_cancel_message (view->session, msg, 200); - } -} - -static gchar* -midori_view_get_cached_icon_file (gchar* uri) -{ - gchar* cache_dir; - gchar* checksum; - gchar* icon_file; - gchar* icon_path; - - cache_dir = g_build_filename (g_get_user_cache_dir (), - PACKAGE_NAME, "icons", NULL); - g_mkdir_with_parents (cache_dir, 0755); - #if GLIB_CHECK_VERSION(2, 16, 0) - checksum = g_compute_checksum_for_string (G_CHECKSUM_MD5, uri, -1); - #else - checksum = g_strdup_printf ("%u", g_str_hash (uri)); - #endif - icon_file = g_strdup_printf ("%s.ico", checksum); - g_free (checksum); - icon_path = g_build_filename (cache_dir, icon_file, NULL); - g_free (icon_file); - return icon_path; -} - -static void -midori_view_got_body_cb (SoupMessage* msg, - MidoriView* view) -{ - GdkPixbuf* pixbuf; - SoupURI* soup_uri; - gchar* uri; - gchar* icon_file; - FILE* fp; - GdkPixbuf* pixbuf_scaled; - gint icon_width, icon_height; - - pixbuf = NULL; - if (msg->response_body->length > 0) - { - soup_uri = soup_message_get_uri (msg); - uri = soup_uri_to_string (soup_uri, FALSE); - icon_file = midori_view_get_cached_icon_file (uri); - g_free (uri); - if ((fp = fopen (icon_file, "w"))) - { - fwrite (msg->response_body->data, - 1, msg->response_body->length, fp); - fclose (fp); - pixbuf = gdk_pixbuf_new_from_file (icon_file, NULL); - } - g_free (icon_file); - } - if (!pixbuf) - pixbuf = gtk_widget_render_icon (GTK_WIDGET (view), - GTK_STOCK_FILE, GTK_ICON_SIZE_MENU, NULL); - gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &icon_width, &icon_height); - pixbuf_scaled = gdk_pixbuf_scale_simple (pixbuf, icon_width, icon_height, - GDK_INTERP_BILINEAR); - g_object_unref (pixbuf); - - katze_object_assign (view->icon, pixbuf_scaled); + katze_object_assign (view->icon, icon); g_object_notify (G_OBJECT (view), "icon"); } -#endif static void _midori_web_view_load_icon (MidoriView* view) { - #if HAVE_LIBSOUP - guint i; - gchar* uri; - gchar* icon_file; - SoupMessage* msg; - #endif GdkPixbuf* pixbuf; - gint icon_width, icon_height; - GdkPixbuf* pixbuf_scaled; - pixbuf = NULL; - #if HAVE_LIBSOUP - if (view->uri && g_str_has_prefix (view->uri, "http://")) - { - i = 8; - while (view->uri[i] != '\0' && view->uri[i] != '/') - i++; - if (view->uri[i] == '/') - { - uri = g_strdup (view->uri); - uri[i] = '\0'; - uri = g_strdup_printf ("%s/favicon.ico", uri); - icon_file = midori_view_get_cached_icon_file (uri); - if (g_file_test (icon_file, G_FILE_TEST_EXISTS)) - pixbuf = gdk_pixbuf_new_from_file (icon_file, NULL); - else - { - msg = soup_message_new ("GET", uri); - g_signal_connect (msg, "got-headers", - G_CALLBACK (midori_view_got_headers_cb), view); - g_signal_connect (msg, "got-body", - G_CALLBACK (midori_view_got_body_cb), view); - soup_session_queue_message (view->session, msg, NULL, NULL); - } - g_free (uri); - } - } - #endif + pixbuf = katze_net_load_icon (view->net, view->uri, + (KatzeNetIconCb)midori_view_icon_cb, GTK_WIDGET (view), view); - if (!pixbuf) - pixbuf = gtk_widget_render_icon (GTK_WIDGET (view), - GTK_STOCK_FILE, GTK_ICON_SIZE_MENU, NULL); - gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &icon_width, &icon_height); - pixbuf_scaled = gdk_pixbuf_scale_simple (pixbuf, icon_width, icon_height, - GDK_INTERP_BILINEAR); - g_object_unref (pixbuf); - - view->icon = pixbuf_scaled; + katze_object_assign (view->icon, pixbuf); g_object_notify (G_OBJECT (view), "icon"); } @@ -586,7 +461,7 @@ midori_view_notify_load_status_cb (MidoriView* view, katze_throbber_set_animated (KATZE_THROBBER (view->tab_icon), view->load_status != MIDORI_LOAD_FINISHED); - if (view->load_status == MIDORI_LOAD_COMMITTED) + if (view->web_view && view->load_status == MIDORI_LOAD_COMMITTED) _midori_web_view_load_icon (view); } @@ -1078,9 +953,7 @@ midori_view_init (MidoriView* view) view->download_manager = NULL; - #if HAVE_LIBSOUP - view->session = soup_session_async_new (); - #endif + view->net = katze_net_new (); g_object_connect (view, "signal::notify::icon", @@ -1120,9 +993,7 @@ midori_view_finalize (GObject* object) g_free (view->download_manager); - #if HAVE_LIBSOUP - g_object_unref (view->session); - #endif + g_object_unref (view->net); /* web_frame = webkit_web_view_get_main_frame (WEBKIT_WEB_VIEW (view->web_view)); @@ -1864,7 +1735,7 @@ midori_view_get_zoom_level (MidoriView* view) if (view->web_view != NULL) return webkit_web_view_get_zoom_level (WEBKIT_WEB_VIEW (view->web_view)); #endif - return FALSE; + return 1.0; } /**