url_bar.c

Go to the documentation of this file.

/*
 * Copyright 2004, 2005 Richard Wilson <info@tinct.net>
 * Copyright 2011-2014 Stephen Fryatt <stevef@netsurf-browser.org>
 *
 * This file is part of NetSurf, http://www.netsurf-browser.org/
 *
 * NetSurf 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; version 2 of the License.
 *
 * NetSurf 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, see <http://www.gnu.org/licenses/>.
 */
 
/**
 * \file
 * RISC OS URL bar implementation.
 *
 * The treeview resources are retrieved from resource url necessitating
 * the use of the hlcache content interface.
 */
 
#include <stddef.h>
#include "oslib/wimp.h"
 
#include "utils/log.h"
#include "utils/messages.h"
#include "netsurf/browser_window.h"
#include "netsurf/plotters.h"
#include "netsurf/content.h"
#include "content/hlcache.h"
 
#include "riscos/gui.h"
#include "riscos/hotlist.h"
#include "riscos/url_suggest.h"
#include "riscos/wimp.h"
#include "riscos/wimp_event.h"
#include "riscos/wimputils.h"
#include "riscos/window.h"
#include "riscos/ucstables.h"
#include "riscos/filetype.h"
#include "riscos/gui/url_bar.h"
 
#define URLBAR_HEIGHT 52
#define URLBAR_FAVICON_SIZE 16
#define URLBAR_HOTLIST_SIZE 17
#define URLBAR_PGINFO_WIDTH ((26) * 2)
#define URLBAR_FAVICON_WIDTH ((5 + URLBAR_FAVICON_SIZE + 5) * 2)
#define URLBAR_HOTLIST_WIDTH ((5 + URLBAR_HOTLIST_SIZE + 5) * 2)
#define URLBAR_MIN_WIDTH 52
#define URLBAR_GRIGHT_GUTTER 8
 
#define URLBAR_PGINFO_NAME_LENGTH 12
#define URLBAR_FAVICON_NAME_LENGTH 12
 
struct url_bar {
        /** The applied theme (or NULL to use the default) */
        struct theme_descriptor *theme;
 
        /** The widget dimensions. */
        int                     x_min, y_min;
 
        /** The window and icon details. */
        wimp_w                  window;
        os_box                  extent;
        osspriteop_area         *sprites;
 
        wimp_i                  container_icon;
 
        bool                    hidden;
        bool                    display;
        bool                    shaded;
 
        struct {
                char            sprite[URLBAR_PGINFO_NAME_LENGTH];
                os_box          extent;
        } pginfo;
 
        struct {
                char            sprite[URLBAR_FAVICON_NAME_LENGTH];
                int             type;
                struct hlcache_handle *content;
                os_box          extent;
                os_coord        offset;
                int             width;
                int             height;
        } favicon;
 
        struct {
                wimp_i          icon;
                char            *buffer;
                size_t          size;
                char            *buffer_utf8;
        } text;
 
        struct {
                wimp_i          icon;
                int             x;
                int             y;
        } suggest;
 
        struct {
                bool                    set;
                os_box                  extent;
                os_coord                offset;
        } hotlist;
};
 
static char text_validation[] = "Pptr_write;KN";
static char suggest_icon[] = "gright";
static char suggest_validation[] = "R5;Sgright,pgright";
static char null_text_string[] = "";
 
/** Treeview content resource data */
struct url_bar_resource {
        const char *url;
        struct hlcache_handle *c;
        int height;
        bool ready;
};
 
enum url_bar_resource_id {
        URLBAR_RES_HOTLIST_ADD = 0,
        URLBAR_RES_HOTLIST_REMOVE,
        URLBAR_RES_LAST
};
 
/** Treeview content resources */
static struct url_bar_resource url_bar_res[URLBAR_RES_LAST] = {
        { "resource:icons/hotlist-add.png", NULL, 0, false },
        { "resource:icons/hotlist-rmv.png", NULL, 0, false }
};
 
 
/**
 * Position the icons in the URL bar to take account of the currently
 * configured extent.
 *
 * \param *url_bar The URL bar to update.
 * \param full true to resize everything;
 *             false to move only the right-hand end of the bar.
 * \return true if successful; else false.
 */
static bool ro_gui_url_bar_icon_resize(struct url_bar *url_bar, bool full)
{
        int x0, y0, x1, y1;
        int centre;
        os_error *error;
        os_coord eig = {1, 1};
        wimp_caret caret;
 
        if ((url_bar == NULL) ||
            (url_bar->window == NULL)) {
                return false;
        }
 
        /* calculate 1px in OS units */
        ro_convert_pixels_to_os_units(&eig, (os_mode) -1);
 
        /* The vertical centre line of the widget's extent. */
        centre = url_bar->extent.y0 +
                (url_bar->extent.y1 - url_bar->extent.y0) / 2;
 
        /* Position the container icon. */
        if (url_bar->container_icon != -1) {
                x0 = url_bar->extent.x0;
                x1 = url_bar->extent.x1 -
                        url_bar->suggest.x - URLBAR_GRIGHT_GUTTER;
 
                y0 = centre - (URLBAR_HEIGHT / 2);
                y1 = y0 + URLBAR_HEIGHT;
 
                error = xwimp_resize_icon(url_bar->window,
                                          url_bar->container_icon,
                                          x0, y0, x1, y1);
                if (error != NULL) {
                        NSLOG(netsurf, INFO,
                              "xwimp_resize_icon: 0x%x: %s",
                              error->errnum, error->errmess);
                        ro_warn_user("WimpError", error->errmess);
                        url_bar->container_icon = -1;
                        return false;
                }
        }
 
        /* Position the URL Suggest icon. */
        if (url_bar->suggest.icon != -1) {
                x0 = url_bar->extent.x1 - url_bar->suggest.x;
                x1 = url_bar->extent.x1;
 
                y0 = centre - (url_bar->suggest.y / 2);
                y1 = y0 + url_bar->suggest.y;
 
                error = xwimp_resize_icon(url_bar->window,
                                          url_bar->suggest.icon,
                                          x0, y0, x1, y1);
                if (error != NULL) {
                        NSLOG(netsurf, INFO,
                              "xwimp_resize_icon: 0x%x: %s",
                              error->errnum, error->errmess);
                        ro_warn_user("WimpError", error->errmess);
                        url_bar->suggest.icon = -1;
                        return false;
                }
        }
 
        /* Position the Text icon. */
        if (url_bar->text.icon != -1) {
                x0 = url_bar->extent.x0 + URLBAR_PGINFO_WIDTH + URLBAR_FAVICON_WIDTH;
                x1 = url_bar->extent.x1 - eig.x - URLBAR_HOTLIST_WIDTH -
                        url_bar->suggest.x - URLBAR_GRIGHT_GUTTER;
 
                y0 = centre - (URLBAR_HEIGHT / 2) + eig.y;
                y1 = y0 + URLBAR_HEIGHT - 2 * eig.y;
 
                error = xwimp_resize_icon(url_bar->window,
                                          url_bar->text.icon,
                                          x0, y0, x1, y1);
                if (error != NULL) {
                        NSLOG(netsurf, INFO,
                              "xwimp_resize_icon: 0x%x: %s",
                              error->errnum, error->errmess);
                        ro_warn_user("WimpError", error->errmess);
                        url_bar->text.icon = -1;
                        return false;
                }
 
                if (xwimp_get_caret_position(&caret) == NULL) {
                        if ((caret.w == url_bar->window) &&
                            (caret.i == url_bar->text.icon)) {
                                xwimp_set_caret_position(url_bar->window,
                                                         url_bar->text.icon,
                                                         caret.pos.x,
                                                         caret.pos.y,
                                                         -1,
                                                         caret.index);
                        }
                }
        }
 
        /* Position the page info icon. */
        url_bar->pginfo.extent.x0 = url_bar->extent.x0 + eig.x;
        url_bar->pginfo.extent.x1 = url_bar->extent.x0 + URLBAR_PGINFO_WIDTH;
        url_bar->pginfo.extent.y0 = centre - (URLBAR_HEIGHT / 2) + eig.y;
        url_bar->pginfo.extent.y1 = url_bar->pginfo.extent.y0 + URLBAR_HEIGHT
                - 2 * eig.y;
 
        /* Position the Favicon icon. */
        url_bar->favicon.extent.x0 = url_bar->extent.x0 + URLBAR_PGINFO_WIDTH ;
        url_bar->favicon.extent.x1 = url_bar->extent.x0 + URLBAR_PGINFO_WIDTH + URLBAR_FAVICON_WIDTH;
        url_bar->favicon.extent.y0 = centre - (URLBAR_HEIGHT / 2) + eig.y;
        url_bar->favicon.extent.y1 = url_bar->favicon.extent.y0 + URLBAR_HEIGHT
                - 2 * eig.y;
 
        /* Position the Hotlist icon. */
        url_bar->hotlist.extent.x0 = url_bar->extent.x1 - eig.x -
                URLBAR_HOTLIST_WIDTH - url_bar->suggest.x -
                URLBAR_GRIGHT_GUTTER;
        url_bar->hotlist.extent.x1 = url_bar->hotlist.extent.x0 +
                URLBAR_HOTLIST_WIDTH;
        url_bar->hotlist.extent.y0 = centre - (URLBAR_HEIGHT / 2) + eig.y;
        url_bar->hotlist.extent.y1 = url_bar->hotlist.extent.y0 + URLBAR_HEIGHT
                - 2 * eig.y;
 
        url_bar->hotlist.offset.x = ((url_bar->hotlist.extent.x1 -
                                      url_bar->hotlist.extent.x0) -
                                     (URLBAR_HOTLIST_SIZE * 2)) / 2;
        url_bar->hotlist.offset.y = ((url_bar->hotlist.extent.y1 -
                                      url_bar->hotlist.extent.y0) -
                                     (URLBAR_HOTLIST_SIZE * 2)) / 2 - 1;
 
        return true;
}
 
 
/**
 * Create or delete a URL bar's icons if required to bring it into sync with
 * the current hidden setting.
 *
 * \param *url_bar The URL bar to update.
 * \return true if successful; else false.
 */
static bool ro_gui_url_bar_icon_update(struct url_bar *url_bar)
{
        wimp_icon_create icon;
        os_error *error;
        bool resize;
 
        if ((url_bar == NULL) ||
            (url_bar->window == NULL)) {
                return false;
        }
 
        icon.w = url_bar->window;
        icon.icon.extent.x0 = 0;
        icon.icon.extent.y0 = 0;
        icon.icon.extent.x1 = 0;
        icon.icon.extent.y1 = 0;
 
        resize = false;
 
        /* Create or delete the container icon. */
 
        if (!url_bar->hidden && url_bar->container_icon == -1) {
                icon.icon.flags = wimp_ICON_BORDER |
                        (wimp_COLOUR_BLACK << wimp_ICON_FG_COLOUR_SHIFT) |
                        (wimp_BUTTON_DOUBLE_CLICK_DRAG << wimp_ICON_BUTTON_TYPE_SHIFT);
                error = xwimp_create_icon(&icon, &url_bar->container_icon);
                if (error != NULL) {
                        NSLOG(netsurf, INFO,
                              "xwimp_create_icon: 0x%x: %s",
                              error->errnum, error->errmess);
                        ro_warn_user("WimpError", error->errmess);
                        url_bar->container_icon = -1;
                        return false;
                }
 
                resize = true;
        } else if ((url_bar->hidden) &&
                   (url_bar->container_icon != -1)) {
                error = xwimp_delete_icon(url_bar->window,
                                          url_bar->container_icon);
                if (error != NULL) {
                        NSLOG(netsurf, INFO,
                              "xwimp_delete_icon: 0x%x: %s",
                              error->errnum, error->errmess);
                        ro_warn_user("WimpError", error->errmess);
                        return false;
                }
 
                url_bar->container_icon = -1;
        }
 
        /* Create or delete the text icon. */
        if (!url_bar->hidden &&
            url_bar->text.icon == -1) {
                icon.icon.data.indirected_text.text = url_bar->text.buffer;
                icon.icon.data.indirected_text.validation = text_validation;
                icon.icon.data.indirected_text.size = url_bar->text.size;
                icon.icon.flags = wimp_ICON_TEXT |
                        wimp_ICON_INDIRECTED |
                        wimp_ICON_VCENTRED |
                        wimp_ICON_FILLED |
                        (wimp_COLOUR_BLACK << wimp_ICON_FG_COLOUR_SHIFT);
 
                if (url_bar->display) {
                        icon.icon.flags |= (wimp_BUTTON_NEVER <<
                                            wimp_ICON_BUTTON_TYPE_SHIFT);
                } else if (!ns_wimp_has_text_selection()) {
                        icon.icon.flags |= (wimp_BUTTON_WRITE_CLICK_DRAG <<
                                            wimp_ICON_BUTTON_TYPE_SHIFT);
                } else {
                        icon.icon.flags |= (wimp_BUTTON_WRITABLE <<
                                            wimp_ICON_BUTTON_TYPE_SHIFT);
                }
                error = xwimp_create_icon(&icon, &url_bar->text.icon);
                if (error) {
                        NSLOG(netsurf, INFO,
                              "xwimp_create_icon: 0x%x: %s",
                              error->errnum, error->errmess);
                        ro_warn_user("WimpError", error->errmess);
                        url_bar->text.icon = -1;
                        return false;
                }
 
                resize = true;
 
        } else if (url_bar->hidden &&
                   url_bar->text.icon != -1) {
                error = xwimp_delete_icon(url_bar->window,
                                          url_bar->text.icon);
                if (error != NULL) {
                        NSLOG(netsurf, INFO,
                              "xwimp_delete_icon: 0x%x: %s",
                              error->errnum, error->errmess);
                        ro_warn_user("WimpError", error->errmess);
                        return false;
                }
 
                url_bar->text.icon = -1;
        }
 
        /* Create or delete the suggest icon. */
        if (!url_bar->hidden &&
            url_bar->suggest.icon == -1) {
                icon.icon.data.indirected_text.text = null_text_string;
                icon.icon.data.indirected_text.size = 1;
                icon.icon.data.indirected_text.validation = suggest_validation;
                icon.icon.flags = wimp_ICON_TEXT |
                        wimp_ICON_SPRITE |
                        wimp_ICON_INDIRECTED |
                        wimp_ICON_HCENTRED |
                        wimp_ICON_VCENTRED |
                        (wimp_BUTTON_CLICK << wimp_ICON_BUTTON_TYPE_SHIFT);
 
                error = xwimp_create_icon(&icon, &url_bar->suggest.icon);
                if (error) {
                        NSLOG(netsurf, INFO, "xwimp_create_icon: 0x%x: %s",
                              error->errnum, error->errmess);
                        ro_warn_user("WimpError", error->errmess);
                        return false;
                }
 
                if (!url_bar->display)
                        ro_gui_wimp_event_register_menu_gright(url_bar->window,
                                                               wimp_ICON_WINDOW,
                                                               url_bar->suggest.icon,
                                                               ro_gui_url_suggest_menu);
 
                if (!ro_gui_url_bar_update_urlsuggest(url_bar)) {
                        return false;
                }
 
                resize = true;
 
        } else if (url_bar->hidden &&
                   url_bar->suggest.icon != -1) {
                ro_gui_wimp_event_deregister(url_bar->window,
                                             url_bar->suggest.icon);
                error = xwimp_delete_icon(url_bar->window,
                                          url_bar->suggest.icon);
                if (error != NULL) {
                        NSLOG(netsurf, INFO,
                              "xwimp_delete_icon: 0x%x: %s",
                              error->errnum, error->errmess);
                        ro_warn_user("WimpError", error->errmess);
                        return false;
                }
 
                url_bar->suggest.icon = -1;
        }
 
        /* If any icons were created, resize the bar. */
        if (resize && !ro_gui_url_bar_icon_resize(url_bar, true)) {
                return false;
        }
 
        /* If there are any icons, apply shading as necessary. */
        if (url_bar->container_icon != -1) {
                ro_gui_set_icon_shaded_state(url_bar->window,
                                             url_bar->container_icon,
                                             url_bar->shaded);
        }
 
        if (url_bar->text.icon != -1) {
                ro_gui_set_icon_shaded_state(url_bar->window,
                                             url_bar->text.icon,
                                             url_bar->shaded);
        }
 
        if (url_bar->suggest.icon != -1) {
                ro_gui_set_icon_shaded_state(url_bar->window,
                                             url_bar->suggest.icon,
                                             url_bar->shaded);
        }
 
        return true;
}
 
 
/**
 * Set the state of a URL Bar's hotlist icon.
 *
 * \param *url_bar The URL Bar to update.
 * \param set TRUE to set the hotlist icon; FALSE to clear it.
 */
static void ro_gui_url_bar_set_hotlist(struct url_bar *url_bar, bool set)
{
        if (url_bar == NULL ||
            set == url_bar->hotlist.set) {
                return;
        }
 
        url_bar->hotlist.set = set;
 
        if (!url_bar->hidden) {
                xwimp_force_redraw(url_bar->window,
                                   url_bar->hotlist.extent.x0,
                                   url_bar->hotlist.extent.y0,
                                   url_bar->hotlist.extent.x1,
                                   url_bar->hotlist.extent.y1);
        }
}
 
 
/**
 * Callback for hlcache.
 */
static nserror
ro_gui_url_bar_res_cb(hlcache_handle *handle,
                      const hlcache_event *event, void *pw)
{
        struct url_bar_resource *r = pw;
 
        switch (event->type) {
        case CONTENT_MSG_READY:
        case CONTENT_MSG_DONE:
                r->ready = true;
                r->height = content_get_height(handle);
                break;
 
        default:
                break;
        }
 
        return NSERROR_OK;
}
 
 
/* This is an exported interface documented in url_bar.h */
struct url_bar *ro_gui_url_bar_create(struct theme_descriptor *theme)
{
        struct url_bar *url_bar;
 
        /* Allocate memory. */
 
        url_bar = malloc(sizeof(struct url_bar));
        if (url_bar == NULL) {
                NSLOG(netsurf, INFO, "No memory for malloc()");
                return NULL;
        }
 
        /* Set up default parameters. */
 
        url_bar->theme = theme;
        url_bar->sprites = ro_gui_theme_get_sprites(theme);
 
        url_bar->display = false;
        url_bar->shaded = false;
 
        url_bar->x_min = URLBAR_FAVICON_WIDTH + URLBAR_MIN_WIDTH +
                URLBAR_HOTLIST_WIDTH;
        url_bar->y_min = URLBAR_HEIGHT;
 
        url_bar->extent.x0 = 0;
        url_bar->extent.y0 = 0;
        url_bar->extent.x1 = 0;
        url_bar->extent.y1 = 0;
 
        url_bar->window = NULL;
        url_bar->container_icon = -1;
        url_bar->text.icon = -1;
        url_bar->suggest.icon = -1;
 
        url_bar->pginfo.extent.x0 = 0;
        url_bar->pginfo.extent.y0 = 0;
        url_bar->pginfo.extent.x1 = 0;
        url_bar->pginfo.extent.y1 = 0;
        strncpy(url_bar->pginfo.sprite,
                "pgiinternal",
                URLBAR_PGINFO_NAME_LENGTH);
 
        url_bar->favicon.extent.x0 = 0;
        url_bar->favicon.extent.y0 = 0;
        url_bar->favicon.extent.x1 = 0;
        url_bar->favicon.extent.y1 = 0;
        url_bar->favicon.width = 0;
        url_bar->favicon.height = 0;
        url_bar->favicon.content = NULL;
        url_bar->favicon.type = 0;
        strncpy(url_bar->favicon.sprite,
                "Ssmall_xxx",
                URLBAR_FAVICON_NAME_LENGTH);
 
        url_bar->hotlist.set = false;
        url_bar->hotlist.extent.x0 = 0;
        url_bar->hotlist.extent.y0 = 0;
        url_bar->hotlist.extent.x1 = 0;
        url_bar->hotlist.extent.y1 = 0;
 
        url_bar->text.size = RO_GUI_MAX_URL_SIZE;
        url_bar->text.buffer = malloc(url_bar->text.size);
        if (url_bar->text.buffer == NULL) {
                free(url_bar);
                return NULL;
        }
        url_bar->text.buffer[0] = 0;
        url_bar->text.buffer_utf8 = NULL;
 
        url_bar->hidden = false;
 
        return url_bar;
}
 
 
/* This is an exported interface documented in url_bar.h */
bool
ro_gui_url_bar_rebuild(struct url_bar *url_bar,
                       struct theme_descriptor *theme,
                       theme_style style,
                       wimp_w window,
                       bool display,
                       bool shaded)
{
        if (url_bar == NULL) {
                return false;
        }
 
        url_bar->theme = theme;
        url_bar->window = window;
 
        url_bar->display = display;
        url_bar->shaded = shaded;
 
        url_bar->container_icon = -1;
        url_bar->text.icon = -1;
        url_bar->suggest.icon = -1;
 
        ro_gui_wimp_get_sprite_dimensions((osspriteop_area *) -1,
                                          suggest_icon,
                                          &url_bar->suggest.x,
                                          &url_bar->suggest.y);
 
        url_bar->x_min = URLBAR_PGINFO_WIDTH +
                URLBAR_FAVICON_WIDTH +
                URLBAR_MIN_WIDTH +
                URLBAR_HOTLIST_WIDTH +
                URLBAR_GRIGHT_GUTTER +
                url_bar->suggest.x;
 
        url_bar->y_min = (url_bar->suggest.y > URLBAR_HEIGHT) ?
                url_bar->suggest.y : URLBAR_HEIGHT;
 
        return ro_gui_url_bar_icon_update(url_bar);
}
 
 
/* This is an exported interface documented in url_bar.h */
void ro_gui_url_bar_destroy(struct url_bar *url_bar)
{
        if (url_bar == NULL) {
                return;
        }
 
        if (url_bar->text.buffer_utf8 != NULL) {
                free(url_bar->text.buffer_utf8);
        }
 
        if (url_bar->text.buffer != NULL) {
                free(url_bar->text.buffer);
        }
 
        free(url_bar);
}
 
 
/* This is an exported interface documented in url_bar.h */
bool ro_gui_url_bar_get_dims(struct url_bar *url_bar, int *width, int *height)
{
        if (url_bar == NULL) {
                return false;
        }
 
        if (url_bar->x_min != -1 &&
            url_bar->y_min != -1) {
                if (width != NULL) {
                        *width = url_bar->x_min;
                }
                if (height != NULL) {
                        *height = url_bar->y_min;
                }
 
                return true;
        }
 
        return false;
}
 
 
/* This is an exported interface documented in url_bar.h */
bool
ro_gui_url_bar_set_extent(struct url_bar *url_bar,
                          int x0, int y0, int x1, int y1)
{
        bool stretch;
 
        if (url_bar == NULL) {
                return false;
        }
 
        if ((x1 - x0) < url_bar->x_min ||
            (y1 - y0) < url_bar->y_min) {
                return false;
        }
 
        if (url_bar->extent.x0 == x0 &&
            url_bar->extent.y0 == y0 &&
            url_bar->extent.x1 == x1 &&
            url_bar->extent.y1 == y1) {
                return true;
        }
 
        /* If it's only the length that changes, less needs to be updated. */
        stretch = (url_bar->extent.x0 == x0 &&
                   url_bar->extent.y0 == y0 &&
                   url_bar->extent.y1 == y1) ? true : false;
 
        /* Redraw the relevant bits of the toolbar. */
        if (url_bar->window != NULL &&
            !url_bar->hidden) {
                if (stretch) {
                        xwimp_force_redraw(url_bar->window,
                                           x0 + URLBAR_PGINFO_WIDTH + URLBAR_FAVICON_WIDTH, y0,
                                           (x1 > url_bar->extent.x1) ?
                                           x1 : url_bar->extent.x1, y1);
                } else {
                        xwimp_force_redraw(url_bar->window,
                                           url_bar->extent.x0,
                                           url_bar->extent.y0,
                                           url_bar->extent.x1,
                                           url_bar->extent.y1);
                        xwimp_force_redraw(url_bar->window, x0, y0, x1, y1);
                }
        }
 
        /* Reposition the URL bar icons. */
        url_bar->extent.x0 = x0;
        url_bar->extent.y0 = y0;
        url_bar->extent.x1 = x1;
        url_bar->extent.y1 = y1;
 
        return ro_gui_url_bar_icon_resize(url_bar, !stretch);
}
 
 
/* This is an exported interface documented in url_bar.h */
bool ro_gui_url_bar_hide(struct url_bar *url_bar, bool hide)
{
        if (url_bar == NULL || url_bar->hidden == hide)
                return (url_bar == NULL) ? false : true;
 
        url_bar->hidden = hide;
 
        return ro_gui_url_bar_icon_update(url_bar);
}
 
 
/* This is an exported interface documented in url_bar.h */
void ro_gui_url_bar_redraw(struct url_bar *url_bar, wimp_draw *redraw)
{
        wimp_icon icon;
        struct rect clip;
        bool draw_pginfo = true;
        bool draw_favicon = true;
        bool draw_hotlist = true;
 
        /* Test for a valid URL bar */
        if (url_bar == NULL || url_bar->hidden)
                return;
 
        if ((redraw->clip.x0 - (redraw->box.x0 - redraw->xscroll)) >
            (url_bar->pginfo.extent.x1) ||
            (redraw->clip.y0 - (redraw->box.y1 - redraw->yscroll)) >
            (url_bar->pginfo.extent.y1) ||
            (redraw->clip.x1 - (redraw->box.x0 - redraw->xscroll)) <
            (url_bar->pginfo.extent.x0) ||
            (redraw->clip.y1 - (redraw->box.y1 - redraw->yscroll)) <
            (url_bar->pginfo.extent.y0)) {
                /* page info not in redraw area */
                draw_pginfo = false;
        }
 
        if ((redraw->clip.x0 - (redraw->box.x0 - redraw->xscroll)) >
            (url_bar->favicon.extent.x1) ||
            (redraw->clip.y0 - (redraw->box.y1 - redraw->yscroll)) >
            (url_bar->favicon.extent.y1) ||
            (redraw->clip.x1 - (redraw->box.x0 - redraw->xscroll)) <
            (url_bar->favicon.extent.x0) ||
            (redraw->clip.y1 - (redraw->box.y1 - redraw->yscroll)) <
            (url_bar->favicon.extent.y0)) {
                /* Favicon not in redraw area */
                draw_favicon = false;
        }
 
        if ((redraw->clip.x0 - (redraw->box.x0 - redraw->xscroll)) >
            (url_bar->hotlist.extent.x1) ||
            (redraw->clip.y0 - (redraw->box.y1 - redraw->yscroll)) >
            (url_bar->hotlist.extent.y1) ||
            (redraw->clip.x1 - (redraw->box.x0 - redraw->xscroll)) <
            (url_bar->hotlist.extent.x0) ||
            (redraw->clip.y1 - (redraw->box.y1 - redraw->yscroll)) <
            (url_bar->hotlist.extent.y0)) {
                /* Hotlist icon not in redraw area */
                draw_hotlist = false;
        }
 
        if (draw_pginfo) {
                icon.flags = wimp_ICON_SPRITE |
                        wimp_ICON_INDIRECTED |
                        wimp_ICON_FILLED |
                        wimp_ICON_HCENTRED |
                        wimp_ICON_VCENTRED |
                        (wimp_COLOUR_WHITE << wimp_ICON_BG_COLOUR_SHIFT);
                icon.data.indirected_sprite.id = (osspriteop_id)url_bar->pginfo.sprite;
                icon.data.indirected_sprite.area = url_bar->sprites;
                icon.data.indirected_sprite.size = 12;
 
                icon.extent.x0 = url_bar->pginfo.extent.x0;
                icon.extent.x1 = url_bar->pginfo.extent.x1;
                icon.extent.y0 = url_bar->pginfo.extent.y0;
                icon.extent.y1 = url_bar->pginfo.extent.y1;
 
                xwimp_plot_icon(&icon);
        }
 
        if (draw_favicon) {
                if (url_bar->favicon.content == NULL) {
                        icon.data.indirected_text.text = null_text_string;
                        icon.data.indirected_text.validation =
                                url_bar->favicon.sprite;
                        icon.data.indirected_text.size = 1;
                        icon.flags = wimp_ICON_TEXT | wimp_ICON_SPRITE |
                                wimp_ICON_INDIRECTED |
                                wimp_ICON_FILLED |
                                wimp_ICON_HCENTRED |
                                wimp_ICON_VCENTRED;
                        icon.extent.x0 = url_bar->favicon.extent.x0;
                        icon.extent.x1 = url_bar->favicon.extent.x1;
                        icon.extent.y0 = url_bar->favicon.extent.y0;
                        icon.extent.y1 = url_bar->favicon.extent.y1;
 
                        xwimp_plot_icon(&icon);
                } else {
                        struct content_redraw_data data;
                        struct redraw_context ctx = {
                                .interactive = true,
                                .background_images = true,
                                .plot = &ro_plotters
                        };
 
                        xwimp_set_colour(wimp_COLOUR_WHITE);
                        xos_plot(os_MOVE_TO,
                                 (redraw->box.x0 - redraw->xscroll) +
                                 url_bar->favicon.extent.x0,
                                 (redraw->box.y1 - redraw->yscroll) +
                                 url_bar->favicon.extent.y0);
                        xos_plot(os_PLOT_TO | os_PLOT_RECTANGLE,
                                 (redraw->box.x0 - redraw->xscroll) +
                                 url_bar->favicon.extent.x1,
                                 (redraw->box.y1 - redraw->yscroll) +
                                 url_bar->favicon.extent.y1);
 
                        clip.x0 = (redraw->clip.x0 - ro_plot_origin_x) / 2;
                        clip.y0 = (ro_plot_origin_y - redraw->clip.y0) / 2;
                        clip.x1 = (redraw->clip.x1 - ro_plot_origin_x) / 2;
                        clip.y1 = (ro_plot_origin_y - redraw->clip.y1) / 2;
 
                        data.x = (url_bar->favicon.extent.x0 +
                                  url_bar->favicon.offset.x) / 2;
                        data.y = (url_bar->favicon.offset.y -
                                  url_bar->favicon.extent.y1) / 2;
                        data.width = url_bar->favicon.width;
                        data.height = url_bar->favicon.height;
                        data.background_colour = 0xFFFFFF;
                        data.scale = 1;
                        data.repeat_x = false;
                        data.repeat_y = false;
 
                        content_redraw(url_bar->favicon.content,
                                       &data, &clip, &ctx);
                }
        }
 
        if (draw_hotlist) {
                struct content_redraw_data data;
                struct redraw_context ctx = {
                        .interactive = true,
                        .background_images = true,
                        .plot = &ro_plotters
                };
                struct url_bar_resource *hotlist_icon = url_bar->hotlist.set ?
                        &(url_bar_res[URLBAR_RES_HOTLIST_REMOVE]) :
                        &(url_bar_res[URLBAR_RES_HOTLIST_ADD]);
 
                xwimp_set_colour(wimp_COLOUR_WHITE);
                xos_plot(os_MOVE_TO,
                         (redraw->box.x0 - redraw->xscroll) +
                         url_bar->hotlist.extent.x0,
                         (redraw->box.y1 - redraw->yscroll) +
                         url_bar->hotlist.extent.y0);
                xos_plot(os_PLOT_TO | os_PLOT_RECTANGLE,
                         (redraw->box.x0 - redraw->xscroll) +
                         url_bar->hotlist.extent.x1,
                         (redraw->box.y1 - redraw->yscroll) +
                         url_bar->hotlist.extent.y1);
 
                if (hotlist_icon->ready == false) {
                        return;
                }
 
                clip.x0 = (redraw->clip.x0 - ro_plot_origin_x) / 2;
                clip.y0 = (ro_plot_origin_y - redraw->clip.y0) / 2;
                clip.x1 = (redraw->clip.x1 - ro_plot_origin_x) / 2;
                clip.y1 = (ro_plot_origin_y - redraw->clip.y1) / 2;
 
                data.x = (url_bar->hotlist.extent.x0 +
                          url_bar->hotlist.offset.x) / 2;
                data.y = (url_bar->hotlist.offset.y -
                          url_bar->hotlist.extent.y1) / 2;
                data.width = URLBAR_HOTLIST_SIZE;
                data.height = URLBAR_HOTLIST_SIZE;
                data.background_colour = 0xFFFFFF;
                data.scale = 1;
                data.repeat_x = false;
                data.repeat_y = false;
 
                content_redraw(hotlist_icon->c, &data, &clip, &ctx);
        }
}
 
/**
 * check if os point is inside an os box
 *
 * \param pos The coordinate of the point
 * \param box The box to check against
 * \return true if point is inside the box else false
 */
static inline bool is_point_in_box(os_coord *pos, os_box *box)
{
        if (pos->x < box->x0 ||
            pos->x > box->x1 ||
            pos->y < box->y0 ||
            pos->y > box->y1) {
                return false;
        }
        return true;
}
 
/* This is an exported interface documented in url_bar.h */
bool
ro_gui_url_bar_click(struct url_bar *url_bar,
                     wimp_pointer *pointer,
                     wimp_window_state *state,
                     url_bar_action *action)
{
        os_coord pos;
 
        if (url_bar == NULL || url_bar->hidden ||
            url_bar->display || url_bar->shaded) {
                return false;
        }
 
        /* Check that the click was within our part of the window. */
        pos.x = pointer->pos.x - state->visible.x0 + state->xscroll;
        pos.y = pointer->pos.y - state->visible.y1 + state->yscroll;
 
        if (!is_point_in_box(&pos, &url_bar->extent)) {
                return false;
        }
 
        /* If we have a Select or Adjust click, check if it originated on the
         * hotlist icon; if it did, return an event.
         */
        if (pointer->buttons == wimp_SINGLE_SELECT ||
            pointer->buttons == wimp_SINGLE_ADJUST) {
                if (is_point_in_box(&pos, &url_bar->hotlist.extent)) {
                        if (pointer->buttons == wimp_SINGLE_SELECT &&
                            action != NULL) {
                                *action = TOOLBAR_URL_SELECT_HOTLIST;
                        } else if (pointer->buttons == wimp_SINGLE_ADJUST &&
                                   action != NULL) {
                                *action = TOOLBAR_URL_ADJUST_HOTLIST;
                        }
                        return true;
                }
 
                if (is_point_in_box(&pos, &url_bar->pginfo.extent)) {
                        if (pointer->buttons == wimp_SINGLE_SELECT &&
                            action != NULL) {
                                *action = TOOLBAR_URL_SELECT_PGINFO;
                        } else if (pointer->buttons == wimp_SINGLE_ADJUST &&
                                   action != NULL) {
                                *action = TOOLBAR_URL_ADJUST_PGINFO;
                        }
                        return true;
                }
 
        }
 
        /* If we find a Select or Adjust drag, check if it originated on the
         * URL bar or over the favicon.  If either, then return an event.
         */
        if (pointer->buttons == wimp_DRAG_SELECT ||
            pointer->buttons == wimp_DRAG_ADJUST) {
                if (!ns_wimp_has_text_selection()) {
                        if (pointer->i == url_bar->text.icon) {
                                if (action != NULL) {
                                        *action = TOOLBAR_URL_DRAG_URL;
                                }
                                return true;
                        }
                }
 
                if (is_point_in_box(&pos, &url_bar->favicon.extent)) {
                        if (action != NULL) {
                                *action = TOOLBAR_URL_DRAG_FAVICON;
                        }
                        return true;
                }
        }
 
        return false;
}
 
 
/* This is an exported interface documented in url_bar.h */
bool
ro_gui_url_bar_menu_prepare(struct url_bar *url_bar,
                            wimp_i i,
                            wimp_menu *menu,
                            wimp_pointer *pointer)
{
        if (url_bar == NULL ||
            url_bar->suggest.icon != i ||
            menu != ro_gui_url_suggest_menu) {
                return false;
        }
 
        if (pointer != NULL) {
                return ro_gui_url_suggest_prepare_menu();
        }
 
        return true;
}
 
 
/* This is an exported interface documented in url_bar.h */
bool
ro_gui_url_bar_menu_select(struct url_bar *url_bar,
                           wimp_i i,
                           wimp_menu *menu,
                           wimp_selection *selection,
                           menu_action action)
{
        const char *urltxt;
        struct gui_window *g;
 
        if (url_bar == NULL ||
            url_bar->suggest.icon != i ||
            menu != ro_gui_url_suggest_menu) {
                return false;
        }
 
        urltxt = ro_gui_url_suggest_get_selection(selection);
        g = ro_gui_toolbar_lookup(url_bar->window);
 
        if (urltxt != NULL &&
            g != NULL &&
            g->bw != NULL) {
                nsurl *url;
                nserror error;
 
                error = nsurl_create(urltxt, &url);
                if (error != NSERROR_OK) {
                        ro_warn_user(messages_get_errorcode(error), 0);
                } else {
                        ro_gui_window_set_url(g, url);
 
                        browser_window_navigate(g->bw,
                                                url,
                                                NULL,
                                                BW_NAVIGATE_HISTORY,
                                                NULL,
                                                NULL,
                                                NULL);
                        nsurl_unref(url);
                }
        }
 
        return true;
}
 
 
/* This is an exported interface documented in url_bar.h */
bool
ro_gui_url_bar_help_suffix(struct url_bar *url_bar,
                           wimp_i i,
                           os_coord *mouse,
                           wimp_window_state *state,
                           wimp_mouse_state buttons,
                           const char **suffix)
{
        os_coord pos;
 
        if (url_bar == NULL || url_bar->hidden) {
                return false;
        }
 
        /* Check that the click was within our part of the window. */
 
        pos.x = mouse->x - state->visible.x0 + state->xscroll;
        pos.y = mouse->y - state->visible.y1 + state->yscroll;
 
        if (pos.x < url_bar->extent.x0 ||
            pos.x > url_bar->extent.x1 ||
            pos.y < url_bar->extent.y0 ||
            pos.y > url_bar->extent.y1) {
                return false;
        }
 
        /* Return hard-coded icon numbers that match the ones that were
         * always allocated to the URL bar in a previous implementation.
         * If Messages can be updated, this could be changed.
         */
 
        if (i == url_bar->text.icon) {
                *suffix = "14";
        } else if (i == url_bar->suggest.icon) {
                *suffix = "15";
        } else if (pos.x >= url_bar->hotlist.extent.x0 &&
                   pos.x <= url_bar->hotlist.extent.x1 &&
                   pos.y >= url_bar->hotlist.extent.y0 &&
                   pos.y <= url_bar->hotlist.extent.y1) {
                *suffix = "Hot";
        } else if (pos.x >= url_bar->favicon.extent.x0 &&
                   pos.x <= url_bar->favicon.extent.x1 &&
                   pos.y >= url_bar->favicon.extent.y0 &&
                   pos.y <= url_bar->favicon.extent.y1) {
                *suffix = "Fav";
        } else {
                *suffix = "";
        }
 
        return true;
}
 
 
/* This is an exported interface documented in url_bar.h */
bool ro_gui_url_bar_take_caret(struct url_bar *url_bar)
{
        os_error *error;
 
        if (url_bar == NULL || url_bar->hidden) {
                return false;
        }
 
        error = xwimp_set_caret_position(url_bar->window,
                                         url_bar->text.icon,
                                         -1, -1, -1, 0);
        if (error) {
                NSLOG(netsurf, INFO,
                      "xwimp_set_caret_position: 0x%x: %s",
                      error->errnum, error->errmess);
                ro_warn_user("WimpError", error->errmess);
 
                return false;
        }
 
        return true;
}
 
 
/* This is an exported interface documented in url_bar.h */
void
ro_gui_url_bar_set_url(struct url_bar *url_bar,
                       const char *url,
                       bool is_utf8,
                       bool set_caret)
{
        wimp_caret caret;
        os_error *error;
        char *local_text = NULL;
        const char *local_url;
        nsurl *n;
 
        if (url_bar == NULL ||
            url_bar->text.buffer == NULL ||
            url == NULL) {
                return;
        }
 
        /* Before we do anything with the URL, get it into local encoding so
         * that behaviour is consistent with the rest of the URL Bar module
         * (which will act on the icon's text buffer, which is always in local
         * encoding).
         */
 
        if (is_utf8) {
                nserror err;
 
                err = utf8_to_local_encoding(url, 0, &local_text);
                if (err != NSERROR_OK) {
                        /* A bad encoding should never happen, so assert this */
                        assert(err != NSERROR_BAD_ENCODING);
                        NSLOG(netsurf, INFO, "utf8_to_enc failed");
                        /* Paranoia */
                        local_text = NULL;
                }
                local_url = (local_text != NULL) ? local_text : url;
        } else {
                local_url = url;
        }
 
        /* Copy the text into the icon buffer. If the text is too long, truncate
         * for URL bar and log the full URL.
         */
        if (strlen(local_url) >= url_bar->text.size) {
                NSLOG(netsurf, WARNING,
                      "URL too long to show in URL bar (%zu chars): %s",
                      strlen(url), url);
        }
 
        strncpy(url_bar->text.buffer, local_url, url_bar->text.size - 1);
        url_bar->text.buffer[url_bar->text.size - 1] = '\0';
 
        if (local_text != NULL) {
                free(local_text);
        }
 
        /* Set the hotlist flag. */
        if (nsurl_create(url, &n) == NSERROR_OK) {
                ro_gui_url_bar_set_hotlist(url_bar, ro_gui_hotlist_has_page(n));
                nsurl_unref(n);
        }
 
        /* If there's no icon, then there's nothing else to do... */
        if (url_bar->text.icon == -1) {
                return;
        }
 
        /* ...if there is, redraw the icon and fix the caret's position. */
        ro_gui_redraw_icon(url_bar->window, url_bar->text.icon);
 
        error = xwimp_get_caret_position(&caret);
        if (error) {
                NSLOG(netsurf, INFO,
                      "xwimp_get_caret_position: 0x%x: %s",
                      error->errnum, error->errmess);
                ro_warn_user("WimpError", error->errmess);
                return;
        }
 
        if (set_caret ||
            (caret.w == url_bar->window &&
             caret.i == url_bar->text.icon)) {
                const char *set_url;
                set_url = ro_gui_get_icon_string(url_bar->window,
                                                 url_bar->text.icon);
 
                error = xwimp_set_caret_position(url_bar->window,
                                                 url_bar->text.icon,
                                                 0, 0, -1,
                                                 strlen(set_url));
                if (error) {
                        NSLOG(netsurf, INFO,
                              "xwimp_set_caret_position: 0x%x: %s",
                              error->errnum,
                              error->errmess);
                        ro_warn_user("WimpError", error->errmess);
                }
        }
}
 
 
/* This is an exported interface documented in url_bar.h */
void ro_gui_url_bar_update_hotlist(struct url_bar *url_bar)
{
        const char *url;
        nsurl *n;
 
        if (url_bar == NULL) {
                return;
        }
 
        url = (const char *) url_bar->text.buffer;
        if (url != NULL &&
            nsurl_create(url, &n) == NSERROR_OK) {
                ro_gui_url_bar_set_hotlist(url_bar, ro_gui_hotlist_has_page(n));
                nsurl_unref(n);
        }
}
 
 
/* This is an exported interface documented in url_bar.h */
const char *ro_gui_url_bar_get_url(struct url_bar *url_bar)
{
        nserror res;
 
        if ((url_bar == NULL) ||
            (url_bar->text.buffer == NULL)) {
                return NULL;
        }
 
        if (url_bar->text.buffer_utf8 != NULL) {
                free(url_bar->text.buffer_utf8);
                url_bar->text.buffer_utf8 = NULL;
        }
 
        if (url_bar->text.buffer[0] == '\0') {
                return (const char *) url_bar->text.buffer;
        }
 
        res = utf8_from_local_encoding(url_bar->text.buffer, 0,
                                       &url_bar->text.buffer_utf8);
        if (res == NSERROR_OK) {
                return (const char *)url_bar->text.buffer_utf8;
        }
 
        return (const char *) url_bar->text.buffer;
}
 
 
/* This is an exported interface documented in url_bar.h */
bool ro_gui_url_bar_get_url_extent(struct url_bar *url_bar, os_box *extent)
{
        wimp_icon_state state;
        os_error *error;
 
        if (url_bar == NULL || url_bar->hidden) {
                return false;
        }
 
        if (extent == NULL) {
                return true;
        }
 
        state.w = url_bar->window;
        state.i = url_bar->container_icon;
        error = xwimp_get_icon_state(&state);
        if (error) {
                NSLOG(netsurf, INFO,
                      "xwimp_get_icon_state: 0x%x: %s",
                      error->errnum, error->errmess);
                ro_warn_user("WimpError", error->errmess);
                return false;
        }
 
        extent->x0 = state.icon.extent.x0;
        extent->y0 = state.icon.extent.y0;
        extent->x1 = state.icon.extent.x1;
        extent->y1 = state.icon.extent.y1;
 
        return true;
}
 
 
/* This is an exported interface documented in url_bar.h */
bool
ro_gui_url_bar_test_for_text_field_click(struct url_bar *url_bar,
                                         wimp_pointer *pointer)
{
        if (url_bar == NULL ||
            url_bar->hidden ||
            pointer == NULL) {
                return false;
        }
 
        return (pointer->w == url_bar->window &&
                pointer->i == url_bar->text.icon) ? true : false;
}
 
 
/* This is an exported interface documented in url_bar.h */
bool
ro_gui_url_bar_test_for_text_field_keypress(struct url_bar *url_bar,
                                            wimp_key *key)
{
        const char *url;
        nsurl *n;
 
        if (url_bar == NULL ||
            url_bar->hidden ||
            key == NULL) {
                return false;
        }
 
        if (key->w != url_bar->window ||
            key->i != url_bar->text.icon) {
                return false;
        }
 
        /* Update hotlist indicator */
 
        url = (const char *) url_bar->text.buffer;
        if (url != NULL &&
            nsurl_create(url, &n) == NSERROR_OK) {
                ro_gui_url_bar_set_hotlist(url_bar, ro_gui_hotlist_has_page(n));
                nsurl_unref(n);
        } else if (url_bar->hotlist.set) {
                ro_gui_url_bar_set_hotlist(url_bar, false);
        }
 
        return true;
}
 
 
/* This is an exported interface documented in url_bar.h */
bool
ro_gui_url_bar_set_site_favicon(struct url_bar *url_bar,
                                struct hlcache_handle *h)
{
        content_type type = CONTENT_NONE;
 
        if (url_bar == NULL) {
                return false;
        }
 
        if (h != NULL) {
                type = content_get_type(h);
        }
 
        // \TODO -- Maybe test for CONTENT_ICO ???
 
        if (type == CONTENT_IMAGE) {
                url_bar->favicon.content = h;
                url_bar->favicon.width = content_get_width(h);
                url_bar->favicon.height = content_get_height(h);
 
                if (url_bar->favicon.width > URLBAR_FAVICON_SIZE) {
                        url_bar->favicon.width = URLBAR_FAVICON_SIZE;
                }
 
                if (url_bar->favicon.height > URLBAR_FAVICON_SIZE) {
                        url_bar->favicon.height = URLBAR_FAVICON_SIZE;
                }
 
                url_bar->favicon.offset.x = ((url_bar->favicon.extent.x1 -
                                              url_bar->favicon.extent.x0) -
                                             (url_bar->favicon.width * 2)) / 2;
                url_bar->favicon.offset.y = ((url_bar->favicon.extent.y1 -
                                              url_bar->favicon.extent.y0) -
                                             (url_bar->favicon.height * 2)) / 2;
        } else {
                url_bar->favicon.content = NULL;
 
                if (url_bar->favicon.type != 0) {
                        snprintf(url_bar->favicon.sprite,
                                 URLBAR_FAVICON_NAME_LENGTH,
                                 "Ssmall_%.3x", url_bar->favicon.type);
                } else {
                        snprintf(url_bar->favicon.sprite,
                                 URLBAR_FAVICON_NAME_LENGTH,
                                 "Ssmall_xxx");
                }
        }
 
        if (!url_bar->hidden) {
                xwimp_force_redraw(url_bar->window,
                                   url_bar->favicon.extent.x0,
                                   url_bar->favicon.extent.y0,
                                   url_bar->favicon.extent.x1,
                                   url_bar->favicon.extent.y1);
        }
 
        return true;
}
 
 
/* This is an exported interface documented in url_bar.h */
bool ro_gui_url_bar_page_info_change(struct url_bar *url_bar)
{
        browser_window_page_info_state pistate;
        const char *icon_name;
        struct gui_window *g;
 
        g = ro_gui_toolbar_lookup(url_bar->window);
 
        pistate = browser_window_get_page_info_state(g->bw);
 
        switch (pistate) {
        case PAGE_STATE_LOCAL:
                icon_name = "pgilocal";
                break;
 
        case PAGE_STATE_INSECURE:
                icon_name = "pgiinsecure";
                break;
 
        case PAGE_STATE_SECURE_OVERRIDE:
                icon_name = "pgiwarning";
                break;
 
        case PAGE_STATE_SECURE_ISSUES:
                icon_name = "pgiwarning";
                break;
 
        case PAGE_STATE_SECURE:
                icon_name = "pgisecure";
                break;
 
        case PAGE_STATE_INTERNAL:
        default:
                icon_name = "pgiinternal";
                break;
        }
 
        strncpy(url_bar->pginfo.sprite, icon_name, URLBAR_PGINFO_NAME_LENGTH);
 
        if (!url_bar->hidden) {
                xwimp_force_redraw(url_bar->window,
                                   url_bar->pginfo.extent.x0,
                                   url_bar->pginfo.extent.y0,
                                   url_bar->pginfo.extent.x1,
                                   url_bar->pginfo.extent.y1);
        }
 
        return true;
}
 
 
/* This is an exported interface documented in url_bar.h */
bool
ro_gui_url_bar_set_content_favicon(struct url_bar *url_bar,
                                   struct gui_window *g)
{
        int type = 0;
        char sprite[URLBAR_FAVICON_NAME_LENGTH-1];
        struct hlcache_handle *h;
 
        if (url_bar == NULL ||
            g == NULL) {
                return false;
        }
 
        h = browser_window_get_content(g->bw);
        if (h != NULL) {
                type = ro_content_filetype(h);
        }
 
        if (type != 0) {
                snprintf(sprite, URLBAR_FAVICON_NAME_LENGTH,
                         "small_%.3x", type);
 
                if (!ro_gui_wimp_sprite_exists(sprite)) {
                        type = 0;
                }
        }
 
        url_bar->favicon.type = type;
 
        if (url_bar->favicon.content == NULL) {
                if (type == 0) {
                        snprintf(url_bar->favicon.sprite,
                                 URLBAR_FAVICON_NAME_LENGTH, "Ssmall_xxx");
                } else {
                        snprintf(url_bar->favicon.sprite,
                                 URLBAR_FAVICON_NAME_LENGTH, "S%s", sprite);
                }
 
                if (!url_bar->hidden) {
                        xwimp_force_redraw(url_bar->window,
                                           url_bar->favicon.extent.x0,
                                           url_bar->favicon.extent.y0,
                                           url_bar->favicon.extent.x1,
                                           url_bar->favicon.extent.y1);
                }
        }
 
        return true;
}
 
 
/* This is an exported interface documented in url_bar.h */
bool ro_gui_url_bar_update_urlsuggest(struct url_bar *url_bar)
{
        if (url_bar == NULL ||
            url_bar->hidden) {
                return (url_bar == NULL) ? false : true;
        }
 
        if (url_bar->window != NULL &&
            url_bar->suggest.icon != -1) {
                ro_gui_set_icon_shaded_state(url_bar->window,
                                             url_bar->suggest.icon,
                                             !ro_gui_url_suggest_get_menu_available());
        }
 
        return true;
}
 
 
/* Exported interface, documented in url_bar.h */
bool ro_gui_url_bar_init(void)
{
        int i;
 
        for (i = 0; i < URLBAR_RES_LAST; i++) {
                nsurl *url;
                if (nsurl_create(url_bar_res[i].url, &url) == NSERROR_OK) {
                        hlcache_handle_retrieve(url,
                                                0,
                                                NULL,
                                                NULL,
                                                ro_gui_url_bar_res_cb,
                                                &(url_bar_res[i]),
                                                NULL,
                                                CONTENT_IMAGE,
                                                &(url_bar_res[i].c));
                        nsurl_unref(url);
                }
        }
 
        return true;
}
 
 
/* Exported interface, documented in url_bar.h */
void ro_gui_url_bar_fini(void)
{
        int i;
 
        for (i = 0; i < URLBAR_RES_LAST; i++) {
                hlcache_handle_release(url_bar_res[i].c);
        }
}