netsurf-commits April 2020

netsurf-commits@netsurf-browser.org

1 participants
18 discussions

netsurf: branch master updated. release/3.9-612-g479d0cb

by NetSurf Browser Project

Gitweb links: ...log http://git.netsurf-browser.org/netsurf.git/shortlog/479d0cb29a74eddc95e3e... ...commit http://git.netsurf-browser.org/netsurf.git/commit/479d0cb29a74eddc95e3e22... ...tree http://git.netsurf-browser.org/netsurf.git/tree/479d0cb29a74eddc95e3e2292... The branch, master has been updated via 479d0cb29a74eddc95e3e2292d9d49e8dafdf46f (commit) via 6b6bbad2b7765378b5135a26b3d410d6b0079966 (commit) from e8d0ba15ad4a91b4644cac0095f40bb3246ec509 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=479d0cb29a74eddc95e... commit 479d0cb29a74eddc95e3e2292d9d49e8dafdf46f Author: Vincent Sanders <vince(a)kyllikki.org> Commit: Vincent Sanders <vince(a)kyllikki.org> remove unused available width and height parameters from html_fecth_object() diff --git a/content/handlers/html/box_construct.c b/content/handlers/html/box_construct.c index 1637c0f..fba9764 100644 --- a/content/handlers/html/box_construct.c +++ b/content/handlers/html/box_construct.c @@ -470,9 +470,11 @@ box_construct_marker(struct box *box, if (error != NSERROR_OK) return false; - if (html_fetch_object(ctx->content, url, marker, image_types, - ctx->content->base.available_width, 1000, false) == - false) { + if (html_fetch_object(ctx->content, + url, + marker, + image_types, + false) == false) { nsurl_unref(url); return false; } @@ -705,10 +707,11 @@ box_construct_element(struct box_construct_ctx *ctx, bool *convert_children) error = nsurl_create(lwc_string_data(bgimage_uri), &url); if (error == NSERROR_OK) { /* Fetch image if we got a valid URL */ - if (html_fetch_object(ctx->content, url, box, - image_types, - ctx->content->base.available_width, - 1000, true) == false) { + if (html_fetch_object(ctx->content, + url, + box, + image_types, + true) == false) { nsurl_unref(url); return false; } diff --git a/content/handlers/html/box_special.c b/content/handlers/html/box_special.c index 38031ce..9f4a512 100644 --- a/content/handlers/html/box_special.c +++ b/content/handlers/html/box_special.c @@ -956,8 +956,7 @@ box_embed(dom_node *n, /* start fetch */ box->flags |= IS_REPLACED; - return html_fetch_object(content, params->data, box, CONTENT_ANY, - content->base.available_width, 1000, false); + return html_fetch_object(content, params->data, box, CONTENT_ANY, false); } @@ -1189,8 +1188,7 @@ box_image(dom_node *n, /* start fetch */ box->flags |= IS_REPLACED; - ok = html_fetch_object(content, url, box, image_types, - content->base.available_width, 1000, false); + ok = html_fetch_object(content, url, box, image_types, false); nsurl_unref(url); wtype = css_computed_width(box->style, &value, &wunit); @@ -1332,11 +1330,11 @@ box_input(dom_node *n, */ if (nsurl_compare(url, content->base_url, NSURL_COMPLETE) == false) { - if (!html_fetch_object(content, url, - box, image_types, - content->base. - available_width, - 1000, false)) { + if (!html_fetch_object(content, + url, + box, + image_types, + false)) { nsurl_unref(url); goto no_memory; } @@ -1613,9 +1611,10 @@ box_object(dom_node *n, /* start fetch (MIME type is ok or not specified) */ box->flags |= IS_REPLACED; if (!html_fetch_object(content, - params->data ? params->data : params->classid, - box, CONTENT_ANY, content->base.available_width, 1000, - false)) + params->data ? params->data : params->classid, + box, + CONTENT_ANY, + false)) return false; *convert_children = false; diff --git a/content/handlers/html/html.c b/content/handlers/html/html.c index 01244cc..7230526 100644 --- a/content/handlers/html/html.c +++ b/content/handlers/html/html.c @@ -687,7 +687,7 @@ static bool html_process_img(html_content *c, dom_node *node) dom_string_unref(src); /* Speculatively fetch the image */ - success = html_fetch_object(c, url, NULL, CONTENT_IMAGE, 0, 0, false); + success = html_fetch_object(c, url, NULL, CONTENT_IMAGE, false); nsurl_unref(url); return success; diff --git a/content/handlers/html/html_internal.h b/content/handlers/html/html_internal.h index d981017..6b55334 100644 --- a/content/handlers/html/html_internal.h +++ b/content/handlers/html/html_internal.h @@ -376,15 +376,10 @@ nserror html_css_fetcher_add_item(dom_string *data, nsurl *base_url, * \param url URL of object to fetch (copied) * \param box box that will contain the object * \param permitted_types bitmap of acceptable types - * \param available_width estimate of width of object - * \param available_height estimate of height of object * \param background this is a background image * \return true on success, false on memory exhaustion */ -bool html_fetch_object(html_content *c, nsurl *url, struct box *box, - content_type permitted_types, - int available_width, int available_height, - bool background); +bool html_fetch_object(html_content *c, nsurl *url, struct box *box, content_type permitted_types, bool background); nserror html_object_free_objects(html_content *html); nserror html_object_close_objects(html_content *html); diff --git a/content/handlers/html/object.c b/content/handlers/html/object.c index 587c487..c20118d 100644 --- a/content/handlers/html/object.c +++ b/content/handlers/html/object.c @@ -677,10 +677,12 @@ nserror html_object_free_objects(html_content *html) /* exported interface documented in html/html_internal.h */ -bool html_fetch_object(html_content *c, nsurl *url, struct box *box, - content_type permitted_types, - int available_width, int available_height, - bool background) +bool +html_fetch_object(html_content *c, + nsurl *url, + struct box *box, + content_type permitted_types, + bool background) { struct content_html_object *object; hlcache_child_context child; @@ -706,10 +708,14 @@ bool html_fetch_object(html_content *c, nsurl *url, struct box *box, object->background = background; error = hlcache_handle_retrieve(url, - HLCACHE_RETRIEVE_SNIFF_TYPE, - content_get_url(&c->base), NULL, - html_object_callback, object, &child, - object->permitted_types, &object->content); + HLCACHE_RETRIEVE_SNIFF_TYPE, + content_get_url(&c->base), + NULL, + html_object_callback, + object, + &child, + object->permitted_types, + &object->content); if (error != NSERROR_OK) { free(object); return error != NSERROR_NOMEM; commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=6b6bbad2b7765378b51... commit 6b6bbad2b7765378b5135a26b3d410d6b0079966 Author: Vincent Sanders <vince(a)kyllikki.org> Commit: Vincent Sanders <vince(a)kyllikki.org> remove unecessary filename prefixes in the html content handler diff --git a/content/handlers/html/Makefile b/content/handlers/html/Makefile index 1976624..bdc0513 100644 --- a/content/handlers/html/Makefile +++ b/content/handlers/html/Makefile @@ -6,18 +6,18 @@ S_HTML := box_construct.c \ box_normalise.c \ box_special.c \ box_textarea.c \ + css.c \ + css_fetcher.c \ font.c \ form.c \ + forms.c \ + html.c \ imagemap.c \ + interaction.c \ layout.c \ + object.c \ + redraw.c \ + redraw_border.c \ + script.c \ search.c \ - table.c \ - html.c \ - html_css.c \ - html_css_fetcher.c \ - html_script.c \ - interaction.c \ - html_redraw.c \ - html_redraw_border.c \ - html_forms.c \ - html_object.c + table.c diff --git a/content/handlers/html/css.c b/content/handlers/html/css.c new file mode 100644 index 0000000..23d51f1 --- /dev/null +++ b/content/handlers/html/css.c @@ -0,0 +1,739 @@ +/* + * Copyright 2013 Vincent Sanders <vince(a)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 + * Processing for html content css operations. + */ + +#include "utils/config.h" + +#define _GNU_SOURCE /* strcasestr needs this for string.h */ + +#include <assert.h> +#include <ctype.h> +#include <stdint.h> +#include <string.h> +#include <strings.h> +#include <stdlib.h> + +#include "utils/nsoption.h" +#include "utils/corestrings.h" +#include "utils/log.h" +#include "netsurf/misc.h" +#include "netsurf/content.h" +#include "content/hlcache.h" +#include "css/css.h" +#include "desktop/gui_internal.h" + +#include "html/html.h" +#include "html/html_internal.h" + +static nsurl *html_default_stylesheet_url; +static nsurl *html_adblock_stylesheet_url; +static nsurl *html_quirks_stylesheet_url; +static nsurl *html_user_stylesheet_url; + +static nserror css_error_to_nserror(css_error error) +{ + switch (error) { + case CSS_OK: + return NSERROR_OK; + + case CSS_NOMEM: + return NSERROR_NOMEM; + + case CSS_BADPARM: + return NSERROR_BAD_PARAMETER; + + case CSS_INVALID: + return NSERROR_INVALID; + + case CSS_FILENOTFOUND: + return NSERROR_NOT_FOUND; + + case CSS_NEEDDATA: + return NSERROR_NEED_DATA; + + case CSS_BADCHARSET: + return NSERROR_BAD_ENCODING; + + case CSS_EOF: + case CSS_IMPORTS_PENDING: + case CSS_PROPERTY_NOT_SET: + default: + break; + } + return NSERROR_CSS; +} + +/** + * Callback for fetchcache() for stylesheets. + */ + +static nserror +html_convert_css_callback(hlcache_handle *css, + const hlcache_event *event, + void *pw) +{ + html_content *parent = pw; + unsigned int i; + struct html_stylesheet *s; + + /* Find sheet */ + for (i = 0, s = parent->stylesheets; + i != parent->stylesheet_count; + i++, s++) { + if (s->sheet == css) + break; + } + + assert(i != parent->stylesheet_count); + + switch (event->type) { + + case CONTENT_MSG_DONE: + NSLOG(netsurf, INFO, "done stylesheet slot %d '%s'", i, + nsurl_access(hlcache_handle_get_url(css))); + parent->base.active--; + NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); + break; + + case CONTENT_MSG_ERROR: + NSLOG(netsurf, INFO, "stylesheet %s failed: %s", + nsurl_access(hlcache_handle_get_url(css)), + event->data.errordata.errormsg); + + hlcache_handle_release(css); + s->sheet = NULL; + parent->base.active--; + NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); + content_add_error(&parent->base, "?", 0); + break; + + case CONTENT_MSG_POINTER: + /* Really don't want this to continue after the switch */ + return NSERROR_OK; + + default: + break; + } + + if (html_can_begin_conversion(parent)) { + html_begin_conversion(parent); + } + + return NSERROR_OK; +} + +static nserror +html_stylesheet_from_domnode(html_content *c, + dom_node *node, + hlcache_handle **sheet) +{ + hlcache_child_context child; + dom_string *style; + nsurl *url; + dom_exception exc; + nserror error; + uint32_t key; + char urlbuf[64]; + + child.charset = c->encoding; + child.quirks = c->base.quirks; + + exc = dom_node_get_text_content(node, &style); + if ((exc != DOM_NO_ERR) || (style == NULL)) { + NSLOG(netsurf, INFO, "No text content"); + return NSERROR_OK; + } + + error = html_css_fetcher_add_item(style, c->base_url, &key); + if (error != NSERROR_OK) { + dom_string_unref(style); + return error; + } + + dom_string_unref(style); + + snprintf(urlbuf, sizeof(urlbuf), "x-ns-css:%u", key); + + error = nsurl_create(urlbuf, &url); + if (error != NSERROR_OK) { + return error; + } + + error = hlcache_handle_retrieve(url, 0, + content_get_url(&c->base), NULL, + html_convert_css_callback, c, &child, CONTENT_CSS, + sheet); + if (error != NSERROR_OK) { + nsurl_unref(url); + return error; + } + + nsurl_unref(url); + + c->base.active++; + NSLOG(netsurf, INFO, "%d fetches active", c->base.active); + + return NSERROR_OK; +} + +/** + * Process an inline stylesheet in the document. + * + * \param c content structure + * \param style xml node of style element + * \return true on success, false if an error occurred + */ + +static struct html_stylesheet * +html_create_style_element(html_content *c, dom_node *style) +{ + dom_string *val; + dom_exception exc; + struct html_stylesheet *stylesheets; + + /* type='text/css', or not present (invalid but common) */ + exc = dom_element_get_attribute(style, corestring_dom_type, &val); + if (exc == DOM_NO_ERR && val != NULL) { + if (!dom_string_caseless_lwc_isequal(val, + corestring_lwc_text_css)) { + dom_string_unref(val); + return NULL; + } + dom_string_unref(val); + } + + /* media contains 'screen' or 'all' or not present */ + exc = dom_element_get_attribute(style, corestring_dom_media, &val); + if (exc == DOM_NO_ERR && val != NULL) { + if (strcasestr(dom_string_data(val), "screen") == NULL && + strcasestr(dom_string_data(val), + "all") == NULL) { + dom_string_unref(val); + return NULL; + } + dom_string_unref(val); + } + + /* Extend array */ + stylesheets = realloc(c->stylesheets, + sizeof(struct html_stylesheet) * + (c->stylesheet_count + 1)); + if (stylesheets == NULL) { + + content_broadcast_error(&c->base, NSERROR_NOMEM, NULL); + return false; + + } + c->stylesheets = stylesheets; + + c->stylesheets[c->stylesheet_count].node = dom_node_ref(style); + c->stylesheets[c->stylesheet_count].sheet = NULL; + c->stylesheets[c->stylesheet_count].modified = false; + c->stylesheets[c->stylesheet_count].unused = false; + c->stylesheet_count++; + + return c->stylesheets + (c->stylesheet_count - 1); +} + +static bool html_css_process_modified_style(html_content *c, + struct html_stylesheet *s) +{ + hlcache_handle *sheet = NULL; + nserror error; + + error = html_stylesheet_from_domnode(c, s->node, &sheet); + if (error != NSERROR_OK) { + NSLOG(netsurf, INFO, "Failed to update sheet"); + content_broadcast_error(&c->base, error, NULL); + return false; + } + + if (sheet != NULL) { + NSLOG(netsurf, INFO, "Updating sheet %p with %p", s->sheet, + sheet); + + if (s->sheet != NULL) { + switch (content_get_status(s->sheet)) { + case CONTENT_STATUS_DONE: + break; + default: + hlcache_handle_abort(s->sheet); + c->base.active--; + NSLOG(netsurf, INFO, "%d fetches active", + c->base.active); + } + hlcache_handle_release(s->sheet); + } + s->sheet = sheet; + } + + s->modified = false; + + return true; +} + +static void html_css_process_modified_styles(void *pw) +{ + html_content *c = pw; + struct html_stylesheet *s; + unsigned int i; + bool all_done = true; + + for (i = 0, s = c->stylesheets; i != c->stylesheet_count; i++, s++) { + if (c->stylesheets[i].modified) { + all_done &= html_css_process_modified_style(c, s); + } + } + + /* If we failed to process any sheet, schedule a retry */ + if (all_done == false) { + guit->misc->schedule(1000, html_css_process_modified_styles, c); + } +} + +bool html_css_update_style(html_content *c, dom_node *style) +{ + unsigned int i; + struct html_stylesheet *s; + + /* Find sheet */ + for (i = 0, s = c->stylesheets; i != c->stylesheet_count; i++, s++) { + if (s->node == style) + break; + } + if (i == c->stylesheet_count) { + s = html_create_style_element(c, style); + } + if (s == NULL) { + NSLOG(netsurf, INFO, + "Could not find or create inline stylesheet for %p", + style); + return false; + } + + s->modified = true; + + guit->misc->schedule(0, html_css_process_modified_styles, c); + + return true; +} + +bool html_css_process_style(html_content *c, dom_node *node) +{ + unsigned int i; + dom_string *val; + dom_exception exc; + struct html_stylesheet *s; + + /* Find sheet */ + for (i = 0, s = c->stylesheets; i != c->stylesheet_count; i++, s++) { + if (s->node == node) + break; + } + + /* Should already exist */ + if (i == c->stylesheet_count) { + return false; + } + + exc = dom_element_get_attribute(node, corestring_dom_media, &val); + if (exc == DOM_NO_ERR && val != NULL) { + if (strcasestr(dom_string_data(val), "screen") == NULL && + strcasestr(dom_string_data(val), + "all") == NULL) { + s->unused = true; + } + dom_string_unref(val); + } + + return true; +} + +bool html_css_process_link(html_content *htmlc, dom_node *node) +{ + dom_string *rel, *type_attr, *media, *href; + struct html_stylesheet *stylesheets; + nsurl *joined; + dom_exception exc; + nserror ns_error; + hlcache_child_context child; + + /* rel=<space separated list, including 'stylesheet'> */ + exc = dom_element_get_attribute(node, corestring_dom_rel, &rel); + if (exc != DOM_NO_ERR || rel == NULL) + return true; + + if (strcasestr(dom_string_data(rel), "stylesheet") == 0) { + dom_string_unref(rel); + return true; + } else if (strcasestr(dom_string_data(rel), "alternate") != 0) { + /* Ignore alternate stylesheets */ + dom_string_unref(rel); + return true; + } + dom_string_unref(rel); + + /* type='text/css' or not present */ + exc = dom_element_get_attribute(node, corestring_dom_type, &type_attr); + if (exc == DOM_NO_ERR && type_attr != NULL) { + if (!dom_string_caseless_lwc_isequal(type_attr, + corestring_lwc_text_css)) { + dom_string_unref(type_attr); + return true; + } + dom_string_unref(type_attr); + } + + /* media contains 'screen' or 'all' or not present */ + exc = dom_element_get_attribute(node, corestring_dom_media, &media); + if (exc == DOM_NO_ERR && media != NULL) { + if (strcasestr(dom_string_data(media), "screen") == NULL && + strcasestr(dom_string_data(media), "all") == NULL) { + dom_string_unref(media); + return true; + } + dom_string_unref(media); + } + + /* href='...' */ + exc = dom_element_get_attribute(node, corestring_dom_href, &href); + if (exc != DOM_NO_ERR || href == NULL) + return true; + + /* TODO: only the first preferred stylesheets (ie. + * those with a title attribute) should be loaded + * (see HTML4 14.3) */ + + ns_error = nsurl_join(htmlc->base_url, dom_string_data(href), &joined); + if (ns_error != NSERROR_OK) { + dom_string_unref(href); + goto no_memory; + } + dom_string_unref(href); + + NSLOG(netsurf, INFO, "linked stylesheet %i '%s'", + htmlc->stylesheet_count, nsurl_access(joined)); + + /* extend stylesheets array to allow for new sheet */ + stylesheets = realloc(htmlc->stylesheets, + sizeof(struct html_stylesheet) * + (htmlc->stylesheet_count + 1)); + if (stylesheets == NULL) { + nsurl_unref(joined); + ns_error = NSERROR_NOMEM; + goto no_memory; + } + + htmlc->stylesheets = stylesheets; + htmlc->stylesheets[htmlc->stylesheet_count].node = NULL; + htmlc->stylesheets[htmlc->stylesheet_count].modified = false; + htmlc->stylesheets[htmlc->stylesheet_count].unused = false; + + /* start fetch */ + child.charset = htmlc->encoding; + child.quirks = htmlc->base.quirks; + + ns_error = hlcache_handle_retrieve(joined, 0, + content_get_url(&htmlc->base), + NULL, html_convert_css_callback, + htmlc, &child, CONTENT_CSS, + &htmlc->stylesheets[htmlc->stylesheet_count].sheet); + + nsurl_unref(joined); + + if (ns_error != NSERROR_OK) + goto no_memory; + + htmlc->stylesheet_count++; + + htmlc->base.active++; + NSLOG(netsurf, INFO, "%d fetches active", htmlc->base.active); + + return true; + +no_memory: + content_broadcast_error(&htmlc->base, ns_error, NULL); + return false; +} + +/* exported interface documented in html/html.h */ +struct html_stylesheet *html_get_stylesheets(hlcache_handle *h, unsigned int *n) +{ + html_content *c = (html_content *) hlcache_handle_get_content(h); + + assert(c != NULL); + assert(n != NULL); + + *n = c->stylesheet_count; + + return c->stylesheets; +} + +/* exported interface documented in html/html_internal.h */ +bool html_saw_insecure_stylesheets(html_content *html) +{ + struct html_stylesheet *s; + unsigned int i; + + for (i = 0, s = html->stylesheets; i < html->stylesheet_count; + i++, s++) { + if (s->sheet != NULL) { + if (content_saw_insecure_objects(s->sheet)) { + return true; + } + } + } + + return false; +} + +/* exported interface documented in html/html_internal.h */ +nserror html_css_free_stylesheets(html_content *html) +{ + unsigned int i; + + guit->misc->schedule(-1, html_css_process_modified_styles, html); + + for (i = 0; i != html->stylesheet_count; i++) { + if (html->stylesheets[i].sheet != NULL) { + hlcache_handle_release(html->stylesheets[i].sheet); + } + if (html->stylesheets[i].node != NULL) { + dom_node_unref(html->stylesheets[i].node); + } + } + free(html->stylesheets); + + return NSERROR_OK; +} + +/* exported interface documented in html/html_internal.h */ +nserror html_css_quirks_stylesheets(html_content *c) +{ + nserror ns_error = NSERROR_OK; + hlcache_child_context child; + + assert(c->stylesheets != NULL); + + if (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL) { + child.charset = c->encoding; + child.quirks = c->base.quirks; + + ns_error = hlcache_handle_retrieve(html_quirks_stylesheet_url, + 0, content_get_url(&c->base), NULL, + html_convert_css_callback, c, &child, + CONTENT_CSS, + &c->stylesheets[STYLESHEET_QUIRKS].sheet); + if (ns_error != NSERROR_OK) { + return ns_error; + } + + c->base.active++; + NSLOG(netsurf, INFO, "%d fetches active", c->base.active); + } + + return ns_error; +} + +/* exported interface documented in html/html_internal.h */ +nserror html_css_new_stylesheets(html_content *c) +{ + nserror ns_error; + hlcache_child_context child; + + if (c->stylesheets != NULL) { + return NSERROR_OK; /* already initialised */ + } + + /* stylesheet 0 is the base style sheet, + * stylesheet 1 is the quirks mode style sheet, + * stylesheet 2 is the adblocking stylesheet, + * stylesheet 3 is the user stylesheet */ + c->stylesheets = calloc(STYLESHEET_START, + sizeof(struct html_stylesheet)); + if (c->stylesheets == NULL) { + return NSERROR_NOMEM; + } + + c->stylesheets[STYLESHEET_BASE].sheet = NULL; + c->stylesheets[STYLESHEET_QUIRKS].sheet = NULL; + c->stylesheets[STYLESHEET_ADBLOCK].sheet = NULL; + c->stylesheets[STYLESHEET_USER].sheet = NULL; + c->stylesheet_count = STYLESHEET_START; + + child.charset = c->encoding; + child.quirks = c->base.quirks; + + ns_error = hlcache_handle_retrieve(html_default_stylesheet_url, 0, + content_get_url(&c->base), NULL, + html_convert_css_callback, c, &child, CONTENT_CSS, + &c->stylesheets[STYLESHEET_BASE].sheet); + if (ns_error != NSERROR_OK) { + return ns_error; + } + + c->base.active++; + NSLOG(netsurf, INFO, "%d fetches active", c->base.active); + + + if (nsoption_bool(block_advertisements)) { + ns_error = hlcache_handle_retrieve(html_adblock_stylesheet_url, + 0, content_get_url(&c->base), NULL, + html_convert_css_callback, + c, &child, CONTENT_CSS, + &c->stylesheets[STYLESHEET_ADBLOCK].sheet); + if (ns_error != NSERROR_OK) { + return ns_error; + } + + c->base.active++; + NSLOG(netsurf, INFO, "%d fetches active", c->base.active); + + } + + ns_error = hlcache_handle_retrieve(html_user_stylesheet_url, 0, + content_get_url(&c->base), NULL, + html_convert_css_callback, c, &child, CONTENT_CSS, + &c->stylesheets[STYLESHEET_USER].sheet); + if (ns_error != NSERROR_OK) { + return ns_error; + } + + c->base.active++; + NSLOG(netsurf, INFO, "%d fetches active", c->base.active); + + return ns_error; +} + +nserror +html_css_new_selection_context(html_content *c, css_select_ctx **ret_select_ctx) +{ + uint32_t i; + css_error css_ret; + css_select_ctx *select_ctx; + + /* check that the base stylesheet loaded; layout fails without it */ + if (c->stylesheets[STYLESHEET_BASE].sheet == NULL) { + return NSERROR_CSS_BASE; + } + + /* Create selection context */ + css_ret = css_select_ctx_create(&select_ctx); + if (css_ret != CSS_OK) { + return css_error_to_nserror(css_ret); + } + + /* Add sheets to it */ + for (i = STYLESHEET_BASE; i != c->stylesheet_count; i++) { + const struct html_stylesheet *hsheet = &c->stylesheets[i]; + css_stylesheet *sheet = NULL; + css_origin origin = CSS_ORIGIN_AUTHOR; + + /* Filter out stylesheets for non-screen media. */ + /* TODO: We should probably pass the sheet in anyway, and let + * libcss handle the filtering. + */ + if (hsheet->unused) { + continue; + } + + if (i < STYLESHEET_USER) { + origin = CSS_ORIGIN_UA; + } else if (i < STYLESHEET_START) { + origin = CSS_ORIGIN_USER; + } + + if (hsheet->sheet != NULL) { + sheet = nscss_get_stylesheet(hsheet->sheet); + } + + if (sheet != NULL) { + /* TODO: Pass the sheet's full media query, instead of + * "screen". + */ + css_ret = css_select_ctx_append_sheet(select_ctx, + sheet, + origin, + "screen"); + if (css_ret != CSS_OK) { + css_select_ctx_destroy(select_ctx); + return css_error_to_nserror(css_ret); + } + } + } + + /* return new selection context to caller */ + *ret_select_ctx = select_ctx; + return NSERROR_OK; +} + +nserror html_css_init(void) +{ + nserror error; + + error = html_css_fetcher_register(); + if (error != NSERROR_OK) + return error; + + error = nsurl_create("resource:default.css", + &html_default_stylesheet_url); + if (error != NSERROR_OK) + return error; + + error = nsurl_create("resource:adblock.css", + &html_adblock_stylesheet_url); + if (error != NSERROR_OK) + return error; + + error = nsurl_create("resource:quirks.css", + &html_quirks_stylesheet_url); + if (error != NSERROR_OK) + return error; + + error = nsurl_create("resource:user.css", + &html_user_stylesheet_url); + + return error; +} + +void html_css_fini(void) +{ + if (html_user_stylesheet_url != NULL) { + nsurl_unref(html_user_stylesheet_url); + html_user_stylesheet_url = NULL; + } + + if (html_quirks_stylesheet_url != NULL) { + nsurl_unref(html_quirks_stylesheet_url); + html_quirks_stylesheet_url = NULL; + } + + if (html_adblock_stylesheet_url != NULL) { + nsurl_unref(html_adblock_stylesheet_url); + html_adblock_stylesheet_url = NULL; + } + + if (html_default_stylesheet_url != NULL) { + nsurl_unref(html_default_stylesheet_url); + html_default_stylesheet_url = NULL; + } +} diff --git a/content/handlers/html/css_fetcher.c b/content/handlers/html/css_fetcher.c new file mode 100644 index 0000000..ae20879 --- /dev/null +++ b/content/handlers/html/css_fetcher.c @@ -0,0 +1,320 @@ +/* + * Copyright 2008 Rob Kendrick <rjek(a)netsurf-browser.org> + * Copyright 2013 John-Mark Bell <jmb(a)netsurf-browser.org> + * + * This file is part of NetSurf. + * + * 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 + * HTML fetcher for CSS objects + */ + +#include <assert.h> +#include <stdbool.h> +#include <stdlib.h> +#include <string.h> +#include <dom/dom.h> +#include <libwapcaplet/libwapcaplet.h> + +#include "netsurf/inttypes.h" +#include "utils/config.h" +#include "utils/corestrings.h" +#include "utils/log.h" +#include "utils/ring.h" +#include "utils/nsurl.h" +#include "utils/utils.h" +#include "content/fetch.h" +#include "content/fetchers.h" + +#include "html/html_internal.h" + +typedef struct html_css_fetcher_item { + uint32_t key; + dom_string *data; + nsurl *base_url; + + struct html_css_fetcher_item *r_next, *r_prev; +} html_css_fetcher_item; + +typedef struct html_css_fetcher_context { + struct fetch *parent_fetch; + + nsurl *url; + html_css_fetcher_item *item; + + bool aborted; + bool locked; + + struct html_css_fetcher_context *r_next, *r_prev; +} html_css_fetcher_context; + +static uint32_t current_key = 0; +static html_css_fetcher_item *items = NULL; +static html_css_fetcher_context *ring = NULL; + +static bool html_css_fetcher_initialise(lwc_string *scheme) +{ + NSLOG(netsurf, INFO, "html_css_fetcher_initialise called for %s", + lwc_string_data(scheme)); + return true; +} + +static void html_css_fetcher_finalise(lwc_string *scheme) +{ + NSLOG(netsurf, INFO, "html_css_fetcher_finalise called for %s", + lwc_string_data(scheme)); +} + +static bool html_css_fetcher_can_fetch(const nsurl *url) +{ + return true; +} + +static void *html_css_fetcher_setup(struct fetch *parent_fetch, nsurl *url, + bool only_2xx, bool downgrade_tls, const char *post_urlenc, + const struct fetch_multipart_data *post_multipart, + const char **headers) +{ + html_css_fetcher_context *ctx; + lwc_string *path; + uint32_t key; + html_css_fetcher_item *item, *found = NULL; + + /* format of a x-ns-css URL is: + * x-ns-url:<key> + * Where key is an unsigned 32bit integer + */ + + path = nsurl_get_component(url, NSURL_PATH); + /* The path must exist */ + if (path == NULL) { + return NULL; + } + + key = strtoul(lwc_string_data(path), NULL, 10); + + lwc_string_unref(path); + + /* There must be at least one item */ + if (items == NULL) { + return NULL; + } + + item = items; + do { + if (item->key == key) { + found = item; + break; + } + + item = item->r_next; + } while (item != items); + + /* We must have found the item */ + if (found == NULL) { + return NULL; + } + + ctx = calloc(1, sizeof(*ctx)); + if (ctx == NULL) + return NULL; + + ctx->parent_fetch = parent_fetch; + ctx->url = nsurl_ref(url); + ctx->item = found; + + RING_INSERT(ring, ctx); + + return ctx; +} + +static bool html_css_fetcher_start(void *ctx) +{ + return true; +} + +static void html_css_fetcher_free(void *ctx) +{ + html_css_fetcher_context *c = ctx; + + nsurl_unref(c->url); + if (c->item != NULL) { + nsurl_unref(c->item->base_url); + dom_string_unref(c->item->data); + RING_REMOVE(items, c->item); + free(c->item); + } + RING_REMOVE(ring, c); + free(ctx); +} + +static void html_css_fetcher_abort(void *ctx) +{ + html_css_fetcher_context *c = ctx; + + /* To avoid the poll loop having to deal with the fetch context + * disappearing from under it, we simply flag the abort here. + * The poll loop itself will perform the appropriate cleanup. + */ + c->aborted = true; +} + +static void html_css_fetcher_send_callback(const fetch_msg *msg, + html_css_fetcher_context *c) +{ + c->locked = true; + fetch_send_callback(msg, c->parent_fetch); + c->locked = false; +} + +static void html_css_fetcher_poll(lwc_string *scheme) +{ + fetch_msg msg; + html_css_fetcher_context *c, *next; + + if (ring == NULL) return; + + /* Iterate over ring, processing each pending fetch */ + c = ring; + do { + /* Ignore fetches that have been flagged as locked. + * This allows safe re-entrant calls to this function. + * Re-entrancy can occur if, as a result of a callback, + * the interested party causes fetch_poll() to be called + * again. + */ + if (c->locked == true) { + next = c->r_next; + continue; + } + + /* Only process non-aborted fetches */ + if (c->aborted) { + /* Nothing to do */ + assert(c->locked == false); + } else if (c->item != NULL) { + char header[4096]; + + fetch_set_http_code(c->parent_fetch, 200); + + /* Any callback can result in the fetch being aborted. + * Therefore, we _must_ check for this after _every_ + * call to html_css_fetcher_send_callback(). + */ + snprintf(header, sizeof header, + "Content-Type: text/css; charset=utf-8"); + msg.type = FETCH_HEADER; + msg.data.header_or_data.buf = (const uint8_t *) header; + msg.data.header_or_data.len = strlen(header); + html_css_fetcher_send_callback(&msg, c); + + if (c->aborted == false) { + snprintf(header, sizeof header, + "Content-Length: %"PRIsizet, + dom_string_byte_length(c->item->data)); + msg.type = FETCH_HEADER; + msg.data.header_or_data.buf = + (const uint8_t *) header; + msg.data.header_or_data.len = strlen(header); + html_css_fetcher_send_callback(&msg, c); + } + + if (c->aborted == false) { + snprintf(header, sizeof header, + "X-NS-Base: %.*s", + (int) nsurl_length(c->item->base_url), + nsurl_access(c->item->base_url)); + msg.type = FETCH_HEADER; + msg.data.header_or_data.buf = + (const uint8_t *) header; + msg.data.header_or_data.len = strlen(header); + html_css_fetcher_send_callback(&msg, c); + } + + if (c->aborted == false) { + msg.type = FETCH_DATA; + msg.data.header_or_data.buf = + (const uint8_t *) + dom_string_data(c->item->data); + msg.data.header_or_data.len = + dom_string_byte_length(c->item->data); + html_css_fetcher_send_callback(&msg, c); + } + + if (c->aborted == false) { + msg.type = FETCH_FINISHED; + html_css_fetcher_send_callback(&msg, c); + } + } else { + NSLOG(netsurf, INFO, "Processing of %s failed!", + nsurl_access(c->url)); + + /* Ensure that we're unlocked here. If we aren't, + * then html_css_fetcher_process() is broken. + */ + assert(c->locked == false); + } + + /* Compute next fetch item at the last possible moment as + * processing this item may have added to the ring. + */ + next = c->r_next; + + fetch_remove_from_queues(c->parent_fetch); + fetch_free(c->parent_fetch); + + /* Advance to next ring entry, exiting if we've reached + * the start of the ring or the ring has become empty + */ + } while ( (c = next) != ring && ring != NULL); +} + +/* exported interface documented in html_internal.h */ +nserror html_css_fetcher_register(void) +{ + const struct fetcher_operation_table html_css_fetcher_ops = { + .initialise = html_css_fetcher_initialise, + .acceptable = html_css_fetcher_can_fetch, + .setup = html_css_fetcher_setup, + .start = html_css_fetcher_start, + .abort = html_css_fetcher_abort, + .free = html_css_fetcher_free, + .poll = html_css_fetcher_poll, + .finalise = html_css_fetcher_finalise + }; + + return fetcher_add(lwc_string_ref(corestring_lwc_x_ns_css), + &html_css_fetcher_ops); +} + +/* exported interface documented in html_internal.h */ +nserror +html_css_fetcher_add_item(dom_string *data, nsurl *base_url, uint32_t *key) +{ + html_css_fetcher_item *item = malloc(sizeof(*item)); + + if (item == NULL) { + return NSERROR_NOMEM; + } + + *key = item->key = current_key++; + item->data = dom_string_ref(data); + item->base_url = nsurl_ref(base_url); + + RING_INSERT(items, item); + + return NSERROR_OK; +} diff --git a/content/handlers/html/forms.c b/content/handlers/html/forms.c new file mode 100644 index 0000000..896263d --- /dev/null +++ b/content/handlers/html/forms.c @@ -0,0 +1,590 @@ +/* + * Copyright 2011 Vincent Sanders <vince(a)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 + * HTML form handling implementation + */ + +#include "utils/config.h" +#include "utils/corestrings.h" +#include "utils/log.h" + +#include "html/form_internal.h" +#include "html/html_internal.h" + +/** + * process form element from dom + */ +static struct form * +parse_form_element(const char *docenc, dom_node *node) +{ + dom_string *ds_action = NULL; + dom_string *ds_charset = NULL; + dom_string *ds_target = NULL; + dom_string *ds_method = NULL; + dom_string *ds_enctype = NULL; + char *action = NULL, *charset = NULL, *target = NULL; + form_method method; + dom_html_form_element *formele = (dom_html_form_element *)(node); + struct form * ret = NULL; + + /* Retrieve the attributes from the node */ + if (dom_html_form_element_get_action(formele, + &ds_action) != DOM_NO_ERR) + goto out; + + if (dom_html_form_element_get_accept_charset(formele, + &ds_charset) != DOM_NO_ERR) + goto out; + + if (dom_html_form_element_get_target(formele, + &ds_target) != DOM_NO_ERR) + goto out; + + if (dom_html_form_element_get_method(formele, + &ds_method) != DOM_NO_ERR) + goto out; + + if (dom_html_form_element_get_enctype(formele, + &ds_enctype) != DOM_NO_ERR) + goto out; + + /* Extract the plain attributes ready for use. We have to do this + * because we cannot guarantee that the dom_strings are NULL terminated + * and thus we copy them. + */ + if (ds_action != NULL) + action = strndup(dom_string_data(ds_action), + dom_string_byte_length(ds_action)); + + if (ds_charset != NULL) + charset = strndup(dom_string_data(ds_charset), + dom_string_byte_length(ds_charset)); + + if (ds_target != NULL) + target = strndup(dom_string_data(ds_target), + dom_string_byte_length(ds_target)); + + /* Determine the method */ + method = method_GET; + if (ds_method != NULL) { + if (dom_string_caseless_lwc_isequal(ds_method, + corestring_lwc_post)) { + method = method_POST_URLENC; + if (ds_enctype != NULL) { + if (dom_string_caseless_lwc_isequal(ds_enctype, + corestring_lwc_multipart_form_data)) { + + method = method_POST_MULTIPART; + } + } + } + } + + /* Construct the form object */ + ret = form_new(node, action, target, method, charset, docenc); + +out: + if (ds_action != NULL) + dom_string_unref(ds_action); + if (ds_charset != NULL) + dom_string_unref(ds_charset); + if (ds_target != NULL) + dom_string_unref(ds_target); + if (ds_method != NULL) + dom_string_unref(ds_method); + if (ds_enctype != NULL) + dom_string_unref(ds_enctype); + if (action != NULL) + free(action); + if (charset != NULL) + free(charset); + if (target != NULL) + free(target); + return ret; +} + +/* documented in html_internal.h */ +struct form *html_forms_get_forms(const char *docenc, dom_html_document *doc) +{ + dom_html_collection *forms; + struct form *ret = NULL, *newf; + dom_node *node; + unsigned long n; + uint32_t nforms; + + if (doc == NULL) + return NULL; + + /* Attempt to build a set of all the forms */ + if (dom_html_document_get_forms(doc, &forms) != DOM_NO_ERR) + return NULL; + + /* Count the number of forms so we can iterate */ + if (dom_html_collection_get_length(forms, &nforms) != DOM_NO_ERR) + goto out; + + /* Iterate the forms collection, making form structs for returning */ + for (n = 0; n < nforms; ++n) { + if (dom_html_collection_item(forms, n, &node) != DOM_NO_ERR) { + goto out; + } + newf = parse_form_element(docenc, node); + dom_node_unref(node); + if (newf == NULL) { + goto err; + } + newf->prev = ret; + ret = newf; + } + + /* All went well */ + goto out; +err: + while (ret != NULL) { + struct form *prev = ret->prev; + /* Destroy ret */ + free(ret); + ret = prev; + } +out: + /* Finished with the collection, return it */ + dom_html_collection_unref(forms); + + return ret; +} + +static struct form * +find_form(struct form *forms, dom_html_form_element *form) +{ + while (forms != NULL) { + if (forms->node == form) + break; + forms = forms->prev; + } + + return forms; +} + +static struct form_control * +parse_button_element(struct form *forms, dom_html_button_element *button) +{ + struct form_control *control = NULL; + dom_exception err; + dom_html_form_element *form = NULL; + dom_string *ds_type = NULL; + dom_string *ds_value = NULL; + dom_string *ds_name = NULL; + + err = dom_html_button_element_get_form(button, &form); + if (err != DOM_NO_ERR) + goto out; + + err = dom_html_button_element_get_type(button, &ds_type); + if (err != DOM_NO_ERR) + goto out; + + if (ds_type == NULL) { + control = form_new_control(button, GADGET_SUBMIT); + } else { + if (dom_string_caseless_lwc_isequal(ds_type, + corestring_lwc_submit)) { + control = form_new_control(button, GADGET_SUBMIT); + } else if (dom_string_caseless_lwc_isequal(ds_type, + corestring_lwc_reset)) { + control = form_new_control(button, GADGET_RESET); + } else { + control = form_new_control(button, GADGET_BUTTON); + } + } + + if (control == NULL) + goto out; + + err = dom_html_button_element_get_value(button, &ds_value); + if (err != DOM_NO_ERR) + goto out; + err = dom_html_button_element_get_name(button, &ds_name); + if (err != DOM_NO_ERR) + goto out; + + if (ds_value != NULL) { + control->value = strndup( + dom_string_data(ds_value), + dom_string_byte_length(ds_value)); + + if (control->value == NULL) { + form_free_control(control); + control = NULL; + goto out; + } + } + + if (ds_name != NULL) { + control->name = strndup( + dom_string_data(ds_name), + dom_string_byte_length(ds_name)); + + if (control->name == NULL) { + form_free_control(control); + control = NULL; + goto out; + } + } + + if (form != NULL && control != NULL) + form_add_control(find_form(forms, form), control); + +out: + if (form != NULL) + dom_node_unref(form); + if (ds_type != NULL) + dom_string_unref(ds_type); + if (ds_value != NULL) + dom_string_unref(ds_value); + if (ds_name != NULL) + dom_string_unref(ds_name); + + return control; +} + +static struct form_control * +parse_input_element(struct form *forms, dom_html_input_element *input) +{ + struct form_control *control = NULL; + dom_html_form_element *form = NULL; + dom_string *ds_type = NULL; + dom_string *ds_name = NULL; + dom_string *ds_value = NULL; + + char *name = NULL; + + if (dom_html_input_element_get_form(input, &form) != DOM_NO_ERR) + goto out; + + if (dom_html_input_element_get_type(input, &ds_type) != DOM_NO_ERR) + goto out; + + if (dom_html_input_element_get_name(input, &ds_name) != DOM_NO_ERR) + goto out; + + if (ds_name != NULL) + name = strndup(dom_string_data(ds_name), + dom_string_byte_length(ds_name)); + + if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, + corestring_lwc_password)) { + control = form_new_control(input, GADGET_PASSWORD); + } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, + corestring_lwc_file)) { + control = form_new_control(input, GADGET_FILE); + } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, + corestring_lwc_hidden)) { + control = form_new_control(input, GADGET_HIDDEN); + } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, + corestring_lwc_checkbox)) { + control = form_new_control(input, GADGET_CHECKBOX); + } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, + corestring_lwc_radio)) { + control = form_new_control(input, GADGET_RADIO); + } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, + corestring_lwc_submit)) { + control = form_new_control(input, GADGET_SUBMIT); + } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, + corestring_lwc_reset)) { + control = form_new_control(input, GADGET_RESET); + } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, + corestring_lwc_button)) { + control = form_new_control(input, GADGET_BUTTON); + } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, + corestring_lwc_image)) { + control = form_new_control(input, GADGET_IMAGE); + } else { + control = form_new_control(input, GADGET_TEXTBOX); + } + + if (control == NULL) + goto out; + + if (name != NULL) { + /* Hand the name string over */ + control->name = name; + name = NULL; + } + + if (control->type == GADGET_CHECKBOX || control->type == GADGET_RADIO) { + bool selected; + if (dom_html_input_element_get_checked( + input, &selected) == DOM_NO_ERR) { + control->selected = selected; + } + } + + if (control->type == GADGET_PASSWORD || + control->type == GADGET_TEXTBOX) { + int32_t maxlength; + if (dom_html_input_element_get_max_length( + input, &maxlength) != DOM_NO_ERR) { + maxlength = -1; + } + + if (maxlength >= 0) { + /* Got valid maxlength */ + control->maxlength = maxlength; + } else { + /* Input has no maxlength attr, or + * dom_html_input_element_get_max_length failed. + * + * Set it to something insane. */ + control->maxlength = UINT_MAX; + } + } + + if (control->type != GADGET_FILE && control->type != GADGET_IMAGE) { + if (dom_html_input_element_get_value( + input, &ds_value) == DOM_NO_ERR) { + if (ds_value != NULL) { + control->value = strndup( + dom_string_data(ds_value), + dom_string_byte_length(ds_value)); + if (control->value == NULL) { + form_free_control(control); + control = NULL; + goto out; + } + control->length = strlen(control->value); + } + } + + if (control->type == GADGET_TEXTBOX || + control->type == GADGET_PASSWORD) { + if (control->value == NULL) { + control->value = strdup(""); + if (control->value == NULL) { + form_free_control(control); + control = NULL; + goto out; + } + + control->length = 0; + } + + control->initial_value = strdup(control->value); + if (control->initial_value == NULL) { + form_free_control(control); + control = NULL; + goto out; + } + + control->last_synced_value = strdup(control->value); + if (control->last_synced_value == NULL) { + form_free_control(control); + control = NULL; + goto out; + } + + control->node_value = dom_string_ref(ds_value); + } + /* Force the gadget and DOM to be in sync */ + form_gadget_sync_with_dom(control); + } + + if (form != NULL && control != NULL) + form_add_control(find_form(forms, form), control); + +out: + if (form != NULL) + dom_node_unref(form); + if (ds_type != NULL) + dom_string_unref(ds_type); + if (ds_name != NULL) + dom_string_unref(ds_name); + if (ds_value != NULL) + dom_string_unref(ds_value); + + if (name != NULL) + free(name); + + return control; +} + +static struct form_control * +parse_textarea_element(struct form *forms, dom_html_text_area_element *ta) +{ + struct form_control *control = NULL; + dom_html_form_element *form = NULL; + dom_string *ds_name = NULL; + + char *name = NULL; + + if (dom_html_text_area_element_get_form(ta, &form) != DOM_NO_ERR) + goto out; + + if (dom_html_text_area_element_get_name(ta, &ds_name) != DOM_NO_ERR) + goto out; + + if (ds_name != NULL) + name = strndup(dom_string_data(ds_name), + dom_string_byte_length(ds_name)); + + control = form_new_control(ta, GADGET_TEXTAREA); + + if (control == NULL) + goto out; + + if (name != NULL) { + /* Hand the name string over */ + control->name = name; + name = NULL; + } + + if (form != NULL && control != NULL) + form_add_control(find_form(forms, form), control); + +out: + if (form != NULL) + dom_node_unref(form); + if (ds_name != NULL) + dom_string_unref(ds_name); + + if (name != NULL) + free(name); + + + return control; +} + +static struct form_control * +parse_select_element(struct form *forms, dom_html_select_element *select) +{ + struct form_control *control = NULL; + dom_html_form_element *form = NULL; + dom_string *ds_name = NULL; + + char *name = NULL; + + if (dom_html_select_element_get_form(select, &form) != DOM_NO_ERR) + goto out; + + if (dom_html_select_element_get_name(select, &ds_name) != DOM_NO_ERR) + goto out; + + if (ds_name != NULL) + name = strndup(dom_string_data(ds_name), + dom_string_byte_length(ds_name)); + + control = form_new_control(select, GADGET_SELECT); + + if (control == NULL) + goto out; + + if (name != NULL) { + /* Hand the name string over */ + control->name = name; + name = NULL; + } + + dom_html_select_element_get_multiple(select, + &(control->data.select.multiple)); + + if (form != NULL && control != NULL) + form_add_control(find_form(forms, form), control); + +out: + if (form != NULL) + dom_node_unref(form); + if (ds_name != NULL) + dom_string_unref(ds_name); + + if (name != NULL) + free(name); + + + return control; +} + + +static struct form_control * +invent_fake_gadget(dom_node *node) +{ + struct form_control *ctl = form_new_control(node, GADGET_HIDDEN); + if (ctl != NULL) { + ctl->value = strdup(""); + ctl->initial_value = strdup(""); + ctl->name = strdup("foo"); + + if (ctl->value == NULL || ctl->initial_value == NULL || + ctl->name == NULL) { + form_free_control(ctl); + ctl = NULL; + } + } + return ctl; +} + +/* documented in html_internal.h */ +struct form_control *html_forms_get_control_for_node(struct form *forms, + dom_node *node) +{ + struct form *f; + struct form_control *ctl = NULL; + dom_exception err; + dom_string *ds_name = NULL; + + /* Step one, see if we already have a control */ + for (f = forms; f != NULL; f = f->prev) { + for (ctl = f->controls; ctl != NULL; ctl = ctl->next) { + if (ctl->node == node) + return ctl; + } + } + + /* Step two, extract the node's name so we can construct a gadget. */ + err = dom_element_get_tag_name(node, &ds_name); + if (err == DOM_NO_ERR && ds_name != NULL) { + + /* Step three, attempt to work out what gadget to make */ + if (dom_string_caseless_lwc_isequal(ds_name, + corestring_lwc_button)) { + ctl = parse_button_element(forms, + (dom_html_button_element *) node); + } else if (dom_string_caseless_lwc_isequal(ds_name, + corestring_lwc_input)) { + ctl = parse_input_element(forms, + (dom_html_input_element *) node); + } else if (dom_string_caseless_lwc_isequal(ds_name, + corestring_lwc_textarea)) { + ctl = parse_textarea_element(forms, + (dom_html_text_area_element *) node); + } else if (dom_string_caseless_lwc_isequal(ds_name, + corestring_lwc_select)) { + ctl = parse_select_element(forms, + (dom_html_select_element *) node); + } + } + + /* If all else fails, fake gadget time */ + if (ctl == NULL) + ctl = invent_fake_gadget(node); + + if (ds_name != NULL) + dom_string_unref(ds_name); + + return ctl; +} diff --git a/content/handlers/html/html_css.c b/content/handlers/html/html_css.c deleted file mode 100644 index 23d51f1..0000000 --- a/content/handlers/html/html_css.c +++ /dev/null @@ -1,739 +0,0 @@ -/* - * Copyright 2013 Vincent Sanders <vince(a)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 - * Processing for html content css operations. - */ - -#include "utils/config.h" - -#define _GNU_SOURCE /* strcasestr needs this for string.h */ - -#include <assert.h> -#include <ctype.h> -#include <stdint.h> -#include <string.h> -#include <strings.h> -#include <stdlib.h> - -#include "utils/nsoption.h" -#include "utils/corestrings.h" -#include "utils/log.h" -#include "netsurf/misc.h" -#include "netsurf/content.h" -#include "content/hlcache.h" -#include "css/css.h" -#include "desktop/gui_internal.h" - -#include "html/html.h" -#include "html/html_internal.h" - -static nsurl *html_default_stylesheet_url; -static nsurl *html_adblock_stylesheet_url; -static nsurl *html_quirks_stylesheet_url; -static nsurl *html_user_stylesheet_url; - -static nserror css_error_to_nserror(css_error error) -{ - switch (error) { - case CSS_OK: - return NSERROR_OK; - - case CSS_NOMEM: - return NSERROR_NOMEM; - - case CSS_BADPARM: - return NSERROR_BAD_PARAMETER; - - case CSS_INVALID: - return NSERROR_INVALID; - - case CSS_FILENOTFOUND: - return NSERROR_NOT_FOUND; - - case CSS_NEEDDATA: - return NSERROR_NEED_DATA; - - case CSS_BADCHARSET: - return NSERROR_BAD_ENCODING; - - case CSS_EOF: - case CSS_IMPORTS_PENDING: - case CSS_PROPERTY_NOT_SET: - default: - break; - } - return NSERROR_CSS; -} - -/** - * Callback for fetchcache() for stylesheets. - */ - -static nserror -html_convert_css_callback(hlcache_handle *css, - const hlcache_event *event, - void *pw) -{ - html_content *parent = pw; - unsigned int i; - struct html_stylesheet *s; - - /* Find sheet */ - for (i = 0, s = parent->stylesheets; - i != parent->stylesheet_count; - i++, s++) { - if (s->sheet == css) - break; - } - - assert(i != parent->stylesheet_count); - - switch (event->type) { - - case CONTENT_MSG_DONE: - NSLOG(netsurf, INFO, "done stylesheet slot %d '%s'", i, - nsurl_access(hlcache_handle_get_url(css))); - parent->base.active--; - NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); - break; - - case CONTENT_MSG_ERROR: - NSLOG(netsurf, INFO, "stylesheet %s failed: %s", - nsurl_access(hlcache_handle_get_url(css)), - event->data.errordata.errormsg); - - hlcache_handle_release(css); - s->sheet = NULL; - parent->base.active--; - NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); - content_add_error(&parent->base, "?", 0); - break; - - case CONTENT_MSG_POINTER: - /* Really don't want this to continue after the switch */ - return NSERROR_OK; - - default: - break; - } - - if (html_can_begin_conversion(parent)) { - html_begin_conversion(parent); - } - - return NSERROR_OK; -} - -static nserror -html_stylesheet_from_domnode(html_content *c, - dom_node *node, - hlcache_handle **sheet) -{ - hlcache_child_context child; - dom_string *style; - nsurl *url; - dom_exception exc; - nserror error; - uint32_t key; - char urlbuf[64]; - - child.charset = c->encoding; - child.quirks = c->base.quirks; - - exc = dom_node_get_text_content(node, &style); - if ((exc != DOM_NO_ERR) || (style == NULL)) { - NSLOG(netsurf, INFO, "No text content"); - return NSERROR_OK; - } - - error = html_css_fetcher_add_item(style, c->base_url, &key); - if (error != NSERROR_OK) { - dom_string_unref(style); - return error; - } - - dom_string_unref(style); - - snprintf(urlbuf, sizeof(urlbuf), "x-ns-css:%u", key); - - error = nsurl_create(urlbuf, &url); - if (error != NSERROR_OK) { - return error; - } - - error = hlcache_handle_retrieve(url, 0, - content_get_url(&c->base), NULL, - html_convert_css_callback, c, &child, CONTENT_CSS, - sheet); - if (error != NSERROR_OK) { - nsurl_unref(url); - return error; - } - - nsurl_unref(url); - - c->base.active++; - NSLOG(netsurf, INFO, "%d fetches active", c->base.active); - - return NSERROR_OK; -} - -/** - * Process an inline stylesheet in the document. - * - * \param c content structure - * \param style xml node of style element - * \return true on success, false if an error occurred - */ - -static struct html_stylesheet * -html_create_style_element(html_content *c, dom_node *style) -{ - dom_string *val; - dom_exception exc; - struct html_stylesheet *stylesheets; - - /* type='text/css', or not present (invalid but common) */ - exc = dom_element_get_attribute(style, corestring_dom_type, &val); - if (exc == DOM_NO_ERR && val != NULL) { - if (!dom_string_caseless_lwc_isequal(val, - corestring_lwc_text_css)) { - dom_string_unref(val); - return NULL; - } - dom_string_unref(val); - } - - /* media contains 'screen' or 'all' or not present */ - exc = dom_element_get_attribute(style, corestring_dom_media, &val); - if (exc == DOM_NO_ERR && val != NULL) { - if (strcasestr(dom_string_data(val), "screen") == NULL && - strcasestr(dom_string_data(val), - "all") == NULL) { - dom_string_unref(val); - return NULL; - } - dom_string_unref(val); - } - - /* Extend array */ - stylesheets = realloc(c->stylesheets, - sizeof(struct html_stylesheet) * - (c->stylesheet_count + 1)); - if (stylesheets == NULL) { - - content_broadcast_error(&c->base, NSERROR_NOMEM, NULL); - return false; - - } - c->stylesheets = stylesheets; - - c->stylesheets[c->stylesheet_count].node = dom_node_ref(style); - c->stylesheets[c->stylesheet_count].sheet = NULL; - c->stylesheets[c->stylesheet_count].modified = false; - c->stylesheets[c->stylesheet_count].unused = false; - c->stylesheet_count++; - - return c->stylesheets + (c->stylesheet_count - 1); -} - -static bool html_css_process_modified_style(html_content *c, - struct html_stylesheet *s) -{ - hlcache_handle *sheet = NULL; - nserror error; - - error = html_stylesheet_from_domnode(c, s->node, &sheet); - if (error != NSERROR_OK) { - NSLOG(netsurf, INFO, "Failed to update sheet"); - content_broadcast_error(&c->base, error, NULL); - return false; - } - - if (sheet != NULL) { - NSLOG(netsurf, INFO, "Updating sheet %p with %p", s->sheet, - sheet); - - if (s->sheet != NULL) { - switch (content_get_status(s->sheet)) { - case CONTENT_STATUS_DONE: - break; - default: - hlcache_handle_abort(s->sheet); - c->base.active--; - NSLOG(netsurf, INFO, "%d fetches active", - c->base.active); - } - hlcache_handle_release(s->sheet); - } - s->sheet = sheet; - } - - s->modified = false; - - return true; -} - -static void html_css_process_modified_styles(void *pw) -{ - html_content *c = pw; - struct html_stylesheet *s; - unsigned int i; - bool all_done = true; - - for (i = 0, s = c->stylesheets; i != c->stylesheet_count; i++, s++) { - if (c->stylesheets[i].modified) { - all_done &= html_css_process_modified_style(c, s); - } - } - - /* If we failed to process any sheet, schedule a retry */ - if (all_done == false) { - guit->misc->schedule(1000, html_css_process_modified_styles, c); - } -} - -bool html_css_update_style(html_content *c, dom_node *style) -{ - unsigned int i; - struct html_stylesheet *s; - - /* Find sheet */ - for (i = 0, s = c->stylesheets; i != c->stylesheet_count; i++, s++) { - if (s->node == style) - break; - } - if (i == c->stylesheet_count) { - s = html_create_style_element(c, style); - } - if (s == NULL) { - NSLOG(netsurf, INFO, - "Could not find or create inline stylesheet for %p", - style); - return false; - } - - s->modified = true; - - guit->misc->schedule(0, html_css_process_modified_styles, c); - - return true; -} - -bool html_css_process_style(html_content *c, dom_node *node) -{ - unsigned int i; - dom_string *val; - dom_exception exc; - struct html_stylesheet *s; - - /* Find sheet */ - for (i = 0, s = c->stylesheets; i != c->stylesheet_count; i++, s++) { - if (s->node == node) - break; - } - - /* Should already exist */ - if (i == c->stylesheet_count) { - return false; - } - - exc = dom_element_get_attribute(node, corestring_dom_media, &val); - if (exc == DOM_NO_ERR && val != NULL) { - if (strcasestr(dom_string_data(val), "screen") == NULL && - strcasestr(dom_string_data(val), - "all") == NULL) { - s->unused = true; - } - dom_string_unref(val); - } - - return true; -} - -bool html_css_process_link(html_content *htmlc, dom_node *node) -{ - dom_string *rel, *type_attr, *media, *href; - struct html_stylesheet *stylesheets; - nsurl *joined; - dom_exception exc; - nserror ns_error; - hlcache_child_context child; - - /* rel=<space separated list, including 'stylesheet'> */ - exc = dom_element_get_attribute(node, corestring_dom_rel, &rel); - if (exc != DOM_NO_ERR || rel == NULL) - return true; - - if (strcasestr(dom_string_data(rel), "stylesheet") == 0) { - dom_string_unref(rel); - return true; - } else if (strcasestr(dom_string_data(rel), "alternate") != 0) { - /* Ignore alternate stylesheets */ - dom_string_unref(rel); - return true; - } - dom_string_unref(rel); - - /* type='text/css' or not present */ - exc = dom_element_get_attribute(node, corestring_dom_type, &type_attr); - if (exc == DOM_NO_ERR && type_attr != NULL) { - if (!dom_string_caseless_lwc_isequal(type_attr, - corestring_lwc_text_css)) { - dom_string_unref(type_attr); - return true; - } - dom_string_unref(type_attr); - } - - /* media contains 'screen' or 'all' or not present */ - exc = dom_element_get_attribute(node, corestring_dom_media, &media); - if (exc == DOM_NO_ERR && media != NULL) { - if (strcasestr(dom_string_data(media), "screen") == NULL && - strcasestr(dom_string_data(media), "all") == NULL) { - dom_string_unref(media); - return true; - } - dom_string_unref(media); - } - - /* href='...' */ - exc = dom_element_get_attribute(node, corestring_dom_href, &href); - if (exc != DOM_NO_ERR || href == NULL) - return true; - - /* TODO: only the first preferred stylesheets (ie. - * those with a title attribute) should be loaded - * (see HTML4 14.3) */ - - ns_error = nsurl_join(htmlc->base_url, dom_string_data(href), &joined); - if (ns_error != NSERROR_OK) { - dom_string_unref(href); - goto no_memory; - } - dom_string_unref(href); - - NSLOG(netsurf, INFO, "linked stylesheet %i '%s'", - htmlc->stylesheet_count, nsurl_access(joined)); - - /* extend stylesheets array to allow for new sheet */ - stylesheets = realloc(htmlc->stylesheets, - sizeof(struct html_stylesheet) * - (htmlc->stylesheet_count + 1)); - if (stylesheets == NULL) { - nsurl_unref(joined); - ns_error = NSERROR_NOMEM; - goto no_memory; - } - - htmlc->stylesheets = stylesheets; - htmlc->stylesheets[htmlc->stylesheet_count].node = NULL; - htmlc->stylesheets[htmlc->stylesheet_count].modified = false; - htmlc->stylesheets[htmlc->stylesheet_count].unused = false; - - /* start fetch */ - child.charset = htmlc->encoding; - child.quirks = htmlc->base.quirks; - - ns_error = hlcache_handle_retrieve(joined, 0, - content_get_url(&htmlc->base), - NULL, html_convert_css_callback, - htmlc, &child, CONTENT_CSS, - &htmlc->stylesheets[htmlc->stylesheet_count].sheet); - - nsurl_unref(joined); - - if (ns_error != NSERROR_OK) - goto no_memory; - - htmlc->stylesheet_count++; - - htmlc->base.active++; - NSLOG(netsurf, INFO, "%d fetches active", htmlc->base.active); - - return true; - -no_memory: - content_broadcast_error(&htmlc->base, ns_error, NULL); - return false; -} - -/* exported interface documented in html/html.h */ -struct html_stylesheet *html_get_stylesheets(hlcache_handle *h, unsigned int *n) -{ - html_content *c = (html_content *) hlcache_handle_get_content(h); - - assert(c != NULL); - assert(n != NULL); - - *n = c->stylesheet_count; - - return c->stylesheets; -} - -/* exported interface documented in html/html_internal.h */ -bool html_saw_insecure_stylesheets(html_content *html) -{ - struct html_stylesheet *s; - unsigned int i; - - for (i = 0, s = html->stylesheets; i < html->stylesheet_count; - i++, s++) { - if (s->sheet != NULL) { - if (content_saw_insecure_objects(s->sheet)) { - return true; - } - } - } - - return false; -} - -/* exported interface documented in html/html_internal.h */ -nserror html_css_free_stylesheets(html_content *html) -{ - unsigned int i; - - guit->misc->schedule(-1, html_css_process_modified_styles, html); - - for (i = 0; i != html->stylesheet_count; i++) { - if (html->stylesheets[i].sheet != NULL) { - hlcache_handle_release(html->stylesheets[i].sheet); - } - if (html->stylesheets[i].node != NULL) { - dom_node_unref(html->stylesheets[i].node); - } - } - free(html->stylesheets); - - return NSERROR_OK; -} - -/* exported interface documented in html/html_internal.h */ -nserror html_css_quirks_stylesheets(html_content *c) -{ - nserror ns_error = NSERROR_OK; - hlcache_child_context child; - - assert(c->stylesheets != NULL); - - if (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL) { - child.charset = c->encoding; - child.quirks = c->base.quirks; - - ns_error = hlcache_handle_retrieve(html_quirks_stylesheet_url, - 0, content_get_url(&c->base), NULL, - html_convert_css_callback, c, &child, - CONTENT_CSS, - &c->stylesheets[STYLESHEET_QUIRKS].sheet); - if (ns_error != NSERROR_OK) { - return ns_error; - } - - c->base.active++; - NSLOG(netsurf, INFO, "%d fetches active", c->base.active); - } - - return ns_error; -} - -/* exported interface documented in html/html_internal.h */ -nserror html_css_new_stylesheets(html_content *c) -{ - nserror ns_error; - hlcache_child_context child; - - if (c->stylesheets != NULL) { - return NSERROR_OK; /* already initialised */ - } - - /* stylesheet 0 is the base style sheet, - * stylesheet 1 is the quirks mode style sheet, - * stylesheet 2 is the adblocking stylesheet, - * stylesheet 3 is the user stylesheet */ - c->stylesheets = calloc(STYLESHEET_START, - sizeof(struct html_stylesheet)); - if (c->stylesheets == NULL) { - return NSERROR_NOMEM; - } - - c->stylesheets[STYLESHEET_BASE].sheet = NULL; - c->stylesheets[STYLESHEET_QUIRKS].sheet = NULL; - c->stylesheets[STYLESHEET_ADBLOCK].sheet = NULL; - c->stylesheets[STYLESHEET_USER].sheet = NULL; - c->stylesheet_count = STYLESHEET_START; - - child.charset = c->encoding; - child.quirks = c->base.quirks; - - ns_error = hlcache_handle_retrieve(html_default_stylesheet_url, 0, - content_get_url(&c->base), NULL, - html_convert_css_callback, c, &child, CONTENT_CSS, - &c->stylesheets[STYLESHEET_BASE].sheet); - if (ns_error != NSERROR_OK) { - return ns_error; - } - - c->base.active++; - NSLOG(netsurf, INFO, "%d fetches active", c->base.active); - - - if (nsoption_bool(block_advertisements)) { - ns_error = hlcache_handle_retrieve(html_adblock_stylesheet_url, - 0, content_get_url(&c->base), NULL, - html_convert_css_callback, - c, &child, CONTENT_CSS, - &c->stylesheets[STYLESHEET_ADBLOCK].sheet); - if (ns_error != NSERROR_OK) { - return ns_error; - } - - c->base.active++; - NSLOG(netsurf, INFO, "%d fetches active", c->base.active); - - } - - ns_error = hlcache_handle_retrieve(html_user_stylesheet_url, 0, - content_get_url(&c->base), NULL, - html_convert_css_callback, c, &child, CONTENT_CSS, - &c->stylesheets[STYLESHEET_USER].sheet); - if (ns_error != NSERROR_OK) { - return ns_error; - } - - c->base.active++; - NSLOG(netsurf, INFO, "%d fetches active", c->base.active); - - return ns_error; -} - -nserror -html_css_new_selection_context(html_content *c, css_select_ctx **ret_select_ctx) -{ - uint32_t i; - css_error css_ret; - css_select_ctx *select_ctx; - - /* check that the base stylesheet loaded; layout fails without it */ - if (c->stylesheets[STYLESHEET_BASE].sheet == NULL) { - return NSERROR_CSS_BASE; - } - - /* Create selection context */ - css_ret = css_select_ctx_create(&select_ctx); - if (css_ret != CSS_OK) { - return css_error_to_nserror(css_ret); - } - - /* Add sheets to it */ - for (i = STYLESHEET_BASE; i != c->stylesheet_count; i++) { - const struct html_stylesheet *hsheet = &c->stylesheets[i]; - css_stylesheet *sheet = NULL; - css_origin origin = CSS_ORIGIN_AUTHOR; - - /* Filter out stylesheets for non-screen media. */ - /* TODO: We should probably pass the sheet in anyway, and let - * libcss handle the filtering. - */ - if (hsheet->unused) { - continue; - } - - if (i < STYLESHEET_USER) { - origin = CSS_ORIGIN_UA; - } else if (i < STYLESHEET_START) { - origin = CSS_ORIGIN_USER; - } - - if (hsheet->sheet != NULL) { - sheet = nscss_get_stylesheet(hsheet->sheet); - } - - if (sheet != NULL) { - /* TODO: Pass the sheet's full media query, instead of - * "screen". - */ - css_ret = css_select_ctx_append_sheet(select_ctx, - sheet, - origin, - "screen"); - if (css_ret != CSS_OK) { - css_select_ctx_destroy(select_ctx); - return css_error_to_nserror(css_ret); - } - } - } - - /* return new selection context to caller */ - *ret_select_ctx = select_ctx; - return NSERROR_OK; -} - -nserror html_css_init(void) -{ - nserror error; - - error = html_css_fetcher_register(); - if (error != NSERROR_OK) - return error; - - error = nsurl_create("resource:default.css", - &html_default_stylesheet_url); - if (error != NSERROR_OK) - return error; - - error = nsurl_create("resource:adblock.css", - &html_adblock_stylesheet_url); - if (error != NSERROR_OK) - return error; - - error = nsurl_create("resource:quirks.css", - &html_quirks_stylesheet_url); - if (error != NSERROR_OK) - return error; - - error = nsurl_create("resource:user.css", - &html_user_stylesheet_url); - - return error; -} - -void html_css_fini(void) -{ - if (html_user_stylesheet_url != NULL) { - nsurl_unref(html_user_stylesheet_url); - html_user_stylesheet_url = NULL; - } - - if (html_quirks_stylesheet_url != NULL) { - nsurl_unref(html_quirks_stylesheet_url); - html_quirks_stylesheet_url = NULL; - } - - if (html_adblock_stylesheet_url != NULL) { - nsurl_unref(html_adblock_stylesheet_url); - html_adblock_stylesheet_url = NULL; - } - - if (html_default_stylesheet_url != NULL) { - nsurl_unref(html_default_stylesheet_url); - html_default_stylesheet_url = NULL; - } -} diff --git a/content/handlers/html/html_css_fetcher.c b/content/handlers/html/html_css_fetcher.c deleted file mode 100644 index ae20879..0000000 --- a/content/handlers/html/html_css_fetcher.c +++ /dev/null @@ -1,320 +0,0 @@ -/* - * Copyright 2008 Rob Kendrick <rjek(a)netsurf-browser.org> - * Copyright 2013 John-Mark Bell <jmb(a)netsurf-browser.org> - * - * This file is part of NetSurf. - * - * 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 - * HTML fetcher for CSS objects - */ - -#include <assert.h> -#include <stdbool.h> -#include <stdlib.h> -#include <string.h> -#include <dom/dom.h> -#include <libwapcaplet/libwapcaplet.h> - -#include "netsurf/inttypes.h" -#include "utils/config.h" -#include "utils/corestrings.h" -#include "utils/log.h" -#include "utils/ring.h" -#include "utils/nsurl.h" -#include "utils/utils.h" -#include "content/fetch.h" -#include "content/fetchers.h" - -#include "html/html_internal.h" - -typedef struct html_css_fetcher_item { - uint32_t key; - dom_string *data; - nsurl *base_url; - - struct html_css_fetcher_item *r_next, *r_prev; -} html_css_fetcher_item; - -typedef struct html_css_fetcher_context { - struct fetch *parent_fetch; - - nsurl *url; - html_css_fetcher_item *item; - - bool aborted; - bool locked; - - struct html_css_fetcher_context *r_next, *r_prev; -} html_css_fetcher_context; - -static uint32_t current_key = 0; -static html_css_fetcher_item *items = NULL; -static html_css_fetcher_context *ring = NULL; - -static bool html_css_fetcher_initialise(lwc_string *scheme) -{ - NSLOG(netsurf, INFO, "html_css_fetcher_initialise called for %s", - lwc_string_data(scheme)); - return true; -} - -static void html_css_fetcher_finalise(lwc_string *scheme) -{ - NSLOG(netsurf, INFO, "html_css_fetcher_finalise called for %s", - lwc_string_data(scheme)); -} - -static bool html_css_fetcher_can_fetch(const nsurl *url) -{ - return true; -} - -static void *html_css_fetcher_setup(struct fetch *parent_fetch, nsurl *url, - bool only_2xx, bool downgrade_tls, const char *post_urlenc, - const struct fetch_multipart_data *post_multipart, - const char **headers) -{ - html_css_fetcher_context *ctx; - lwc_string *path; - uint32_t key; - html_css_fetcher_item *item, *found = NULL; - - /* format of a x-ns-css URL is: - * x-ns-url:<key> - * Where key is an unsigned 32bit integer - */ - - path = nsurl_get_component(url, NSURL_PATH); - /* The path must exist */ - if (path == NULL) { - return NULL; - } - - key = strtoul(lwc_string_data(path), NULL, 10); - - lwc_string_unref(path); - - /* There must be at least one item */ - if (items == NULL) { - return NULL; - } - - item = items; - do { - if (item->key == key) { - found = item; - break; - } - - item = item->r_next; - } while (item != items); - - /* We must have found the item */ - if (found == NULL) { - return NULL; - } - - ctx = calloc(1, sizeof(*ctx)); - if (ctx == NULL) - return NULL; - - ctx->parent_fetch = parent_fetch; - ctx->url = nsurl_ref(url); - ctx->item = found; - - RING_INSERT(ring, ctx); - - return ctx; -} - -static bool html_css_fetcher_start(void *ctx) -{ - return true; -} - -static void html_css_fetcher_free(void *ctx) -{ - html_css_fetcher_context *c = ctx; - - nsurl_unref(c->url); - if (c->item != NULL) { - nsurl_unref(c->item->base_url); - dom_string_unref(c->item->data); - RING_REMOVE(items, c->item); - free(c->item); - } - RING_REMOVE(ring, c); - free(ctx); -} - -static void html_css_fetcher_abort(void *ctx) -{ - html_css_fetcher_context *c = ctx; - - /* To avoid the poll loop having to deal with the fetch context - * disappearing from under it, we simply flag the abort here. - * The poll loop itself will perform the appropriate cleanup. - */ - c->aborted = true; -} - -static void html_css_fetcher_send_callback(const fetch_msg *msg, - html_css_fetcher_context *c) -{ - c->locked = true; - fetch_send_callback(msg, c->parent_fetch); - c->locked = false; -} - -static void html_css_fetcher_poll(lwc_string *scheme) -{ - fetch_msg msg; - html_css_fetcher_context *c, *next; - - if (ring == NULL) return; - - /* Iterate over ring, processing each pending fetch */ - c = ring; - do { - /* Ignore fetches that have been flagged as locked. - * This allows safe re-entrant calls to this function. - * Re-entrancy can occur if, as a result of a callback, - * the interested party causes fetch_poll() to be called - * again. - */ - if (c->locked == true) { - next = c->r_next; - continue; - } - - /* Only process non-aborted fetches */ - if (c->aborted) { - /* Nothing to do */ - assert(c->locked == false); - } else if (c->item != NULL) { - char header[4096]; - - fetch_set_http_code(c->parent_fetch, 200); - - /* Any callback can result in the fetch being aborted. - * Therefore, we _must_ check for this after _every_ - * call to html_css_fetcher_send_callback(). - */ - snprintf(header, sizeof header, - "Content-Type: text/css; charset=utf-8"); - msg.type = FETCH_HEADER; - msg.data.header_or_data.buf = (const uint8_t *) header; - msg.data.header_or_data.len = strlen(header); - html_css_fetcher_send_callback(&msg, c); - - if (c->aborted == false) { - snprintf(header, sizeof header, - "Content-Length: %"PRIsizet, - dom_string_byte_length(c->item->data)); - msg.type = FETCH_HEADER; - msg.data.header_or_data.buf = - (const uint8_t *) header; - msg.data.header_or_data.len = strlen(header); - html_css_fetcher_send_callback(&msg, c); - } - - if (c->aborted == false) { - snprintf(header, sizeof header, - "X-NS-Base: %.*s", - (int) nsurl_length(c->item->base_url), - nsurl_access(c->item->base_url)); - msg.type = FETCH_HEADER; - msg.data.header_or_data.buf = - (const uint8_t *) header; - msg.data.header_or_data.len = strlen(header); - html_css_fetcher_send_callback(&msg, c); - } - - if (c->aborted == false) { - msg.type = FETCH_DATA; - msg.data.header_or_data.buf = - (const uint8_t *) - dom_string_data(c->item->data); - msg.data.header_or_data.len = - dom_string_byte_length(c->item->data); - html_css_fetcher_send_callback(&msg, c); - } - - if (c->aborted == false) { - msg.type = FETCH_FINISHED; - html_css_fetcher_send_callback(&msg, c); - } - } else { - NSLOG(netsurf, INFO, "Processing of %s failed!", - nsurl_access(c->url)); - - /* Ensure that we're unlocked here. If we aren't, - * then html_css_fetcher_process() is broken. - */ - assert(c->locked == false); - } - - /* Compute next fetch item at the last possible moment as - * processing this item may have added to the ring. - */ - next = c->r_next; - - fetch_remove_from_queues(c->parent_fetch); - fetch_free(c->parent_fetch); - - /* Advance to next ring entry, exiting if we've reached - * the start of the ring or the ring has become empty - */ - } while ( (c = next) != ring && ring != NULL); -} - -/* exported interface documented in html_internal.h */ -nserror html_css_fetcher_register(void) -{ - const struct fetcher_operation_table html_css_fetcher_ops = { - .initialise = html_css_fetcher_initialise, - .acceptable = html_css_fetcher_can_fetch, - .setup = html_css_fetcher_setup, - .start = html_css_fetcher_start, - .abort = html_css_fetcher_abort, - .free = html_css_fetcher_free, - .poll = html_css_fetcher_poll, - .finalise = html_css_fetcher_finalise - }; - - return fetcher_add(lwc_string_ref(corestring_lwc_x_ns_css), - &html_css_fetcher_ops); -} - -/* exported interface documented in html_internal.h */ -nserror -html_css_fetcher_add_item(dom_string *data, nsurl *base_url, uint32_t *key) -{ - html_css_fetcher_item *item = malloc(sizeof(*item)); - - if (item == NULL) { - return NSERROR_NOMEM; - } - - *key = item->key = current_key++; - item->data = dom_string_ref(data); - item->base_url = nsurl_ref(base_url); - - RING_INSERT(items, item); - - return NSERROR_OK; -} diff --git a/content/handlers/html/html_forms.c b/content/handlers/html/html_forms.c deleted file mode 100644 index 896263d..0000000 --- a/content/handlers/html/html_forms.c +++ /dev/null @@ -1,590 +0,0 @@ -/* - * Copyright 2011 Vincent Sanders <vince(a)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 - * HTML form handling implementation - */ - -#include "utils/config.h" -#include "utils/corestrings.h" -#include "utils/log.h" - -#include "html/form_internal.h" -#include "html/html_internal.h" - -/** - * process form element from dom - */ -static struct form * -parse_form_element(const char *docenc, dom_node *node) -{ - dom_string *ds_action = NULL; - dom_string *ds_charset = NULL; - dom_string *ds_target = NULL; - dom_string *ds_method = NULL; - dom_string *ds_enctype = NULL; - char *action = NULL, *charset = NULL, *target = NULL; - form_method method; - dom_html_form_element *formele = (dom_html_form_element *)(node); - struct form * ret = NULL; - - /* Retrieve the attributes from the node */ - if (dom_html_form_element_get_action(formele, - &ds_action) != DOM_NO_ERR) - goto out; - - if (dom_html_form_element_get_accept_charset(formele, - &ds_charset) != DOM_NO_ERR) - goto out; - - if (dom_html_form_element_get_target(formele, - &ds_target) != DOM_NO_ERR) - goto out; - - if (dom_html_form_element_get_method(formele, - &ds_method) != DOM_NO_ERR) - goto out; - - if (dom_html_form_element_get_enctype(formele, - &ds_enctype) != DOM_NO_ERR) - goto out; - - /* Extract the plain attributes ready for use. We have to do this - * because we cannot guarantee that the dom_strings are NULL terminated - * and thus we copy them. - */ - if (ds_action != NULL) - action = strndup(dom_string_data(ds_action), - dom_string_byte_length(ds_action)); - - if (ds_charset != NULL) - charset = strndup(dom_string_data(ds_charset), - dom_string_byte_length(ds_charset)); - - if (ds_target != NULL) - target = strndup(dom_string_data(ds_target), - dom_string_byte_length(ds_target)); - - /* Determine the method */ - method = method_GET; - if (ds_method != NULL) { - if (dom_string_caseless_lwc_isequal(ds_method, - corestring_lwc_post)) { - method = method_POST_URLENC; - if (ds_enctype != NULL) { - if (dom_string_caseless_lwc_isequal(ds_enctype, - corestring_lwc_multipart_form_data)) { - - method = method_POST_MULTIPART; - } - } - } - } - - /* Construct the form object */ - ret = form_new(node, action, target, method, charset, docenc); - -out: - if (ds_action != NULL) - dom_string_unref(ds_action); - if (ds_charset != NULL) - dom_string_unref(ds_charset); - if (ds_target != NULL) - dom_string_unref(ds_target); - if (ds_method != NULL) - dom_string_unref(ds_method); - if (ds_enctype != NULL) - dom_string_unref(ds_enctype); - if (action != NULL) - free(action); - if (charset != NULL) - free(charset); - if (target != NULL) - free(target); - return ret; -} - -/* documented in html_internal.h */ -struct form *html_forms_get_forms(const char *docenc, dom_html_document *doc) -{ - dom_html_collection *forms; - struct form *ret = NULL, *newf; - dom_node *node; - unsigned long n; - uint32_t nforms; - - if (doc == NULL) - return NULL; - - /* Attempt to build a set of all the forms */ - if (dom_html_document_get_forms(doc, &forms) != DOM_NO_ERR) - return NULL; - - /* Count the number of forms so we can iterate */ - if (dom_html_collection_get_length(forms, &nforms) != DOM_NO_ERR) - goto out; - - /* Iterate the forms collection, making form structs for returning */ - for (n = 0; n < nforms; ++n) { - if (dom_html_collection_item(forms, n, &node) != DOM_NO_ERR) { - goto out; - } - newf = parse_form_element(docenc, node); - dom_node_unref(node); - if (newf == NULL) { - goto err; - } - newf->prev = ret; - ret = newf; - } - - /* All went well */ - goto out; -err: - while (ret != NULL) { - struct form *prev = ret->prev; - /* Destroy ret */ - free(ret); - ret = prev; - } -out: - /* Finished with the collection, return it */ - dom_html_collection_unref(forms); - - return ret; -} - -static struct form * -find_form(struct form *forms, dom_html_form_element *form) -{ - while (forms != NULL) { - if (forms->node == form) - break; - forms = forms->prev; - } - - return forms; -} - -static struct form_control * -parse_button_element(struct form *forms, dom_html_button_element *button) -{ - struct form_control *control = NULL; - dom_exception err; - dom_html_form_element *form = NULL; - dom_string *ds_type = NULL; - dom_string *ds_value = NULL; - dom_string *ds_name = NULL; - - err = dom_html_button_element_get_form(button, &form); - if (err != DOM_NO_ERR) - goto out; - - err = dom_html_button_element_get_type(button, &ds_type); - if (err != DOM_NO_ERR) - goto out; - - if (ds_type == NULL) { - control = form_new_control(button, GADGET_SUBMIT); - } else { - if (dom_string_caseless_lwc_isequal(ds_type, - corestring_lwc_submit)) { - control = form_new_control(button, GADGET_SUBMIT); - } else if (dom_string_caseless_lwc_isequal(ds_type, - corestring_lwc_reset)) { - control = form_new_control(button, GADGET_RESET); - } else { - control = form_new_control(button, GADGET_BUTTON); - } - } - - if (control == NULL) - goto out; - - err = dom_html_button_element_get_value(button, &ds_value); - if (err != DOM_NO_ERR) - goto out; - err = dom_html_button_element_get_name(button, &ds_name); - if (err != DOM_NO_ERR) - goto out; - - if (ds_value != NULL) { - control->value = strndup( - dom_string_data(ds_value), - dom_string_byte_length(ds_value)); - - if (control->value == NULL) { - form_free_control(control); - control = NULL; - goto out; - } - } - - if (ds_name != NULL) { - control->name = strndup( - dom_string_data(ds_name), - dom_string_byte_length(ds_name)); - - if (control->name == NULL) { - form_free_control(control); - control = NULL; - goto out; - } - } - - if (form != NULL && control != NULL) - form_add_control(find_form(forms, form), control); - -out: - if (form != NULL) - dom_node_unref(form); - if (ds_type != NULL) - dom_string_unref(ds_type); - if (ds_value != NULL) - dom_string_unref(ds_value); - if (ds_name != NULL) - dom_string_unref(ds_name); - - return control; -} - -static struct form_control * -parse_input_element(struct form *forms, dom_html_input_element *input) -{ - struct form_control *control = NULL; - dom_html_form_element *form = NULL; - dom_string *ds_type = NULL; - dom_string *ds_name = NULL; - dom_string *ds_value = NULL; - - char *name = NULL; - - if (dom_html_input_element_get_form(input, &form) != DOM_NO_ERR) - goto out; - - if (dom_html_input_element_get_type(input, &ds_type) != DOM_NO_ERR) - goto out; - - if (dom_html_input_element_get_name(input, &ds_name) != DOM_NO_ERR) - goto out; - - if (ds_name != NULL) - name = strndup(dom_string_data(ds_name), - dom_string_byte_length(ds_name)); - - if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, - corestring_lwc_password)) { - control = form_new_control(input, GADGET_PASSWORD); - } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, - corestring_lwc_file)) { - control = form_new_control(input, GADGET_FILE); - } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, - corestring_lwc_hidden)) { - control = form_new_control(input, GADGET_HIDDEN); - } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, - corestring_lwc_checkbox)) { - control = form_new_control(input, GADGET_CHECKBOX); - } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, - corestring_lwc_radio)) { - control = form_new_control(input, GADGET_RADIO); - } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, - corestring_lwc_submit)) { - control = form_new_control(input, GADGET_SUBMIT); - } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, - corestring_lwc_reset)) { - control = form_new_control(input, GADGET_RESET); - } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, - corestring_lwc_button)) { - control = form_new_control(input, GADGET_BUTTON); - } else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type, - corestring_lwc_image)) { - control = form_new_control(input, GADGET_IMAGE); - } else { - control = form_new_control(input, GADGET_TEXTBOX); - } - - if (control == NULL) - goto out; - - if (name != NULL) { - /* Hand the name string over */ - control->name = name; - name = NULL; - } - - if (control->type == GADGET_CHECKBOX || control->type == GADGET_RADIO) { - bool selected; - if (dom_html_input_element_get_checked( - input, &selected) == DOM_NO_ERR) { - control->selected = selected; - } - } - - if (control->type == GADGET_PASSWORD || - control->type == GADGET_TEXTBOX) { - int32_t maxlength; - if (dom_html_input_element_get_max_length( - input, &maxlength) != DOM_NO_ERR) { - maxlength = -1; - } - - if (maxlength >= 0) { - /* Got valid maxlength */ - control->maxlength = maxlength; - } else { - /* Input has no maxlength attr, or - * dom_html_input_element_get_max_length failed. - * - * Set it to something insane. */ - control->maxlength = UINT_MAX; - } - } - - if (control->type != GADGET_FILE && control->type != GADGET_IMAGE) { - if (dom_html_input_element_get_value( - input, &ds_value) == DOM_NO_ERR) { - if (ds_value != NULL) { - control->value = strndup( - dom_string_data(ds_value), - dom_string_byte_length(ds_value)); - if (control->value == NULL) { - form_free_control(control); - control = NULL; - goto out; - } - control->length = strlen(control->value); - } - } - - if (control->type == GADGET_TEXTBOX || - control->type == GADGET_PASSWORD) { - if (control->value == NULL) { - control->value = strdup(""); - if (control->value == NULL) { - form_free_control(control); - control = NULL; - goto out; - } - - control->length = 0; - } - - control->initial_value = strdup(control->value); - if (control->initial_value == NULL) { - form_free_control(control); - control = NULL; - goto out; - } - - control->last_synced_value = strdup(control->value); - if (control->last_synced_value == NULL) { - form_free_control(control); - control = NULL; - goto out; - } - - control->node_value = dom_string_ref(ds_value); - } - /* Force the gadget and DOM to be in sync */ - form_gadget_sync_with_dom(control); - } - - if (form != NULL && control != NULL) - form_add_control(find_form(forms, form), control); - -out: - if (form != NULL) - dom_node_unref(form); - if (ds_type != NULL) - dom_string_unref(ds_type); - if (ds_name != NULL) - dom_string_unref(ds_name); - if (ds_value != NULL) - dom_string_unref(ds_value); - - if (name != NULL) - free(name); - - return control; -} - -static struct form_control * -parse_textarea_element(struct form *forms, dom_html_text_area_element *ta) -{ - struct form_control *control = NULL; - dom_html_form_element *form = NULL; - dom_string *ds_name = NULL; - - char *name = NULL; - - if (dom_html_text_area_element_get_form(ta, &form) != DOM_NO_ERR) - goto out; - - if (dom_html_text_area_element_get_name(ta, &ds_name) != DOM_NO_ERR) - goto out; - - if (ds_name != NULL) - name = strndup(dom_string_data(ds_name), - dom_string_byte_length(ds_name)); - - control = form_new_control(ta, GADGET_TEXTAREA); - - if (control == NULL) - goto out; - - if (name != NULL) { - /* Hand the name string over */ - control->name = name; - name = NULL; - } - - if (form != NULL && control != NULL) - form_add_control(find_form(forms, form), control); - -out: - if (form != NULL) - dom_node_unref(form); - if (ds_name != NULL) - dom_string_unref(ds_name); - - if (name != NULL) - free(name); - - - return control; -} - -static struct form_control * -parse_select_element(struct form *forms, dom_html_select_element *select) -{ - struct form_control *control = NULL; - dom_html_form_element *form = NULL; - dom_string *ds_name = NULL; - - char *name = NULL; - - if (dom_html_select_element_get_form(select, &form) != DOM_NO_ERR) - goto out; - - if (dom_html_select_element_get_name(select, &ds_name) != DOM_NO_ERR) - goto out; - - if (ds_name != NULL) - name = strndup(dom_string_data(ds_name), - dom_string_byte_length(ds_name)); - - control = form_new_control(select, GADGET_SELECT); - - if (control == NULL) - goto out; - - if (name != NULL) { - /* Hand the name string over */ - control->name = name; - name = NULL; - } - - dom_html_select_element_get_multiple(select, - &(control->data.select.multiple)); - - if (form != NULL && control != NULL) - form_add_control(find_form(forms, form), control); - -out: - if (form != NULL) - dom_node_unref(form); - if (ds_name != NULL) - dom_string_unref(ds_name); - - if (name != NULL) - free(name); - - - return control; -} - - -static struct form_control * -invent_fake_gadget(dom_node *node) -{ - struct form_control *ctl = form_new_control(node, GADGET_HIDDEN); - if (ctl != NULL) { - ctl->value = strdup(""); - ctl->initial_value = strdup(""); - ctl->name = strdup("foo"); - - if (ctl->value == NULL || ctl->initial_value == NULL || - ctl->name == NULL) { - form_free_control(ctl); - ctl = NULL; - } - } - return ctl; -} - -/* documented in html_internal.h */ -struct form_control *html_forms_get_control_for_node(struct form *forms, - dom_node *node) -{ - struct form *f; - struct form_control *ctl = NULL; - dom_exception err; - dom_string *ds_name = NULL; - - /* Step one, see if we already have a control */ - for (f = forms; f != NULL; f = f->prev) { - for (ctl = f->controls; ctl != NULL; ctl = ctl->next) { - if (ctl->node == node) - return ctl; - } - } - - /* Step two, extract the node's name so we can construct a gadget. */ - err = dom_element_get_tag_name(node, &ds_name); - if (err == DOM_NO_ERR && ds_name != NULL) { - - /* Step three, attempt to work out what gadget to make */ - if (dom_string_caseless_lwc_isequal(ds_name, - corestring_lwc_button)) { - ctl = parse_button_element(forms, - (dom_html_button_element *) node); - } else if (dom_string_caseless_lwc_isequal(ds_name, - corestring_lwc_input)) { - ctl = parse_input_element(forms, - (dom_html_input_element *) node); - } else if (dom_string_caseless_lwc_isequal(ds_name, - corestring_lwc_textarea)) { - ctl = parse_textarea_element(forms, - (dom_html_text_area_element *) node); - } else if (dom_string_caseless_lwc_isequal(ds_name, - corestring_lwc_select)) { - ctl = parse_select_element(forms, - (dom_html_select_element *) node); - } - } - - /* If all else fails, fake gadget time */ - if (ctl == NULL) - ctl = invent_fake_gadget(node); - - if (ds_name != NULL) - dom_string_unref(ds_name); - - return ctl; -} diff --git a/content/handlers/html/html_object.c b/content/handlers/html/html_object.c deleted file mode 100644 index 587c487..0000000 --- a/content/handlers/html/html_object.c +++ /dev/null @@ -1,729 +0,0 @@ -/* - * Copyright 2013 Vincent Sanders <vince(a)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 - * Processing for html content object operations. - */ - -#include <assert.h> -#include <ctype.h> -#include <stdint.h> -#include <string.h> -#include <strings.h> -#include <stdlib.h> -#include <nsutils/time.h> - -#include "utils/corestrings.h" -#include "utils/config.h" -#include "utils/log.h" -#include "utils/nsoption.h" -#include "netsurf/content.h" -#include "netsurf/misc.h" -#include "content/hlcache.h" -#include "css/utils.h" -#include "desktop/scrollbar.h" -#include "desktop/gui_internal.h" - -#include "html/html.h" -#include "html/box.h" -#include "html/box_inspect.h" -#include "html/html_internal.h" - -/* break reference loop */ -static void html_object_refresh(void *p); - -/** - * Retrieve objects used by HTML document - * - * \param h Content to retrieve objects from - * \param n Pointer to location to receive number of objects - * \return Pointer to list of objects - */ -struct content_html_object *html_get_objects(hlcache_handle *h, unsigned int *n) -{ - html_content *c = (html_content *) hlcache_handle_get_content(h); - - assert(c != NULL); - assert(n != NULL); - - *n = c->num_objects; - - return c->object_list; -} - -/** - * Handle object fetching or loading failure. - * - * \param box box containing object which failed to load - * \param content document of type CONTENT_HTML - * \param background the object was the background image for the box - */ - -static void -html_object_failed(struct box *box, html_content *content, bool background) -{ - /* Nothing to do */ - return; -} - -/** - * Update a box whose content has completed rendering. - */ - -static void -html_object_done(struct box *box, - hlcache_handle *object, - bool background) -{ - struct box *b; - - if (background) { - box->background = object; - return; - } - - box->object = object; - - /* Normalise the box type, now it has been replaced. */ - switch (box->type) { - case BOX_TABLE: - box->type = BOX_BLOCK; - break; - default: - /* TODO: Any other box types need mapping? */ - break; - } - - if (!(box->flags & REPLACE_DIM)) { - /* invalidate parent min, max widths */ - for (b = box; b; b = b->parent) - b->max_width = UNKNOWN_MAX_WIDTH; - - /* delete any clones of this box */ - while (box->next && (box->next->flags & CLONE)) { - /* box_free_box(box->next); */ - box->next = box->next->next; - } - } -} - -/** - * Callback for hlcache_handle_retrieve() for objects. - */ - -static nserror -html_object_callback(hlcache_handle *object, - const hlcache_event *event, - void *pw) -{ - struct content_html_object *o = pw; - html_content *c = (html_content *) o->parent; - int x, y; - struct box *box; - - box = o->box; - if (box == NULL && event->type != CONTENT_MSG_ERROR) { - return NSERROR_OK; - } - - switch (event->type) { - case CONTENT_MSG_LOADING: - if (c->base.status != CONTENT_STATUS_LOADING && c->bw != NULL) - content_open(object, - c->bw, &c->base, - box->object_params); - break; - - case CONTENT_MSG_READY: - if (content_can_reformat(object)) { - /* TODO: avoid knowledge of box internals here */ - content_reformat(object, false, - box->max_width != UNKNOWN_MAX_WIDTH ? - box->width : 0, - box->max_width != UNKNOWN_MAX_WIDTH ? - box->height : 0); - - /* Adjust parent content for new object size */ - html_object_done(box, object, o->background); - if (c->base.status == CONTENT_STATUS_READY || - c->base.status == CONTENT_STATUS_DONE) - content__reformat(&c->base, false, - c->base.available_width, - c->base.available_height); - } - break; - - case CONTENT_MSG_DONE: - c->base.active--; - NSLOG(netsurf, INFO, "%d fetches active", c->base.active); - - html_object_done(box, object, o->background); - - if (c->base.status != CONTENT_STATUS_LOADING && - box->flags & REPLACE_DIM) { - union content_msg_data data; - - if (c->had_initial_layout == false) { - break; - } - - if (!box_visible(box)) - break; - - box_coords(box, &x, &y); - - data.redraw.x = x + box->padding[LEFT]; - data.redraw.y = y + box->padding[TOP]; - data.redraw.width = box->width; - data.redraw.height = box->height; - - content_broadcast(&c->base, CONTENT_MSG_REDRAW, &data); - } - break; - - case CONTENT_MSG_ERROR: - hlcache_handle_release(object); - - o->content = NULL; - - if (box != NULL) { - c->base.active--; - NSLOG(netsurf, INFO, "%d fetches active", - c->base.active); - - content_add_error(&c->base, "?", 0); - html_object_failed(box, c, o->background); - } - break; - - case CONTENT_MSG_REDRAW: - if (c->base.status != CONTENT_STATUS_LOADING) { - union content_msg_data data = event->data; - - if (c->had_initial_layout == false) { - break; - } - - if (!box_visible(box)) - break; - - box_coords(box, &x, &y); - - if (object == box->background) { - /* Redraw request is for background */ - css_fixed hpos = 0, vpos = 0; - css_unit hunit = CSS_UNIT_PX; - css_unit vunit = CSS_UNIT_PX; - int width = box->padding[LEFT] + box->width + - box->padding[RIGHT]; - int height = box->padding[TOP] + box->height + - box->padding[BOTTOM]; - int t, h, l, w; - - /* Need to know background-position */ - css_computed_background_position(box->style, - &hpos, &hunit, &vpos, &vunit); - - w = content_get_width(box->background); - if (hunit == CSS_UNIT_PCT) { - l = (width - w) * hpos / INTTOFIX(100); - } else { - l = FIXTOINT(nscss_len2px(&c->len_ctx, - hpos, hunit, - box->style)); - } - - h = content_get_height(box->background); - if (vunit == CSS_UNIT_PCT) { - t = (height - h) * vpos / INTTOFIX(100); - } else { - t = FIXTOINT(nscss_len2px(&c->len_ctx, - vpos, vunit, - box->style)); - } - - /* Redraw area depends on background-repeat */ - switch (css_computed_background_repeat( - box->style)) { - case CSS_BACKGROUND_REPEAT_REPEAT: - data.redraw.x = 0; - data.redraw.y = 0; - data.redraw.width = box->width; - data.redraw.height = box->height; - break; - - case CSS_BACKGROUND_REPEAT_REPEAT_X: - data.redraw.x = 0; - data.redraw.y += t; - data.redraw.width = box->width; - break; - - case CSS_BACKGROUND_REPEAT_REPEAT_Y: - data.redraw.x += l; - data.redraw.y = 0; - data.redraw.height = box->height; - break; - - case CSS_BACKGROUND_REPEAT_NO_REPEAT: - data.redraw.x += l; - data.redraw.y += t; - break; - - default: - break; - } - - /* Add offset to box */ - data.redraw.x += x; - data.redraw.y += y; - - } else { - /* Non-background case */ - int w = content_get_width(object); - int h = content_get_height(object); - - if (w != 0 && box->width != w) { - /* Not showing image at intrinsic - * width; need to scale the redraw - * request area. */ - data.redraw.x = data.redraw.x * - box->width / w; - data.redraw.width = - data.redraw.width * - box->width / w; - } - - if (h != 0 && box->height != w) { - /* Not showing image at intrinsic - * height; need to scale the redraw - * request area. */ - data.redraw.y = data.redraw.y * - box->height / h; - data.redraw.height = - data.redraw.height * - box->height / h; - } - - data.redraw.x += x + box->padding[LEFT]; - data.redraw.y += y + box->padding[TOP]; - } - - content_broadcast(&c->base, CONTENT_MSG_REDRAW, &data); - } - break; - - case CONTENT_MSG_REFRESH: - if (content_get_type(object) == CONTENT_HTML) { - /* only for HTML objects */ - guit->misc->schedule(event->data.delay * 1000, - html_object_refresh, o); - } - - break; - - case CONTENT_MSG_LINK: - /* Don't care about favicons that aren't on top level content */ - break; - - case CONTENT_MSG_GETTHREAD: - /* Objects don't have JS threads */ - *(event->data.jsthread) = NULL; - break; - - case CONTENT_MSG_GETDIMS: - *(event->data.getdims.viewport_width) = - content__get_width(&c->base); - *(event->data.getdims.viewport_height) = - content__get_height(&c->base); - break; - - case CONTENT_MSG_SCROLL: - if (box->scroll_x != NULL) - scrollbar_set(box->scroll_x, event->data.scroll.x0, - false); - if (box->scroll_y != NULL) - scrollbar_set(box->scroll_y, event->data.scroll.y0, - false); - break; - - case CONTENT_MSG_DRAGSAVE: - { - union content_msg_data msg_data; - if (event->data.dragsave.content == NULL) - msg_data.dragsave.content = object; - else - msg_data.dragsave.content = - event->data.dragsave.content; - - content_broadcast(&c->base, CONTENT_MSG_DRAGSAVE, &msg_data); - } - break; - - case CONTENT_MSG_SAVELINK: - case CONTENT_MSG_POINTER: - case CONTENT_MSG_SELECTMENU: - case CONTENT_MSG_GADGETCLICK: - /* These messages are for browser window layer. - * we're not interested, so pass them on. */ - content_broadcast(&c->base, event->type, &event->data); - break; - - case CONTENT_MSG_CARET: - { - union html_focus_owner focus_owner; - focus_owner.content = box; - - switch (event->data.caret.type) { - case CONTENT_CARET_REMOVE: - case CONTENT_CARET_HIDE: - html_set_focus(c, HTML_FOCUS_CONTENT, focus_owner, - true, 0, 0, 0, NULL); - break; - case CONTENT_CARET_SET_POS: - html_set_focus(c, HTML_FOCUS_CONTENT, focus_owner, - false, event->data.caret.pos.x, - event->data.caret.pos.y, - event->data.caret.pos.height, - event->data.caret.pos.clip); - break; - } - } - break; - - case CONTENT_MSG_DRAG: - { - html_drag_type drag_type = HTML_DRAG_NONE; - union html_drag_owner drag_owner; - drag_owner.content = box; - - switch (event->data.drag.type) { - case CONTENT_DRAG_NONE: - drag_type = HTML_DRAG_NONE; - drag_owner.no_owner = true; - break; - case CONTENT_DRAG_SCROLL: - drag_type = HTML_DRAG_CONTENT_SCROLL; - break; - case CONTENT_DRAG_SELECTION: - drag_type = HTML_DRAG_CONTENT_SELECTION; - break; - } - html_set_drag_type(c, drag_type, drag_owner, - event->data.drag.rect); - } - break; - - case CONTENT_MSG_SELECTION: - { - html_selection_type sel_type; - union html_selection_owner sel_owner; - - if (event->data.selection.selection) { - sel_type = HTML_SELECTION_CONTENT; - sel_owner.content = box; - } else { - sel_type = HTML_SELECTION_NONE; - sel_owner.none = true; - } - html_set_selection(c, sel_type, sel_owner, - event->data.selection.read_only); - } - break; - - default: - break; - } - - if (c->base.status == CONTENT_STATUS_READY && - c->base.active == 0 && - (event->type == CONTENT_MSG_LOADING || - event->type == CONTENT_MSG_DONE || - event->type == CONTENT_MSG_ERROR)) { - /* all objects have arrived */ - content__reformat(&c->base, false, c->base.available_width, - c->base.available_height); - content_set_done(&c->base); - } else if (nsoption_bool(incremental_reflow) && - event->type == CONTENT_MSG_DONE && - box != NULL && - !(box->flags & REPLACE_DIM) && - (c->base.status == CONTENT_STATUS_READY || - c->base.status == CONTENT_STATUS_DONE)) { - /* 1) the configuration option to reflow pages while - * objects are fetched is set - * 2) an object is newly fetched & converted, - * 3) the box's dimensions need to change due to being replaced - * 4) the object's parent HTML is ready for reformat, - */ - uint64_t ms_now; - nsu_getmonotonic_ms(&ms_now); - if (ms_now > c->base.reformat_time) { - /* The time since the previous reformat is - * more than the configured minimum time - * between reformats so reformat the page to - * display newly fetched objects - */ - content__reformat(&c->base, - false, - c->base.available_width, - c->base.available_height); - } - } - - return NSERROR_OK; -} - -/** - * Start a fetch for an object required by a page, replacing an existing object. - * - * \param object Object to replace - * \param url URL of object to fetch (copied) - * \return true on success, false on memory exhaustion - */ - -static bool html_replace_object(struct content_html_object *object, nsurl *url) -{ - html_content *c; - hlcache_child_context child; - html_content *page; - nserror error; - - assert(object != NULL); - assert(object->box != NULL); - - c = (html_content *) object->parent; - - child.charset = c->encoding; - child.quirks = c->base.quirks; - - if (object->content != NULL) { - /* remove existing object */ - if (content_get_status(object->content) != CONTENT_STATUS_DONE) { - c->base.active--; - NSLOG(netsurf, INFO, "%d fetches active", - c->base.active); - } - - hlcache_handle_release(object->content); - object->content = NULL; - - object->box->object = NULL; - } - - /* initialise fetch */ - error = hlcache_handle_retrieve(url, HLCACHE_RETRIEVE_SNIFF_TYPE, - content_get_url(&c->base), NULL, - html_object_callback, object, &child, - object->permitted_types, - &object->content); - - if (error != NSERROR_OK) - return false; - - for (page = c; page != NULL; page = page->page) { - page->base.active++; - NSLOG(netsurf, INFO, "%d fetches active", c->base.active); - - page->base.status = CONTENT_STATUS_READY; - } - - return true; -} - -/** - * schedule callback for object refresh - */ - -static void html_object_refresh(void *p) -{ - struct content_html_object *object = p; - nsurl *refresh_url; - - assert(content_get_type(object->content) == CONTENT_HTML); - - refresh_url = content_get_refresh_url(object->content); - - /* Ignore if refresh URL has gone - * (may happen if fetch errored) */ - if (refresh_url == NULL) - return; - - content_invalidate_reuse_data(object->content); - - if (!html_replace_object(object, refresh_url)) { - /** \todo handle memory exhaustion */ - } -} - -nserror html_object_open_objects(html_content *html, struct browser_window *bw) -{ - struct content_html_object *object, *next; - - for (object = html->object_list; object != NULL; object = next) { - next = object->next; - - if (object->content == NULL || object->box == NULL) - continue; - - if (content_get_type(object->content) == CONTENT_NONE) - continue; - - content_open(object->content, - bw, - &html->base, - object->box->object_params); - } - return NSERROR_OK; -} - -nserror html_object_abort_objects(html_content *htmlc) -{ - struct content_html_object *object; - - for (object = htmlc->object_list; - object != NULL; - object = object->next) { - if (object->content == NULL) - continue; - - switch (content_get_status(object->content)) { - case CONTENT_STATUS_DONE: - /* already loaded: do nothing */ - break; - - case CONTENT_STATUS_READY: - hlcache_handle_abort(object->content); - /* Active count will be updated when - * html_object_callback receives - * CONTENT_MSG_DONE from this object - */ - break; - - default: - hlcache_handle_abort(object->content); - hlcache_handle_release(object->content); - object->content = NULL; - if (object->box != NULL) { - htmlc->base.active--; - NSLOG(netsurf, INFO, "%d fetches active", - htmlc->base.active); - } - break; - - } - } - - return NSERROR_OK; -} - -nserror html_object_close_objects(html_content *html) -{ - struct content_html_object *object, *next; - - for (object = html->object_list; object != NULL; object = next) { - next = object->next; - - if (object->content == NULL || object->box == NULL) - continue; - - if (content_get_type(object->content) == CONTENT_NONE) - continue; - - if (content_get_type(object->content) == CONTENT_HTML) { - guit->misc->schedule(-1, html_object_refresh, object); - } - - content_close(object->content); - } - return NSERROR_OK; -} - -nserror html_object_free_objects(html_content *html) -{ - while (html->object_list != NULL) { - struct content_html_object *victim = html->object_list; - - if (victim->content != NULL) { - NSLOG(netsurf, INFO, "object %p", victim->content); - - if (content_get_type(victim->content) == CONTENT_HTML) { - guit->misc->schedule(-1, html_object_refresh, victim); - } - hlcache_handle_release(victim->content); - } - - html->object_list = victim->next; - free(victim); - } - return NSERROR_OK; -} - - - -/* exported interface documented in html/html_internal.h */ -bool html_fetch_object(html_content *c, nsurl *url, struct box *box, - content_type permitted_types, - int available_width, int available_height, - bool background) -{ - struct content_html_object *object; - hlcache_child_context child; - nserror error; - - /* If we've already been aborted, don't bother attempting the fetch */ - if (c->aborted) - return true; - - child.charset = c->encoding; - child.quirks = c->base.quirks; - - object = calloc(1, sizeof(struct content_html_object)); - if (object == NULL) { - return false; - } - - object->parent = (struct content *) c; - object->next = NULL; - object->content = NULL; - object->box = box; - object->permitted_types = permitted_types; - object->background = background; - - error = hlcache_handle_retrieve(url, - HLCACHE_RETRIEVE_SNIFF_TYPE, - content_get_url(&c->base), NULL, - html_object_callback, object, &child, - object->permitted_types, &object->content); - if (error != NSERROR_OK) { - free(object); - return error != NSERROR_NOMEM; - } - - /* add to content object list */ - object->next = c->object_list; - c->object_list = object; - - c->num_objects++; - if (box != NULL) { - c->base.active++; - NSLOG(netsurf, INFO, "%d fetches active", c->base.active); - } - - return true; -} diff --git a/content/handlers/html/html_redraw.c b/content/handlers/html/html_redraw.c deleted file mode 100644 index ee6fab2..0000000 --- a/content/handlers/html/html_redraw.c +++ /dev/null @@ -1,1961 +0,0 @@ -/* - * Copyright 2004-2008 James Bursa <bursa(a)users.sourceforge.net> - * Copyright 2004-2007 John M Bell <jmb202(a)ecs.soton.ac.uk> - * Copyright 2004-2007 Richard Wilson <info(a)tinct.net> - * Copyright 2005-2006 Adrian Lees <adrianl(a)users.sourceforge.net> - * Copyright 2006 Rob Kendrick <rjek(a)netsurf-browser.org> - * Copyright 2008 Michael Drake <tlsa(a)netsurf-browser.org> - * Copyright 2009 Paul Blokus <paul_pl(a)users.sourceforge.net> - * - * 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 - * - * Redrawing CONTENT_HTML implementation. - */ - -#include "utils/config.h" -#include <assert.h> -#include <stdbool.h> -#include <stdlib.h> -#include <string.h> -#include <math.h> -#include <dom/dom.h> - -#include "utils/log.h" -#include "utils/messages.h" -#include "utils/utils.h" -#include "utils/nsoption.h" -#include "netsurf/content.h" -#include "netsurf/browser_window.h" -#include "netsurf/plotters.h" -#include "netsurf/bitmap.h" -#include "netsurf/layout.h" -#include "content/content_protected.h" -#include "css/utils.h" -#include "desktop/selection.h" -#include "desktop/print.h" -#include "desktop/scrollbar.h" -#include "desktop/textarea.h" -#include "desktop/gui_internal.h" - -#include "html/box.h" -#include "html/box_inspect.h" -#include "html/box_manipulate.h" -#include "html/font.h" -#include "html/form_internal.h" -#include "html/html_internal.h" -#include "html/layout.h" -#include "html/search.h" - - -bool html_redraw_debug = false; - -/** - * Determine if a box has a background that needs drawing - * - * \param box Box to consider - * \return True if box has a background, false otherwise. - */ -static bool html_redraw_box_has_background(struct box *box) -{ - if (box->background != NULL) - return true; - - if (box->style != NULL) { - css_color colour; - - css_computed_background_color(box->style, &colour); - - if (nscss_color_is_transparent(colour) == false) - return true; - } - - return false; -} - -/** - * Find the background box for a box - * - * \param box Box to find background box for - * \return Pointer to background box, or NULL if there is none - */ -static struct box *html_redraw_find_bg_box(struct box *box) -{ - /* Thanks to backwards compatibility, CSS defines the following: - * - * + If the box is for the root element and it has a background, - * use that (and then process the body box with no special case) - * + If the box is for the root element and it has no background, - * then use the background (if any) from the body element as if - * it were specified on the root. Then, when the box for the body - * element is processed, ignore the background. - * + For any other box, just use its own styling. - */ - if (box->parent == NULL) { - /* Root box */ - if (html_redraw_box_has_background(box)) - return box; - - /* No background on root box: consider body box, if any */ - if (box->children != NULL) { - if (html_redraw_box_has_background(box->children)) - return box->children; - } - } else if (box->parent != NULL && box->parent->parent == NULL) { - /* Body box: only render background if root has its own */ - if (html_redraw_box_has_background(box) && - html_redraw_box_has_background(box->parent)) - return box; - } else { - /* Any other box */ - if (html_redraw_box_has_background(box)) - return box; - } - - return NULL; -} - -/** - * Redraw a short text string, complete with highlighting - * (for selection/search) - * - * \param utf8_text pointer to UTF-8 text string - * \param utf8_len length of string, in bytes - * \param offset byte offset within textual representation - * \param space width of space that follows string (0 = no space) - * \param fstyle text style to use (pass text size unscaled) - * \param x x ordinate at which to plot text - * \param y y ordinate at which to plot text - * \param clip pointer to current clip rectangle - * \param height height of text string - * \param scale current display scale (1.0 = 100%) - * \param excluded exclude this text string from the selection - * \param c Content being redrawn. - * \param sel Selection context - * \param search Search context - * \param ctx current redraw context - * \return true iff successful and redraw should proceed - */ - -static bool -text_redraw(const char *utf8_text, - size_t utf8_len, - size_t offset, - int space, - const plot_font_style_t *fstyle, - int x, - int y, - const struct rect *clip, - int height, - float scale, - bool excluded, - struct content *c, - const struct selection *sel, - struct search_context *search, - const struct redraw_context *ctx) -{ - bool highlighted = false; - plot_font_style_t plot_fstyle = *fstyle; - nserror res; - - /* Need scaled text size to pass to plotters */ - plot_fstyle.size *= scale; - - /* is this box part of a selection? */ - if (!excluded && ctx->interactive == true) { - unsigned len = utf8_len + (space ? 1 : 0); - unsigned start_idx; - unsigned end_idx; - - /* first try the browser window's current selection */ - if (selection_defined(sel) && selection_highlighted(sel, - offset, offset + len, - &start_idx, &end_idx)) { - highlighted = true; - } - - /* what about the current search operation, if any? */ - if (!highlighted && (search != NULL) && - search_term_highlighted(c, - offset, offset + len, - &start_idx, &end_idx, - search)) { - highlighted = true; - } - - /* \todo make search terms visible within selected text */ - if (highlighted) { - struct rect r; - unsigned endtxt_idx = end_idx; - bool clip_changed = false; - bool text_visible = true; - int startx, endx; - plot_style_t pstyle_fill_hback = *plot_style_fill_white; - plot_font_style_t fstyle_hback = plot_fstyle; - - if (end_idx > utf8_len) { - /* adjust for trailing space, not present in - * utf8_text */ - assert(end_idx == utf8_len + 1); - endtxt_idx = utf8_len; - } - - res = guit->layout->width(fstyle, - utf8_text, start_idx, - &startx); - if (res != NSERROR_OK) { - startx = 0; - } - - res = guit->layout->width(fstyle, - utf8_text, endtxt_idx, - &endx); - if (res != NSERROR_OK) { - endx = 0; - } - - /* is there a trailing space that should be highlighted - * as well? */ - if (end_idx > utf8_len) { - endx += space; - } - - if (scale != 1.0) { - startx *= scale; - endx *= scale; - } - - /* draw any text preceding highlighted portion */ - if ((start_idx > 0) && - (ctx->plot->text(ctx, - &plot_fstyle, - x, - y + (int)(height * 0.75 * scale), - utf8_text, - start_idx) != NSERROR_OK)) - return false; - - pstyle_fill_hback.fill_colour = fstyle->foreground; - - /* highlighted portion */ - r.x0 = x + startx; - r.y0 = y; - r.x1 = x + endx; - r.y1 = y + height * scale; - res = ctx->plot->rectangle(ctx, &pstyle_fill_hback, &r); - if (res != NSERROR_OK) { - return false; - } - - if (start_idx > 0) { - int px0 = max(x + startx, clip->x0); - int px1 = min(x + endx, clip->x1); - - if (px0 < px1) { - r.x0 = px0; - r.y0 = clip->y0; - r.x1 = px1; - r.y1 = clip->y1; - res = ctx->plot->clip(ctx, &r); - if (res != NSERROR_OK) { - return false; - } - - clip_changed = true; - } else { - text_visible = false; - } - } - - fstyle_hback.background = - pstyle_fill_hback.fill_colour; - fstyle_hback.foreground = colour_to_bw_furthest( - pstyle_fill_hback.fill_colour); - - if (text_visible && - (ctx->plot->text(ctx, - &fstyle_hback, - x, - y + (int)(height * 0.75 * scale), - utf8_text, - endtxt_idx) != NSERROR_OK)) { - return false; - } - - /* draw any text succeeding highlighted portion */ - if (endtxt_idx < utf8_len) { - int px0 = max(x + endx, clip->x0); - if (px0 < clip->x1) { - - r.x0 = px0; - r.y0 = clip->y0; - r.x1 = clip->x1; - r.y1 = clip->y1; - res = ctx->plot->clip(ctx, &r); - if (res != NSERROR_OK) { - return false; - } - - clip_changed = true; - - res = ctx->plot->text(ctx, - &plot_fstyle, - x, - y + (int)(height * 0.75 * scale), - utf8_text, - utf8_len); - if (res != NSERROR_OK) { - return false; - } - } - } - - if (clip_changed && - (ctx->plot->clip(ctx, clip) != NSERROR_OK)) { - return false; - } - } - } - - if (!highlighted) { - res = ctx->plot->text(ctx, - &plot_fstyle, - x, - y + (int) (height * 0.75 * scale), - utf8_text, - utf8_len); - if (res != NSERROR_OK) { - return false; - } - } - return true; -} - - -/** - * Plot a checkbox. - * - * \param x left coordinate - * \param y top coordinate - * \param width dimensions of checkbox - * \param height dimensions of checkbox - * \param selected the checkbox is selected - * \param ctx current redraw context - * \return true if successful, false otherwise - */ - -static bool html_redraw_checkbox(int x, int y, int width, int height, - bool selected, const struct redraw_context *ctx) -{ - double z; - nserror res; - struct rect rect; - - z = width * 0.15; - if (z == 0) { - z = 1; - } - - rect.x0 = x; - rect.y0 = y ; - rect.x1 = x + width; - rect.y1 = y + height; - res = ctx->plot->rectangle(ctx, plot_style_fill_wbasec, &rect); - if (res != NSERROR_OK) { - return false; - } - - /* dark line across top */ - rect.y1 = y; - res = ctx->plot->line(ctx, plot_style_stroke_darkwbasec, &rect); - if (res != NSERROR_OK) { - return false; - } - - /* dark line across left */ - rect.x1 = x; - rect.y1 = y + height; - res = ctx->plot->line(ctx, plot_style_stroke_darkwbasec, &rect); - if (res != NSERROR_OK) { - return false; - } - - /* light line across right */ - rect.x0 = x + width; - rect.x1 = x + width; - res = ctx->plot->line(ctx, plot_style_stroke_lightwbasec, &rect); - if (res != NSERROR_OK) { - return false; - } - - /* light line across bottom */ - rect.x0 = x; - rect.y0 = y + height; - res = ctx->plot->line(ctx, plot_style_stroke_lightwbasec, &rect); - if (res != NSERROR_OK) { - return false; - } - - if (selected) { - if (width < 12 || height < 12) { - /* render a solid box instead of a tick */ - rect.x0 = x + z + z; - rect.y0 = y + z + z; - rect.x1 = x + width - z; - rect.y1 = y + height - z; - res = ctx->plot->rectangle(ctx, plot_style_fill_wblobc, &rect); - if (res != NSERROR_OK) { - return false; - } - } else { - /* render a tick, as it'll fit comfortably */ - rect.x0 = x + width - z; - rect.y0 = y + z; - rect.x1 = x + (z * 3); - rect.y1 = y + height - z; - res = ctx->plot->line(ctx, plot_style_stroke_wblobc, &rect); - if (res != NSERROR_OK) { - return false; - } - - rect.x0 = x + (z * 3); - rect.y0 = y + height - z; - rect.x1 = x + z + z; - rect.y1 = y + (height / 2); - res = ctx->plot->line(ctx, plot_style_stroke_wblobc, &rect); - if (res != NSERROR_OK) { - return false; - } - } - } - return true; -} - - -/** - * Plot a radio icon. - * - * \param x left coordinate - * \param y top coordinate - * \param width dimensions of radio icon - * \param height dimensions of radio icon - * \param selected the radio icon is selected - * \param ctx current redraw context - * \return true if successful, false otherwise - */ -static bool html_redraw_radio(int x, int y, int width, int height, - bool selected, const struct redraw_context *ctx) -{ - nserror res; - - /* plot background of radio button */ - res = ctx->plot->disc(ctx, - plot_style_fill_wbasec, - x + width * 0.5, - y + height * 0.5, - width * 0.5 - 1); - if (res != NSERROR_OK) { - return false; - } - - /* plot dark arc */ - res = ctx->plot->arc(ctx, - plot_style_fill_darkwbasec, - x + width * 0.5, - y + height * 0.5, - width * 0.5 - 1, - 45, - 225); - if (res != NSERROR_OK) { - return false; - } - - /* plot light arc */ - res = ctx->plot->arc(ctx, - plot_style_fill_lightwbasec, - x + width * 0.5, - y + height * 0.5, - width * 0.5 - 1, - 225, - 45); - if (res != NSERROR_OK) { - return false; - } - - if (selected) { - /* plot selection blob */ - res = ctx->plot->disc(ctx, - plot_style_fill_wblobc, - x + width * 0.5, - y + height * 0.5, - width * 0.3 - 1); - if (res != NSERROR_OK) { - return false; - } - } - - return true; -} - - -/** - * Plot a file upload input. - * - * \param x left coordinate - * \param y top coordinate - * \param width dimensions of input - * \param height dimensions of input - * \param box box of input - * \param scale scale for redraw - * \param background_colour current background colour - * \param len_ctx Length conversion context - * \param ctx current redraw context - * \return true if successful, false otherwise - */ - -static bool html_redraw_file(int x, int y, int width, int height, - struct box *box, float scale, colour background_colour, - const nscss_len_ctx *len_ctx, - const struct redraw_context *ctx) -{ - int text_width; - const char *text; - size_t length; - plot_font_style_t fstyle; - nserror res; - - font_plot_style_from_css(len_ctx, box->style, &fstyle); - fstyle.background = background_colour; - - if (box->gadget->value) { - text = box->gadget->value; - } else { - text = messages_get("Form_Drop"); - } - length = strlen(text); - - res = guit->layout->width(&fstyle, text, length, &text_width); - if (res != NSERROR_OK) { - return false; - } - text_width *= scale; - if (width < text_width + 8) { - x = x + width - text_width - 4; - } else { - x = x + 4; - } - - res = ctx->plot->text(ctx, &fstyle, x, y + height * 0.75, text, length); - if (res != NSERROR_OK) { - return false; - } - return true; -} - - -/** - * Plot background images. - * - * The reason for the presence of \a background is the backwards compatibility - * mess that is backgrounds on <body>. The background will be drawn relative - * to \a box, using the background information contained within \a background. - * - * \param x coordinate of box - * \param y coordinate of box - * \param box box to draw background image of - * \param scale scale for redraw - * \param clip current clip rectangle - * \param background_colour current background colour - * \param background box containing background details (usually \a box) - * \param len_ctx Length conversion context - * \param ctx current redraw context - * \return true if successful, false otherwise - */ - -static bool html_redraw_background(int x, int y, struct box *box, float scale, - const struct rect *clip, colour *background_colour, - struct box *background, - const nscss_len_ctx *len_ctx, - const struct redraw_context *ctx) -{ - bool repeat_x = false; - bool repeat_y = false; - bool plot_colour = true; - bool plot_content; - bool clip_to_children = false; - struct box *clip_box = box; - int ox = x, oy = y; - int width, height; - css_fixed hpos = 0, vpos = 0; - css_unit hunit = CSS_UNIT_PX, vunit = CSS_UNIT_PX; - struct box *parent; - struct rect r = *clip; - css_color bgcol; - plot_style_t pstyle_fill_bg = { - .fill_type = PLOT_OP_TYPE_SOLID, - .fill_colour = *background_colour, - }; - nserror res; - - if (ctx->background_images == false) - return true; - - plot_content = (background->background != NULL); - - if (plot_content) { - if (!box->parent) { - /* Root element, special case: - * background origin calc. is based on margin box */ - x -= box->margin[LEFT] * scale; - y -= box->margin[TOP] * scale; - width = box->margin[LEFT] + box->padding[LEFT] + - box->width + box->padding[RIGHT] + - box->margin[RIGHT]; - height = box->margin[TOP] + box->padding[TOP] + - box->height + box->padding[BOTTOM] + - box->margin[BOTTOM]; - } else { - width = box->padding[LEFT] + box->width + - box->padding[RIGHT]; - height = box->padding[TOP] + box->height + - box->padding[BOTTOM]; - } - /* handle background-repeat */ - switch (css_computed_background_repeat(background->style)) { - case CSS_BACKGROUND_REPEAT_REPEAT: - repeat_x = repeat_y = true; - /* optimisation: only plot the colour if - * bitmap is not opaque */ - plot_colour = !content_get_opaque(background->background); - break; - - case CSS_BACKGROUND_REPEAT_REPEAT_X: - repeat_x = true; - break; - - case CSS_BACKGROUND_REPEAT_REPEAT_Y: - repeat_y = true; - break; - - case CSS_BACKGROUND_REPEAT_NO_REPEAT: - break; - - default: - break; - } - - /* handle background-position */ - css_computed_background_position(background->style, - &hpos, &hunit, &vpos, &vunit); - if (hunit == CSS_UNIT_PCT) { - x += (width - - content_get_width(background->background)) * - scale * FIXTOFLT(hpos) / 100.; - } else { - x += (int) (FIXTOFLT(nscss_len2px(len_ctx, hpos, hunit, - background->style)) * scale); - } - - if (vunit == CSS_UNIT_PCT) { - y += (height - - content_get_height(background->background)) * - scale * FIXTOFLT(vpos) / 100.; - } else { - y += (int) (FIXTOFLT(nscss_len2px(len_ctx, vpos, vunit, - background->style)) * scale); - } - } - - /* special case for table rows as their background needs - * to be clipped to all the cells */ - if (box->type == BOX_TABLE_ROW) { - css_fixed h = 0, v = 0; - css_unit hu = CSS_UNIT_PX, vu = CSS_UNIT_PX; - - for (parent = box->parent; - ((parent) && (parent->type != BOX_TABLE)); - parent = parent->parent); - assert(parent && (parent->style)); - - css_computed_border_spacing(parent->style, &h, &hu, &v, &vu); - - clip_to_children = (h > 0) || (v > 0); - - if (clip_to_children) - clip_box = box->children; - } - - for (; clip_box; clip_box = clip_box->next) { - /* clip to child boxes if needed */ - if (clip_to_children) { - assert(clip_box->type == BOX_TABLE_CELL); - - /* update clip.* to the child cell */ - r.x0 = ox + (clip_box->x * scale); - r.y0 = oy + (clip_box->y * scale); - r.x1 = r.x0 + (clip_box->padding[LEFT] + - clip_box->width + - clip_box->padding[RIGHT]) * scale; - r.y1 = r.y0 + (clip_box->padding[TOP] + - clip_box->height + - clip_box->padding[BOTTOM]) * scale; - - if (r.x0 < clip->x0) r.x0 = clip->x0; - if (r.y0 < clip->y0) r.y0 = clip->y0; - if (r.x1 > clip->x1) r.x1 = clip->x1; - if (r.y1 > clip->y1) r.y1 = clip->y1; - - css_computed_background_color(clip_box->style, &bgcol); - - /* <td> attributes override <tr> */ - /* if the background content is opaque there - * is no need to plot underneath it. - */ - if ((r.x0 >= r.x1) || - (r.y0 >= r.y1) || - (nscss_color_is_transparent(bgcol) == false) || - ((clip_box->background != NULL) && - content_get_opaque(clip_box->background))) - continue; - } - - /* plot the background colour */ - css_computed_background_color(background->style, &bgcol); - - if (nscss_color_is_transparent(bgcol) == false) { - *background_colour = nscss_color_to_ns(bgcol); - pstyle_fill_bg.fill_colour = *background_colour; - if (plot_colour) { - res = ctx->plot->rectangle(ctx, &pstyle_fill_bg, &r); - if (res != NSERROR_OK) { - return false; - } - } - } - /* and plot the image */ - if (plot_content) { - width = content_get_width(background->background); - height = content_get_height(background->background); - - /* ensure clip area only as large as required */ - if (!repeat_x) { - if (r.x0 < x) - r.x0 = x; - if (r.x1 > x + width * scale) - r.x1 = x + width * scale; - } - if (!repeat_y) { - if (r.y0 < y) - r.y0 = y; - if (r.y1 > y + height * scale) - r.y1 = y + height * scale; - } - /* valid clipping rectangles only */ - if ((r.x0 < r.x1) && (r.y0 < r.y1)) { - struct content_redraw_data bg_data; - - res = ctx->plot->clip(ctx, &r); - if (res != NSERROR_OK) { - return false; - } - - bg_data.x = x; - bg_data.y = y; - bg_data.width = ceilf(width * scale); - bg_data.height = ceilf(height * scale); - bg_data.background_colour = *background_colour; - bg_data.scale = scale; - bg_data.repeat_x = repeat_x; - bg_data.repeat_y = repeat_y; - - /* We just continue if redraw fails */ - content_redraw(background->background, - &bg_data, &r, ctx); - } - } - - /* only <tr> rows being clipped to child boxes loop */ - if (!clip_to_children) - return true; - } - return true; -} - - -/** - * Plot an inline's background and/or background image. - * - * \param x coordinate of box - * \param y coordinate of box - * \param box BOX_INLINE which created the background - * \param scale scale for redraw - * \param clip coordinates of clip rectangle - * \param b coordinates of border edge rectangle - * \param first true if this is the first rectangle associated with the inline - * \param last true if this is the last rectangle associated with the inline - * \param background_colour updated to current background colour if plotted - * \param len_ctx Length conversion context - * \param ctx current redraw context - * \return true if successful, false otherwise - */ - -static bool html_redraw_inline_background(int x, int y, struct box *box, - float scale, const struct rect *clip, struct rect b, - bool first, bool last, colour *background_colour, - const nscss_len_ctx *len_ctx, - const struct redraw_context *ctx) -{ - struct rect r = *clip; - bool repeat_x = false; - bool repeat_y = false; - bool plot_colour = true; - bool plot_content; - css_fixed hpos = 0, vpos = 0; - css_unit hunit = CSS_UNIT_PX, vunit = CSS_UNIT_PX; - css_color bgcol; - plot_style_t pstyle_fill_bg = { - .fill_type = PLOT_OP_TYPE_SOLID, - .fill_colour = *background_colour, - }; - nserror res; - - plot_content = (box->background != NULL); - - if (html_redraw_printing && nsoption_bool(remove_backgrounds)) - return true; - - if (plot_content) { - /* handle background-repeat */ - switch (css_computed_background_repeat(box->style)) { - case CSS_BACKGROUND_REPEAT_REPEAT: - repeat_x = repeat_y = true; - /* optimisation: only plot the colour if - * bitmap is not opaque - */ - plot_colour = !content_get_opaque(box->background); - break; - - case CSS_BACKGROUND_REPEAT_REPEAT_X: - repeat_x = true; - break; - - case CSS_BACKGROUND_REPEAT_REPEAT_Y: - repeat_y = true; - break; - - case CSS_BACKGROUND_REPEAT_NO_REPEAT: - break; - - default: - break; - } - - /* handle background-position */ - css_computed_background_position(box->style, - &hpos, &hunit, &vpos, &vunit); - if (hunit == CSS_UNIT_PCT) { - x += (b.x1 - b.x0 - - content_get_width(box->background) * - scale) * FIXTOFLT(hpos) / 100.; - - if (!repeat_x && ((hpos < 2 && !first) || - (hpos > 98 && !last))){ - plot_content = false; - } - } else { - x += (int) (FIXTOFLT(nscss_len2px(len_ctx, hpos, hunit, - box->style)) * scale); - } - - if (vunit == CSS_UNIT_PCT) { - y += (b.y1 - b.y0 - - content_get_height(box->background) * - scale) * FIXTOFLT(vpos) / 100.; - } else { - y += (int) (FIXTOFLT(nscss_len2px(len_ctx, vpos, vunit, - box->style)) * scale); - } - } - - /* plot the background colour */ - css_computed_background_color(box->style, &bgcol); - - if (nscss_color_is_transparent(bgcol) == false) { - *background_colour = nscss_color_to_ns(bgcol); - pstyle_fill_bg.fill_colour = *background_colour; - - if (plot_colour) { - res = ctx->plot->rectangle(ctx, &pstyle_fill_bg, &r); - if (res != NSERROR_OK) { - return false; - } - } - } - /* and plot the image */ - if (plot_content) { - int width = content_get_width(box->background); - int height = content_get_height(box->background); - - if (!repeat_x) { - if (r.x0 < x) - r.x0 = x; - if (r.x1 > x + width * scale) - r.x1 = x + width * scale; - } - if (!repeat_y) { - if (r.y0 < y) - r.y0 = y; - if (r.y1 > y + height * scale) - r.y1 = y + height * scale; - } - /* valid clipping rectangles only */ - if ((r.x0 < r.x1) && (r.y0 < r.y1)) { - struct content_redraw_data bg_data; - - res = ctx->plot->clip(ctx, &r); - if (res != NSERROR_OK) { - return false; - } - - bg_data.x = x; - bg_data.y = y; - bg_data.width = ceilf(width * scale); - bg_data.height = ceilf(height * scale); - bg_data.background_colour = *background_colour; - bg_data.scale = scale; - bg_data.repeat_x = repeat_x; - bg_data.repeat_y = repeat_y; - - /* We just continue if redraw fails */ - content_redraw(box->background, &bg_data, &r, ctx); - } - } - - return true; -} - - -/** - * Plot text decoration for an inline box. - * - * \param box box to plot decorations for, of type BOX_INLINE - * \param x x coordinate of parent of box - * \param y y coordinate of parent of box - * \param scale scale for redraw - * \param colour colour for decorations - * \param ratio position of line as a ratio of line height - * \param ctx current redraw context - * \return true if successful, false otherwise - */ - -static bool -html_redraw_text_decoration_inline(struct box *box, - int x, int y, - float scale, - colour colour, - float ratio, - const struct redraw_context *ctx) -{ - struct box *c; - plot_style_t plot_style_box = { - .stroke_type = PLOT_OP_TYPE_SOLID, - .stroke_colour = colour, - }; - nserror res; - struct rect rect; - - for (c = box->next; - c && c != box->inline_end; - c = c->next) { - if (c->type != BOX_TEXT) { - continue; - } - rect.x0 = (x + c->x) * scale; - rect.y0 = (y + c->y + c->height * ratio) * scale; - rect.x1 = (x + c->x + c->width) * scale; - rect.y1 = (y + c->y + c->height * ratio) * scale; - res = ctx->plot->line(ctx, &plot_style_box, &rect); - if (res != NSERROR_OK) { - return false; - } - } - return true; -} - - -/** - * Plot text decoration for an non-inline box. - * - * \param box box to plot decorations for, of type other than BOX_INLINE - * \param x x coordinate of box - * \param y y coordinate of box - * \param scale scale for redraw - * \param colour colour for decorations - * \param ratio position of line as a ratio of line height - * \param ctx current redraw context - * \return true if successful, false otherwise - */ - -static bool -html_redraw_text_decoration_block(struct box *box, - int x, int y, - float scale, - colour colour, - float ratio, - const struct redraw_context *ctx) -{ - struct box *c; - plot_style_t plot_style_box = { - .stroke_type = PLOT_OP_TYPE_SOLID, - .stroke_colour = colour, - }; - nserror res; - struct rect rect; - - /* draw through text descendants */ - for (c = box->children; c; c = c->next) { - if (c->type == BOX_TEXT) { - rect.x0 = (x + c->x) * scale; - rect.y0 = (y + c->y + c->height * ratio) * scale; - rect.x1 = (x + c->x + c->width) * scale; - rect.y1 = (y + c->y + c->height * ratio) * scale; - res = ctx->plot->line(ctx, &plot_style_box, &rect); - if (res != NSERROR_OK) { - return false; - } - } else if ((c->type == BOX_INLINE_CONTAINER) || (c->type == BOX_BLOCK)) { - if (!html_redraw_text_decoration_block(c, - x + c->x, y + c->y, - scale, colour, ratio, ctx)) - return false; - } - } - return true; -} - - -/** - * Plot text decoration for a box. - * - * \param box box to plot decorations for - * \param x_parent x coordinate of parent of box - * \param y_parent y coordinate of parent of box - * \param scale scale for redraw - * \param background_colour current background colour - * \param ctx current redraw context - * \return true if successful, false otherwise - */ - -static bool html_redraw_text_decoration(struct box *box, - int x_parent, int y_parent, float scale, - colour background_colour, const struct redraw_context *ctx) -{ - static const enum css_text_decoration_e decoration[] = { - CSS_TEXT_DECORATION_UNDERLINE, CSS_TEXT_DECORATION_OVERLINE, - CSS_TEXT_DECORATION_LINE_THROUGH }; - static const float line_ratio[] = { 0.9, 0.1, 0.5 }; - colour fgcol; - unsigned int i; - css_color col; - - css_computed_color(box->style, &col); - fgcol = nscss_color_to_ns(col); - - /* antialias colour for under/overline */ - if (html_redraw_printing == false) - fgcol = blend_colour(background_colour, fgcol); - - if (box->type == BOX_INLINE) { - if (!box->inline_end) - return true; - for (i = 0; i != NOF_ELEMENTS(decoration); i++) - if (css_computed_text_decoration(box->style) & - decoration[i]) - if (!html_redraw_text_decoration_inline(box, - x_parent, y_parent, scale, - fgcol, line_ratio[i], ctx)) - return false; - } else { - for (i = 0; i != NOF_ELEMENTS(decoration); i++) - if (css_computed_text_decoration(box->style) & - decoration[i]) - if (!html_redraw_text_decoration_block(box, - x_parent + box->x, - y_parent + box->y, - scale, - fgcol, line_ratio[i], ctx)) - return false; - } - - return true; -} - - -/** - * Redraw the text content of a box, possibly partially highlighted - * because the text has been selected, or matches a search operation. - * - * \param html The html content to redraw text within. - * \param box box with text content - * \param x x co-ord of box - * \param y y co-ord of box - * \param clip current clip rectangle - * \param scale current scale setting (1.0 = 100%) - * \param current_background_color - * \param ctx current redraw context - * \return true iff successful and redraw should proceed - */ - -static bool html_redraw_text_box(const html_content *html, struct box *box, - int x, int y, const struct rect *clip, float scale, - colour current_background_color, - const struct redraw_context *ctx) -{ - bool excluded = (box->object != NULL); - plot_font_style_t fstyle; - - font_plot_style_from_css(&html->len_ctx, box->style, &fstyle); - fstyle.background = current_background_color; - - if (!text_redraw(box->text, box->length, box->byte_offset, - box->space, &fstyle, x, y, - clip, box->height, scale, excluded, - (struct content *)html, &html->sel, - html->search, ctx)) - return false; - - return true; -} - -bool html_redraw_box(const html_content *html, struct box *box, - int x_parent, int y_parent, - const struct rect *clip, float scale, - colour current_background_color, - const struct redraw_context *ctx); - -/** - * Draw the various children of a box. - * - * \param html html content - * \param box box to draw children of - * \param x_parent coordinate of parent box - * \param y_parent coordinate of parent box - * \param clip clip rectangle - * \param scale scale for redraw - * \param current_background_color background colour under this box - * \param ctx current redraw context - * \return true if successful, false otherwise - */ - -static bool html_redraw_box_children(const html_content *html, struct box *box, - int x_parent, int y_parent, - const struct rect *clip, float scale, - colour current_background_color, - const struct redraw_context *ctx) -{ - struct box *c; - - for (c = box->children; c; c = c->next) { - - if (c->type != BOX_FLOAT_LEFT && c->type != BOX_FLOAT_RIGHT) - if (!html_redraw_box(html, c, - x_parent + box->x - - scrollbar_get_offset(box->scroll_x), - y_parent + box->y - - scrollbar_get_offset(box->scroll_y), - clip, scale, current_background_color, - ctx)) - return false; - } - for (c = box->float_children; c; c = c->next_float) - if (!html_redraw_box(html, c, - x_parent + box->x - - scrollbar_get_offset(box->scroll_x), - y_parent + box->y - - scrollbar_get_offset(box->scroll_y), - clip, scale, current_background_color, - ctx)) - return false; - - return true; -} - -/** - * Recursively draw a box. - * - * \param html html content - * \param box box to draw - * \param x_parent coordinate of parent box - * \param y_parent coordinate of parent box - * \param clip clip rectangle - * \param scale scale for redraw - * \param current_background_color background colour under this box - * \param ctx current redraw context - * \return true if successful, false otherwise - * - * x, y, clip_[xy][01] are in target coordinates. - */ - -bool html_redraw_box(const html_content *html, struct box *box, - int x_parent, int y_parent, - const struct rect *clip, const float scale, - colour current_background_color, - const struct redraw_context *ctx) -{ - const struct plotter_table *plot = ctx->plot; - int x, y; - int width, height; - int padding_left, padding_top, padding_width, padding_height; - int border_left, border_top, border_right, border_bottom; - struct rect r; - struct rect rect; - int x_scrolled, y_scrolled; - struct box *bg_box = NULL; - css_computed_clip_rect css_rect; - enum css_overflow_e overflow_x = CSS_OVERFLOW_VISIBLE; - enum css_overflow_e overflow_y = CSS_OVERFLOW_VISIBLE; - - if (html_redraw_printing && (box->flags & PRINTED)) - return true; - - if (box->style != NULL) { - overflow_x = css_computed_overflow_x(box->style); - overflow_y = css_computed_overflow_y(box->style); - } - - /* avoid trivial FP maths */ - if (scale == 1.0) { - x = x_parent + box->x; - y = y_parent + box->y; - width = box->width; - height = box->height; - padding_left = box->padding[LEFT]; - padding_top = box->padding[TOP]; - padding_width = padding_left + box->width + box->padding[RIGHT]; - padding_height = padding_top + box->height + - box->padding[BOTTOM]; - border_left = box->border[LEFT].width; - border_top = box->border[TOP].width; - border_right = box->border[RIGHT].width; - border_bottom = box->border[BOTTOM].width; - } else { - x = (x_parent + box->x) * scale; - y = (y_parent + box->y) * scale; - width = box->width * scale; - height = box->height * scale; - /* left and top padding values are normally zero, - * so avoid trivial FP maths */ - padding_left = box->padding[LEFT] ? box->padding[LEFT] * scale - : 0; - padding_top = box->padding[TOP] ? box->padding[TOP] * scale - : 0; - padding_width = (box->padding[LEFT] + box->width + - box->padding[RIGHT]) * scale; - padding_height = (box->padding[TOP] + box->height + - box->padding[BOTTOM]) * scale; - border_left = box->border[LEFT].width * scale; - border_top = box->border[TOP].width * scale; - border_right = box->border[RIGHT].width * scale; - border_bottom = box->border[BOTTOM].width * scale; - } - - /* calculate rectangle covering this box and descendants */ - if (box->style && overflow_x != CSS_OVERFLOW_VISIBLE && - box->parent != NULL) { - /* box contents clipped to box size */ - r.x0 = x - border_left; - r.x1 = x + padding_width + border_right; - } else { - /* box contents can hang out of the box; use descendant box */ - if (scale == 1.0) { - r.x0 = x + box->descendant_x0; - r.x1 = x + box->descendant_x1 + 1; - } else { - r.x0 = x + box->descendant_x0 * scale; - r.x1 = x + box->descendant_x1 * scale + 1; - } - if (!box->parent) { - /* root element */ - int margin_left, margin_right; - if (scale == 1.0) { - margin_left = box->margin[LEFT]; - margin_right = box->margin[RIGHT]; - } else { - margin_left = box->margin[LEFT] * scale; - margin_right = box->margin[RIGHT] * scale; - } - r.x0 = x - border_left - margin_left < r.x0 ? - x - border_left - margin_left : r.x0; - r.x1 = x + padding_width + border_right + - margin_right > r.x1 ? - x + padding_width + border_right + - margin_right : r.x1; - } - } - - /* calculate rectangle covering this box and descendants */ - if (box->style && overflow_y != CSS_OVERFLOW_VISIBLE && - box->parent != NULL) { - /* box contents clipped to box size */ - r.y0 = y - border_top; - r.y1 = y + padding_height + border_bottom; - } else { - /* box contents can hang out of the box; use descendant box */ - if (scale == 1.0) { - r.y0 = y + box->descendant_y0; - r.y1 = y + box->descendant_y1 + 1; - } else { - r.y0 = y + box->descendant_y0 * scale; - r.y1 = y + box->descendant_y1 * scale + 1; - } - if (!box->parent) { - /* root element */ - int margin_top, margin_bottom; - if (scale == 1.0) { - margin_top = box->margin[TOP]; - margin_bottom = box->margin[BOTTOM]; - } else { - margin_top = box->margin[TOP] * scale; - margin_bottom = box->margin[BOTTOM] * scale; - } - r.y0 = y - border_top - margin_top < r.y0 ? - y - border_top - margin_top : r.y0; - r.y1 = y + padding_height + border_bottom + - margin_bottom > r.y1 ? - y + padding_height + border_bottom + - margin_bottom : r.y1; - } - } - - /* return if the rectangle is completely outside the clip rectangle */ - if (clip->y1 < r.y0 || r.y1 < clip->y0 || - clip->x1 < r.x0 || r.x1 < clip->x0) - return true; - - /*if the rectangle is under the page bottom but it can fit in a page, - don't print it now*/ - if (html_redraw_printing) { - if (r.y1 > html_redraw_printing_border) { - if (r.y1 - r.y0 <= html_redraw_printing_border && - (box->type == BOX_TEXT || - box->type == BOX_TABLE_CELL - || box->object || box->gadget)) { - /*remember the highest of all points from the - not printed elements*/ - if (r.y0 < html_redraw_printing_top_cropped) - html_redraw_printing_top_cropped = r.y0; - return true; - } - } - else box->flags |= PRINTED; /*it won't be printed anymore*/ - } - - /* if visibility is hidden render children only */ - if (box->style && css_computed_visibility(box->style) == - CSS_VISIBILITY_HIDDEN) { - if ((ctx->plot->group_start) && - (ctx->plot->group_start(ctx, "hidden box") != NSERROR_OK)) - return false; - if (!html_redraw_box_children(html, box, x_parent, y_parent, - &r, scale, current_background_color, ctx)) - return false; - return ((!ctx->plot->group_end) || (ctx->plot->group_end(ctx) == NSERROR_OK)); - } - - if ((ctx->plot->group_start) && - (ctx->plot->group_start(ctx,"vis box") != NSERROR_OK)) { - return false; - } - - if (box->style != NULL && - css_computed_position(box->style) == - CSS_POSITION_ABSOLUTE && - css_computed_clip(box->style, &css_rect) == - CSS_CLIP_RECT) { - /* We have an absolutly positioned box with a clip rect */ - if (css_rect.left_auto == false) - r.x0 = x - border_left + FIXTOINT(nscss_len2px( - &html->len_ctx, - css_rect.left, css_rect.lunit, - box->style)); - - if (css_rect.top_auto == false) - r.y0 = y - border_top + FIXTOINT(nscss_len2px( - &html->len_ctx, - css_rect.top, css_rect.tunit, - box->style)); - - if (css_rect.right_auto == false) - r.x1 = x - border_left + FIXTOINT(nscss_len2px( - &html->len_ctx, - css_rect.right, css_rect.runit, - box->style)); - - if (css_rect.bottom_auto == false) - r.y1 = y - border_top + FIXTOINT(nscss_len2px( - &html->len_ctx, - css_rect.bottom, css_rect.bunit, - box->style)); - - /* find intersection of clip rectangle and box */ - if (r.x0 < clip->x0) r.x0 = clip->x0; - if (r.y0 < clip->y0) r.y0 = clip->y0; - if (clip->x1 < r.x1) r.x1 = clip->x1; - if (clip->y1 < r.y1) r.y1 = clip->y1; - /* Nothing to do for invalid rectangles */ - if (r.x0 >= r.x1 || r.y0 >= r.y1) - /* not an error */ - return ((!ctx->plot->group_end) || - (ctx->plot->group_end(ctx) == NSERROR_OK)); - /* clip to it */ - if (ctx->plot->clip(ctx, &r) != NSERROR_OK) - return false; - - } else if (box->type == BOX_BLOCK || box->type == BOX_INLINE_BLOCK || - box->type == BOX_TABLE_CELL || box->object) { - /* find intersection of clip rectangle and box */ - if (r.x0 < clip->x0) r.x0 = clip->x0; - if (r.y0 < clip->y0) r.y0 = clip->y0; - if (clip->x1 < r.x1) r.x1 = clip->x1; - if (clip->y1 < r.y1) r.y1 = clip->y1; - /* no point trying to draw 0-width/height boxes */ - if (r.x0 == r.x1 || r.y0 == r.y1) - /* not an error */ - return ((!ctx->plot->group_end) || - (ctx->plot->group_end(ctx) == NSERROR_OK)); - /* clip to it */ - if (ctx->plot->clip(ctx, &r) != NSERROR_OK) - return false; - } else { - /* clip box is fine, clip to it */ - r = *clip; - if (ctx->plot->clip(ctx, &r) != NSERROR_OK) - return false; - } - - /* background colour and image for block level content and replaced - * inlines */ - - bg_box = html_redraw_find_bg_box(box); - - /* bg_box == NULL implies that this box should not have - * its background rendered. Otherwise filter out linebreaks, - * optimize away non-differing inlines, only plot background - * for BOX_TEXT it's in an inline */ - if (bg_box && bg_box->type != BOX_BR && - bg_box->type != BOX_TEXT && - bg_box->type != BOX_INLINE_END && - (bg_box->type != BOX_INLINE || bg_box->object || - bg_box->flags & IFRAME || box->flags & REPLACE_DIM || - (bg_box->gadget != NULL && - (bg_box->gadget->type == GADGET_TEXTAREA || - bg_box->gadget->type == GADGET_TEXTBOX || - bg_box->gadget->type == GADGET_PASSWORD)))) { - /* find intersection of clip box and border edge */ - struct rect p; - p.x0 = x - border_left < r.x0 ? r.x0 : x - border_left; - p.y0 = y - border_top < r.y0 ? r.y0 : y - border_top; - p.x1 = x + padding_width + border_right < r.x1 ? - x + padding_width + border_right : r.x1; - p.y1 = y + padding_height + border_bottom < r.y1 ? - y + padding_height + border_bottom : r.y1; - if (!box->parent) { - /* Root element, special case: - * background covers margins too */ - int m_left, m_top, m_right, m_bottom; - if (scale == 1.0) { - m_left = box->margin[LEFT]; - m_top = box->margin[TOP]; - m_right = box->margin[RIGHT]; - m_bottom = box->margin[BOTTOM]; - } else { - m_left = box->margin[LEFT] * scale; - m_top = box->margin[TOP] * scale; - m_right = box->margin[RIGHT] * scale; - m_bottom = box->margin[BOTTOM] * scale; - } - p.x0 = p.x0 - m_left < r.x0 ? r.x0 : p.x0 - m_left; - p.y0 = p.y0 - m_top < r.y0 ? r.y0 : p.y0 - m_top; - p.x1 = p.x1 + m_right < r.x1 ? p.x1 + m_right : r.x1; - p.y1 = p.y1 + m_bottom < r.y1 ? p.y1 + m_bottom : r.y1; - } - /* valid clipping rectangles only */ - if ((p.x0 < p.x1) && (p.y0 < p.y1)) { - /* plot background */ - if (!html_redraw_background(x, y, box, scale, &p, - &current_background_color, bg_box, - &html->len_ctx, ctx)) - return false; - /* restore previous graphics window */ - if (ctx->plot->clip(ctx, &r) != NSERROR_OK) - return false; - } - } - - /* borders for block level content and replaced inlines */ - if (box->style && - box->type != BOX_TEXT && - box->type != BOX_INLINE_END && - (box->type != BOX_INLINE || box->object || - box->flags & IFRAME || box->flags & REPLACE_DIM || - (box->gadget != NULL && - (box->gadget->type == GADGET_TEXTAREA || - box->gadget->type == GADGET_TEXTBOX || - box->gadget->type == GADGET_PASSWORD))) && - (border_top || border_right || border_bottom || border_left)) { - if (!html_redraw_borders(box, x_parent, y_parent, - padding_width, padding_height, &r, - scale, ctx)) - return false; - } - - /* backgrounds and borders for non-replaced inlines */ - if (box->style && box->type == BOX_INLINE && box->inline_end && - (html_redraw_box_has_background(box) || - border_top || border_right || - border_bottom || border_left)) { - /* inline backgrounds and borders span other boxes and may - * wrap onto separate lines */ - struct box *ib; - struct rect b; /* border edge rectangle */ - struct rect p; /* clipped rect */ - bool first = true; - int ib_x; - int ib_y = y; - int ib_p_width; - int ib_b_left, ib_b_right; - - b.x0 = x - border_left; - b.x1 = x + padding_width + border_right; - b.y0 = y - border_top; - b.y1 = y + padding_height + border_bottom; - - p.x0 = b.x0 < r.x0 ? r.x0 : b.x0; - p.x1 = b.x1 < r.x1 ? b.x1 : r.x1; - p.y0 = b.y0 < r.y0 ? r.y0 : b.y0; - p.y1 = b.y1 < r.y1 ? b.y1 : r.y1; - for (ib = box; ib; ib = ib->next) { - /* to get extents of rectangle(s) associated with - * inline, cycle though all boxes in inline, skipping - * over floats */ - if (ib->type == BOX_FLOAT_LEFT || - ib->type == BOX_FLOAT_RIGHT) - continue; - if (scale == 1.0) { - ib_x = x_parent + ib->x; - ib_y = y_parent + ib->y; - ib_p_width = ib->padding[LEFT] + ib->width + - ib->padding[RIGHT]; - ib_b_left = ib->border[LEFT].width; - ib_b_right = ib->border[RIGHT].width; - } else { - ib_x = (x_parent + ib->x) * scale; - ib_y = (y_parent + ib->y) * scale; - ib_p_width = (ib->padding[LEFT] + ib->width + - ib->padding[RIGHT]) * scale; - ib_b_left = ib->border[LEFT].width * scale; - ib_b_right = ib->border[RIGHT].width * scale; - } - - if ((ib->flags & NEW_LINE) && ib != box) { - /* inline element has wrapped, plot background - * and borders */ - if (!html_redraw_inline_background( - x, y, box, scale, &p, b, - first, false, - &current_background_color, - &html->len_ctx, ctx)) - return false; - /* restore previous graphics window */ - if (ctx->plot->clip(ctx, &r) != NSERROR_OK) - return false; - if (!html_redraw_inline_borders(box, b, &r, - scale, first, false, ctx)) - return false; - /* reset coords */ - b.x0 = ib_x - ib_b_left; - b.y0 = ib_y - border_top - padding_top; - b.y1 = ib_y + padding_height - padding_top + - border_bottom; - - p.x0 = b.x0 < r.x0 ? r.x0 : b.x0; - p.y0 = b.y0 < r.y0 ? r.y0 : b.y0; - p.y1 = b.y1 < r.y1 ? b.y1 : r.y1; - - first = false; - } - - /* increase width for current box */ - b.x1 = ib_x + ib_p_width + ib_b_right; - p.x1 = b.x1 < r.x1 ? b.x1 : r.x1; - - if (ib == box->inline_end) - /* reached end of BOX_INLINE span */ - break; - } - /* plot background and borders for last rectangle of - * the inline */ - if (!html_redraw_inline_background(x, ib_y, box, scale, &p, b, - first, true, &current_background_color, - &html->len_ctx, ctx)) - return false; - /* restore previous graphics window */ - if (ctx->plot->clip(ctx, &r) != NSERROR_OK) - return false; - if (!html_redraw_inline_borders(box, b, &r, scale, first, true, - ctx)) - return false; - - } - - /* Debug outlines */ - if (html_redraw_debug) { - int margin_left, margin_right; - int margin_top, margin_bottom; - if (scale == 1.0) { - /* avoid trivial fp maths */ - margin_left = box->margin[LEFT]; - margin_top = box->margin[TOP]; - margin_right = box->margin[RIGHT]; - margin_bottom = box->margin[BOTTOM]; - } else { - margin_left = box->margin[LEFT] * scale; - margin_top = box->margin[TOP] * scale; - margin_right = box->margin[RIGHT] * scale; - margin_bottom = box->margin[BOTTOM] * scale; - } - /* Content edge -- blue */ - rect.x0 = x + padding_left; - rect.y0 = y + padding_top; - rect.x1 = x + padding_left + width; - rect.y1 = y + padding_top + height; - if (ctx->plot->rectangle(ctx, plot_style_content_edge, &rect) != NSERROR_OK) - return false; - - /* Padding edge -- red */ - rect.x0 = x; - rect.y0 = y; - rect.x1 = x + padding_width; - rect.y1 = y + padding_height; - if (ctx->plot->rectangle(ctx, plot_style_padding_edge, &rect) != NSERROR_OK) - return false; - - /* Margin edge -- yellow */ - rect.x0 = x - border_left - margin_left; - rect.y0 = y - border_top - margin_top; - rect.x1 = x + padding_width + border_right + margin_right; - rect.y1 = y + padding_height + border_bottom + margin_bottom; - if (ctx->plot->rectangle(ctx, plot_style_margin_edge, &rect) != NSERROR_OK) - return false; - } - - /* clip to the padding edge for objects, or boxes with overflow hidden - * or scroll, unless it's the root element */ - if (box->parent != NULL) { - bool need_clip = false; - if (box->object || box->flags & IFRAME || - (overflow_x != CSS_OVERFLOW_VISIBLE && - overflow_y != CSS_OVERFLOW_VISIBLE)) { - r.x0 = x; - r.y0 = y; - r.x1 = x + padding_width; - r.y1 = y + padding_height; - if (r.x0 < clip->x0) r.x0 = clip->x0; - if (r.y0 < clip->y0) r.y0 = clip->y0; - if (clip->x1 < r.x1) r.x1 = clip->x1; - if (clip->y1 < r.y1) r.y1 = clip->y1; - if (r.x1 <= r.x0 || r.y1 <= r.y0) { - return (!ctx->plot->group_end || - (ctx->plot->group_end(ctx) == NSERROR_OK)); - } - need_clip = true; - - } else if (overflow_x != CSS_OVERFLOW_VISIBLE) { - r.x0 = x; - r.y0 = clip->y0; - r.x1 = x + padding_width; - r.y1 = clip->y1; - if (r.x0 < clip->x0) r.x0 = clip->x0; - if (clip->x1 < r.x1) r.x1 = clip->x1; - if (r.x1 <= r.x0) { - return (!ctx->plot->group_end || - (ctx->plot->group_end(ctx) == NSERROR_OK)); - } - need_clip = true; - - } else if (overflow_y != CSS_OVERFLOW_VISIBLE) { - r.x0 = clip->x0; - r.y0 = y; - r.x1 = clip->x1; - r.y1 = y + padding_height; - if (r.y0 < clip->y0) r.y0 = clip->y0; - if (clip->y1 < r.y1) r.y1 = clip->y1; - if (r.y1 <= r.y0) { - return (!ctx->plot->group_end || - (ctx->plot->group_end(ctx) == NSERROR_OK)); - } - need_clip = true; - } - - if (need_clip && - (box->type == BOX_BLOCK || - box->type == BOX_INLINE_BLOCK || - box->type == BOX_TABLE_CELL || box->object)) { - if (ctx->plot->clip(ctx, &r) != NSERROR_OK) - return false; - } - } - - /* text decoration */ - if ((box->type != BOX_TEXT) && - box->style && - css_computed_text_decoration(box->style) != CSS_TEXT_DECORATION_NONE) { - if (!html_redraw_text_decoration(box, x_parent, y_parent, - scale, current_background_color, ctx)) - return false; - } - - if (box->object && width != 0 && height != 0) { - struct content_redraw_data obj_data; - - x_scrolled = x - scrollbar_get_offset(box->scroll_x) * scale; - y_scrolled = y - scrollbar_get_offset(box->scroll_y) * scale; - - obj_data.x = x_scrolled + padding_left; - obj_data.y = y_scrolled + padding_top; - obj_data.width = width; - obj_data.height = height; - obj_data.background_colour = current_background_color; - obj_data.scale = scale; - obj_data.repeat_x = false; - obj_data.repeat_y = false; - - if (content_get_type(box->object) == CONTENT_HTML) { - obj_data.x /= scale; - obj_data.y /= scale; - } - - if (!content_redraw(box->object, &obj_data, &r, ctx)) { - /* Show image fail */ - /* Unicode (U+FFFC) 'OBJECT REPLACEMENT CHARACTER' */ - const char *obj = "\xef\xbf\xbc"; - int obj_width; - int obj_x = x + padding_left; - nserror res; - - rect.x0 = x + padding_left; - rect.y0 = y + padding_top; - rect.x1 = x + padding_left + width - 1; - rect.y1 = y + padding_top + height - 1; - res = ctx->plot->rectangle(ctx, plot_style_broken_object, &rect); - if (res != NSERROR_OK) { - return false; - } - - res = guit->layout->width(plot_fstyle_broken_object, - obj, - sizeof(obj) - 1, - &obj_width); - if (res != NSERROR_OK) { - obj_x += 1; - } else { - obj_x += width / 2 - obj_width / 2; - } - - if (ctx->plot->text(ctx, - plot_fstyle_broken_object, - obj_x, y + padding_top + (int)(height * 0.75), - obj, sizeof(obj) - 1) != NSERROR_OK) - return false; - } - - } else if (box->iframe) { - /* Offset is passed to browser window redraw unscaled */ - browser_window_redraw(box->iframe, - x + padding_left, - y + padding_top, &r, ctx); - - } else if (box->gadget && box->gadget->type == GADGET_CHECKBOX) { - if (!html_redraw_checkbox(x + padding_left, y + padding_top, - width, height, box->gadget->selected, ctx)) - return false; - - } else if (box->gadget && box->gadget->type == GADGET_RADIO) { - if (!html_redraw_radio(x + padding_left, y + padding_top, - width, height, box->gadget->selected, ctx)) - return false; - - } else if (box->gadget && box->gadget->type == GADGET_FILE) { - if (!html_redraw_file(x + padding_left, y + padding_top, - width, height, box, scale, - current_background_color, &html->len_ctx, ctx)) - return false; - - } else if (box->gadget && - (box->gadget->type == GADGET_TEXTAREA || - box->gadget->type == GADGET_PASSWORD || - box->gadget->type == GADGET_TEXTBOX)) { - textarea_redraw(box->gadget->data.text.ta, x, y, - current_background_color, scale, &r, ctx); - - } else if (box->text) { - if (!html_redraw_text_box(html, box, x, y, &r, scale, - current_background_color, ctx)) - return false; - - } else { - if (!html_redraw_box_children(html, box, x_parent, y_parent, &r, - scale, current_background_color, ctx)) - return false; - } - - if (box->type == BOX_BLOCK || box->type == BOX_INLINE_BLOCK || - box->type == BOX_TABLE_CELL || box->type == BOX_INLINE) - if (ctx->plot->clip(ctx, clip) != NSERROR_OK) - return false; - - /* list marker */ - if (box->list_marker) { - if (!html_redraw_box(html, box->list_marker, - x_parent + box->x - - scrollbar_get_offset(box->scroll_x), - y_parent + box->y - - scrollbar_get_offset(box->scroll_y), - clip, scale, current_background_color, ctx)) - return false; - } - - /* scrollbars */ - if (((box->style && box->type != BOX_BR && - box->type != BOX_TABLE && box->type != BOX_INLINE && - (box->gadget == NULL || box->gadget->type != GADGET_TEXTAREA) && - (overflow_x == CSS_OVERFLOW_SCROLL || - overflow_x == CSS_OVERFLOW_AUTO || - overflow_y == CSS_OVERFLOW_SCROLL || - overflow_y == CSS_OVERFLOW_AUTO)) || - (box->object && content_get_type(box->object) == - CONTENT_HTML)) && box->parent != NULL) { - nserror res; - bool has_x_scroll = (overflow_x == CSS_OVERFLOW_SCROLL); - bool has_y_scroll = (overflow_y == CSS_OVERFLOW_SCROLL); - - has_x_scroll |= (overflow_x == CSS_OVERFLOW_AUTO) && - box_hscrollbar_present(box); - has_y_scroll |= (overflow_y == CSS_OVERFLOW_AUTO) && - box_vscrollbar_present(box); - - res = box_handle_scrollbars((struct content *)html, - box, has_x_scroll, has_y_scroll); - if (res != NSERROR_OK) { - NSLOG(netsurf, INFO, "%s", messages_get_errorcode(res)); - return false; - } - - if (box->scroll_x != NULL) - scrollbar_redraw(box->scroll_x, - x_parent + box->x, - y_parent + box->y + box->padding[TOP] + - box->height + box->padding[BOTTOM] - - SCROLLBAR_WIDTH, clip, scale, ctx); - if (box->scroll_y != NULL) - scrollbar_redraw(box->scroll_y, - x_parent + box->x + box->padding[LEFT] + - box->width + box->padding[RIGHT] - - SCROLLBAR_WIDTH, - y_parent + box->y, clip, scale, ctx); - } - - if (box->type == BOX_BLOCK || box->type == BOX_INLINE_BLOCK || - box->type == BOX_TABLE_CELL || box->type == BOX_INLINE) { - if (ctx->plot->clip(ctx, clip) != NSERROR_OK) - return false; - } - - return ((!plot->group_end) || (ctx->plot->group_end(ctx) == NSERROR_OK)); -} - -/** - * Draw a CONTENT_HTML using the current set of plotters (plot). - * - * \param c content of type CONTENT_HTML - * \param data redraw data for this content redraw - * \param clip current clip region - * \param ctx current redraw context - * \return true if successful, false otherwise - * - * x, y, clip_[xy][01] are in target coordinates. - */ - -bool html_redraw(struct content *c, struct content_redraw_data *data, - const struct rect *clip, const struct redraw_context *ctx) -{ - html_content *html = (html_content *) c; - struct box *box; - bool result = true; - bool select, select_only; - plot_style_t pstyle_fill_bg = { - .fill_type = PLOT_OP_TYPE_SOLID, - .fill_colour = data->background_colour, - }; - - box = html->layout; - assert(box); - - /* The select menu needs special treating because, when opened, it - * reaches beyond its layout box. - */ - select = false; - select_only = false; - if (ctx->interactive && html->visible_select_menu != NULL) { - struct form_control *control = html->visible_select_menu; - select = true; - /* check if the redraw rectangle is completely inside of the - select menu */ - select_only = form_clip_inside_select_menu(control, - data->scale, clip); - } - - if (!select_only) { - /* clear to background colour */ - result = (ctx->plot->clip(ctx, clip) == NSERROR_OK); - - if (html->background_colour != NS_TRANSPARENT) - pstyle_fill_bg.fill_colour = html->background_colour; - - result &= (ctx->plot->rectangle(ctx, &pstyle_fill_bg, clip) == NSERROR_OK); - - result &= html_redraw_box(html, box, data->x, data->y, clip, - data->scale, pstyle_fill_bg.fill_colour, ctx); - } - - if (select) { - int menu_x, menu_y; - box = html->visible_select_menu->box; - box_coords(box, &menu_x, &menu_y); - - menu_x -= box->border[LEFT].width; - menu_y += box->height + box->border[BOTTOM].width + - box->padding[BOTTOM] + box->padding[TOP]; - result &= form_redraw_select_menu(html->visible_select_menu, - data->x + menu_x, data->y + menu_y, - data->scale, clip, ctx); - } - - return result; - -} diff --git a/content/handlers/html/html_redraw_border.c b/content/handlers/html/html_redraw_border.c deleted file mode 100644 index 0b3d858..0000000 --- a/content/handlers/html/html_redraw_border.c +++ /dev/null @@ -1,928 +0,0 @@ -/* - * Copyright 2017 Vincent Sanders <vince(a)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 - * - * Redrawing CONTENT_HTML borders implementation. - */ - -#include <stdbool.h> -#include <stdlib.h> - -#include "utils/log.h" -#include "netsurf/plotters.h" -#include "netsurf/css.h" - -#include "html/box.h" -#include "html/html_internal.h" - - -static plot_style_t plot_style_bdr = { - .stroke_type = PLOT_OP_TYPE_DASH, -}; -static plot_style_t plot_style_fillbdr = { - .fill_type = PLOT_OP_TYPE_SOLID, -}; -static plot_style_t plot_style_fillbdr_dark = { - .fill_type = PLOT_OP_TYPE_SOLID, -}; -static plot_style_t plot_style_fillbdr_light = { - .fill_type = PLOT_OP_TYPE_SOLID, -}; -static plot_style_t plot_style_fillbdr_ddark = { - .fill_type = PLOT_OP_TYPE_SOLID, -}; -static plot_style_t plot_style_fillbdr_dlight = { - .fill_type = PLOT_OP_TYPE_SOLID, -}; - - -static inline nserror -plot_clipped_rectangle(const struct redraw_context *ctx, - const plot_style_t *style, - const struct rect *clip, - struct rect *rect) -{ - nserror res; - - rect->x0 = (clip->x0 > rect->x0) ? clip->x0 : rect->x0; - rect->y0 = (clip->y0 > rect->y0) ? clip->y0 : rect->y0; - rect->x1 = (clip->x1 < rect->x1) ? clip->x1 : rect->x1; - rect->y1 = (clip->y1 < rect->y1) ? clip->y1 : rect->y1; - if ((rect->x0 < rect->x1) && (rect->y0 < rect->y1)) { - /* valid clip rectangles only */ - res = ctx->plot->rectangle(ctx, style, rect); - } else { - res = NSERROR_OK; - } - return res; -} - - -/** - * Draw one border. - * - * \param side index of border side (TOP, RIGHT, BOTTOM, LEFT) - * \param p array of precomputed border vertices - * \param c colour for border - * \param style border line style - * \param thickness border thickness - * \param rectangular whether border is rectangular - * \param clip cliping area for redrawing border. - * \param ctx current redraw context - * \return NSERROR_OK if successful otherwise appropriate error code - */ -static nserror -html_redraw_border_plot(const int side, - const int *p, - colour c, - enum css_border_style_e style, - int thickness, - bool rectangular, - const struct rect *clip, - const struct redraw_context *ctx) -{ - int z[8]; /* Vertices of border part */ - unsigned int light = side; - plot_style_t *plot_style_bdr_in; - plot_style_t *plot_style_bdr_out; - nserror res = NSERROR_OK; - struct rect rect; - - if (c == NS_TRANSPARENT) { - return res; - } - - plot_style_bdr.stroke_type = PLOT_OP_TYPE_DASH; - plot_style_bdr.stroke_colour = c; - plot_style_bdr.stroke_width = (thickness << PLOT_STYLE_RADIX); - plot_style_fillbdr.fill_colour = c; - plot_style_fillbdr_dark.fill_colour = darken_colour(c); - plot_style_fillbdr_light.fill_colour = lighten_colour(c); - plot_style_fillbdr_ddark.fill_colour = double_darken_colour(c); - plot_style_fillbdr_dlight.fill_colour = double_lighten_colour(c); - - switch (style) { - case CSS_BORDER_STYLE_DOTTED: - plot_style_bdr.stroke_type = PLOT_OP_TYPE_DOT; - /* fall through */ - case CSS_BORDER_STYLE_DASHED: - rect.x0 = (p[0] + p[2]) / 2; - rect.y0 = (p[1] + p[3]) / 2; - rect.x1 = (p[4] + p[6]) / 2; - rect.y1 = (p[5] + p[7]) / 2; - res = ctx->plot->line(ctx, &plot_style_bdr, &rect); - break; - - case CSS_BORDER_STYLE_SOLID: - /* fall through to default */ - default: - if (rectangular || thickness == 1) { - - if (side == TOP || side == RIGHT) { - rect.x0 = p[2]; - rect.y0 = p[3]; - if ((side == TOP) && - (p[4] - p[6] != 0)) { - rect.x1 = p[4]; - } else { - rect.x1 = p[6]; - } - rect.y1 = p[7]; - } else { - rect.x0 = p[6]; - rect.y0 = p[7]; - rect.x1 = p[2]; - if ((side == LEFT) && - (p[1] - p[3] != 0)) { - rect.y1 = p[1]; - } else { - rect.y1 = p[3]; - } - } - res = plot_clipped_rectangle(ctx, - &plot_style_fillbdr, - clip, - &rect); - } else { - res = ctx->plot->polygon(ctx, &plot_style_fillbdr, p, 4); - } - break; - - case CSS_BORDER_STYLE_DOUBLE: - z[0] = p[0]; - z[1] = p[1]; - z[2] = (p[0] * 2 + p[2]) / 3; - z[3] = (p[1] * 2 + p[3]) / 3; - z[4] = (p[6] * 2 + p[4]) / 3; - z[5] = (p[7] * 2 + p[5]) / 3; - z[6] = p[6]; - z[7] = p[7]; - res = ctx->plot->polygon(ctx, &plot_style_fillbdr, z, 4); - if (res == NSERROR_OK) { - z[0] = p[2]; - z[1] = p[3]; - z[2] = (p[2] * 2 + p[0]) / 3; - z[3] = (p[3] * 2 + p[1]) / 3; - z[4] = (p[4] * 2 + p[6]) / 3; - z[5] = (p[5] * 2 + p[7]) / 3; - z[6] = p[4]; - z[7] = p[5]; - res = ctx->plot->polygon(ctx, &plot_style_fillbdr, z, 4); - } - break; - - case CSS_BORDER_STYLE_GROOVE: - light = 3 - light; - /* fall through */ - case CSS_BORDER_STYLE_RIDGE: - /* choose correct colours for each part of the border line */ - if (light <= 1) { - plot_style_bdr_in = &plot_style_fillbdr_dark; - plot_style_bdr_out = &plot_style_fillbdr_light; - } else { - plot_style_bdr_in = &plot_style_fillbdr_light; - plot_style_bdr_out = &plot_style_fillbdr_dark; - } - - /* Render border */ - if ((rectangular || thickness == 2) && thickness != 1) { - /* Border made up from two parts and can be - * plotted with rectangles - */ - - /* First part */ - if (side == TOP || side == RIGHT) { - rect.x0 = (p[0] + p[2]) / 2; - rect.y0 = (p[1] + p[3]) / 2; - rect.x1 = p[6]; - rect.y1 = p[7]; - } else { - rect.x0 = p[6]; - rect.y0 = p[7]; - rect.x1 = (p[0] + p[2]) / 2; - rect.y1 = (p[1] + p[3]) / 2; - } - res = plot_clipped_rectangle(ctx, - plot_style_bdr_in, - clip, - &rect); - if (res != NSERROR_OK) { - return res; - } - - /* Second part */ - if (side == TOP || side == RIGHT) { - rect.x0 = p[2]; - rect.y0 = p[3]; - rect.x1 = (p[6] + p[4]) / 2; - rect.y1 = (p[7] + p[5]) / 2; - } else { - rect.x0 = (p[6] + p[4]) / 2; - rect.y0 = (p[7] + p[5]) / 2; - rect.x1 = p[2]; - rect.y1 = p[3]; - } - res = plot_clipped_rectangle(ctx, - plot_style_bdr_out, - clip, - &rect); - } else if (thickness == 1) { - /* Border made up from one part which can be - * plotted as a rectangle - */ - - if (side == TOP || side == RIGHT) { - rect.x0 = p[2]; - rect.y0 = p[3]; - rect.x1 = p[6]; - rect.y1 = p[7]; - rect.x1 = ((side == TOP) && (p[4] - p[6] != 0)) ? - rect.x1 + p[4] - p[6] : rect.x1; - - res = plot_clipped_rectangle(ctx, - plot_style_bdr_in, - clip, - &rect); - } else { - rect.x0 = p[6]; - rect.y0 = p[7]; - rect.x1 = p[2]; - rect.y1 = p[3]; - rect.y1 = ((side == LEFT) && (p[1] - p[3] != 0)) ? - rect.y1 + p[1] - p[3] : rect.y1; - res = plot_clipped_rectangle(ctx, - plot_style_bdr_out, - clip, - &rect); - } - } else { - /* Border made up from two parts and can't be - * plotted with rectangles - */ - z[0] = p[0]; - z[1] = p[1]; - z[2] = (p[0] + p[2]) / 2; - z[3] = (p[1] + p[3]) / 2; - z[4] = (p[6] + p[4]) / 2; - z[5] = (p[7] + p[5]) / 2; - z[6] = p[6]; - z[7] = p[7]; - res = ctx->plot->polygon(ctx, plot_style_bdr_in, z, 4); - if (res == NSERROR_OK) { - z[0] = p[2]; - z[1] = p[3]; - z[6] = p[4]; - z[7] = p[5]; - res = ctx->plot->polygon(ctx, - plot_style_bdr_out, - z, - 4); - } - } - break; - - case CSS_BORDER_STYLE_INSET: - light = (light + 2) % 4; - /* fall through */ - case CSS_BORDER_STYLE_OUTSET: - /* choose correct colours for each part of the border line */ - switch (light) { - case 0: - plot_style_bdr_in = &plot_style_fillbdr_light; - plot_style_bdr_out = &plot_style_fillbdr_dlight; - break; - case 1: - plot_style_bdr_in = &plot_style_fillbdr_ddark; - plot_style_bdr_out = &plot_style_fillbdr_dark; - break; - case 2: - plot_style_bdr_in = &plot_style_fillbdr_dark; - plot_style_bdr_out = &plot_style_fillbdr_ddark; - break; - case 3: - plot_style_bdr_in = &plot_style_fillbdr_dlight; - plot_style_bdr_out = &plot_style_fillbdr_light; - break; - default: - plot_style_bdr_in = &plot_style_fillbdr; - plot_style_bdr_out = &plot_style_fillbdr; - break; - } - - /* Render border */ - if ((rectangular || thickness == 2) && thickness != 1) { - /* Border made up from two parts and can be - * plotted with rectangles - */ - - /* First part */ - if (side == TOP || side == RIGHT) { - rect.x0 = (p[0] + p[2]) / 2; - rect.y0 = (p[1] + p[3]) / 2; - rect.x1 = p[6]; - rect.y1 = p[7]; - } else { - rect.x0 = p[6]; - rect.y0 = p[7]; - rect.x1 = (p[0] + p[2]) / 2; - rect.y1 = (p[1] + p[3]) / 2; - } - res = plot_clipped_rectangle(ctx, - plot_style_bdr_in, - clip, - &rect); - if (res != NSERROR_OK) { - return res; - } - - /* Second part */ - if (side == TOP || side == RIGHT) { - rect.x0 = p[2]; - rect.y0 = p[3]; - rect.x1 = (p[6] + p[4]) / 2; - rect.y1 = (p[7] + p[5]) / 2; - } else { - rect.x0 = (p[6] + p[4]) / 2; - rect.y0 = (p[7] + p[5]) / 2; - rect.x1 = p[2]; - rect.y1 = p[3]; - } - res = plot_clipped_rectangle(ctx, - plot_style_bdr_out, - clip, - &rect); - } else if (thickness == 1) { - /* Border made up from one part which can be - * plotted as a rectangle - */ - - if (side == TOP || side == RIGHT) { - rect.x0 = p[2]; - rect.y0 = p[3]; - rect.x1 = p[6]; - rect.y1 = p[7]; - rect.x1 = ((side == TOP) && (p[4] - p[6] != 0)) ? - rect.x1 + p[4] - p[6] : rect.x1; - res = plot_clipped_rectangle(ctx, - plot_style_bdr_in, - clip, - &rect); - } else { - rect.x0 = p[6]; - rect.y0 = p[7]; - rect.x1 = p[2]; - rect.y1 = p[3]; - rect.y1 = ((side == LEFT) && (p[1] - p[3] != 0)) ? - rect.y1 + p[1] - p[3] : rect.y1; - res = plot_clipped_rectangle(ctx, - plot_style_bdr_out, - clip, - &rect); - } - } else { - /* Border made up from two parts and can't be - * plotted with rectangles - */ - - z[0] = p[0]; - z[1] = p[1]; - z[2] = (p[0] + p[2]) / 2; - z[3] = (p[1] + p[3]) / 2; - z[4] = (p[6] + p[4]) / 2; - z[5] = (p[7] + p[5]) / 2; - z[6] = p[6]; - z[7] = p[7]; - res = ctx->plot->polygon(ctx, plot_style_bdr_in, z, 4); - if (res != NSERROR_OK) { - return res; - } - z[0] = p[2]; - z[1] = p[3]; - z[6] = p[4]; - z[7] = p[5]; - res = ctx->plot->polygon(ctx, plot_style_bdr_out, z, 4); - } - break; - } - - return res; -} - - -/** - * Draw borders for a box. - * - * \param box box to draw - * \param x_parent coordinate of left padding edge of parent of box - * \param y_parent coordinate of top padding edge of parent of box - * \param p_width width of padding box - * \param p_height height of padding box - * \param clip cliping area for redrawing border. - * \param scale scale for redraw - * \param ctx current redraw context - * \return true if successful, false otherwise - */ -bool -html_redraw_borders(struct box *box, - int x_parent, - int y_parent, - int p_width, - int p_height, - const struct rect *clip, - float scale, - const struct redraw_context *ctx) -{ - unsigned int sides[] = { LEFT, RIGHT, TOP, BOTTOM }; - int top = box->border[TOP].width; - int right = box->border[RIGHT].width; - int bottom = box->border[BOTTOM].width; - int left = box->border[LEFT].width; - int x, y; - unsigned int i, side; - int p[8]; /* Box border vertices */ - int z[8]; /* Border vertices */ - bool square_end_1 = false; - bool square_end_2 = false; - nserror res; - - x = x_parent + box->x; - y = y_parent + box->y; - - if (scale != 1.0) { - top *= scale; - right *= scale; - bottom *= scale; - left *= scale; - x *= scale; - y *= scale; - } - - assert(box->style); - - /* Calculate border vertices - * - * A----------------------+ - * | \ / | - * | B--------------+ | - * | | | | - * | +--------------C | - * | / \ | - * +----------------------D - */ - p[0] = x - left; p[1] = y - top; /* A */ - p[2] = x; p[3] = y; /* B */ - p[4] = x + p_width; p[5] = y + p_height; /* C */ - p[6] = x + p_width + right; p[7] = y + p_height + bottom; /* D */ - - for (i = 0; i != 4; i++) { - colour col = 0; - side = sides[i]; /* plot order */ - - if (box->border[side].width == 0 || - nscss_color_is_transparent(box->border[side].c)) { - continue; - } - - switch (side) { - case LEFT: - square_end_1 = (top == 0); - square_end_2 = (bottom == 0); - - z[0] = p[0]; z[1] = p[7]; - z[2] = p[2]; z[3] = p[5]; - z[4] = p[2]; z[5] = p[3]; - z[6] = p[0]; z[7] = p[1]; - - if (nscss_color_is_transparent(box->border[TOP].c) == false && - box->border[TOP].style != CSS_BORDER_STYLE_DOUBLE) { - /* make border overhang top corner fully, - * if top border is opaque - */ - z[5] -= top; - square_end_1 = true; - } - if (nscss_color_is_transparent(box->border[BOTTOM].c) == false && - box->border[BOTTOM].style != CSS_BORDER_STYLE_DOUBLE) { - /* make border overhang bottom corner fully, - * if bottom border is opaque - */ - z[3] += bottom; - square_end_2 = true; - } - - col = nscss_color_to_ns(box->border[side].c); - - res = html_redraw_border_plot(side, - z, - col, - box->border[side].style, - box->border[side].width * scale, - square_end_1 && square_end_2, - clip, - ctx); - if (res != NSERROR_OK) { - return false; - } - break; - - case RIGHT: - square_end_1 = (top == 0); - square_end_2 = (bottom == 0); - - z[0] = p[6]; z[1] = p[1]; - z[2] = p[4]; z[3] = p[3]; - z[4] = p[4]; z[5] = p[5]; - z[6] = p[6]; z[7] = p[7]; - - if (nscss_color_is_transparent(box->border[TOP].c) == false && - box->border[TOP].style != CSS_BORDER_STYLE_DOUBLE) { - /* make border overhang top corner fully, - * if top border is opaque - */ - z[3] -= top; - square_end_1 = true; - } - if (nscss_color_is_transparent(box->border[BOTTOM].c) == false && - box->border[BOTTOM].style != CSS_BORDER_STYLE_DOUBLE) { - /* make border overhang bottom corner fully, - * if bottom border is opaque - */ - z[5] += bottom; - square_end_2 = true; - } - - col = nscss_color_to_ns(box->border[side].c); - - res = html_redraw_border_plot(side, - z, - col, - box->border[side].style, - box->border[side].width * scale, - square_end_1 && square_end_2, - clip, - ctx); - if (res != NSERROR_OK) { - return false; - } - break; - - case TOP: - if (clip->y0 > p[3]) { - /* clip rectangle is below border; nothing to - * plot - */ - continue; - } - - square_end_1 = (left == 0); - square_end_2 = (right == 0); - - z[0] = p[2]; z[1] = p[3]; - z[2] = p[0]; z[3] = p[1]; - z[4] = p[6]; z[5] = p[1]; - z[6] = p[4]; z[7] = p[3]; - - if (box->border[TOP].style == CSS_BORDER_STYLE_SOLID && - box->border[TOP].c == box->border[LEFT].c) { - /* don't bother overlapping left corner if - * it's the same colour anyway - */ - z[2] += left; - square_end_1 = true; - } - if (box->border[TOP].style == CSS_BORDER_STYLE_SOLID && - box->border[TOP].c == box->border[RIGHT].c) { - /* don't bother overlapping right corner if - * it's the same colour anyway - */ - z[4] -= right; - square_end_2 = true; - } - - col = nscss_color_to_ns(box->border[side].c); - - res = html_redraw_border_plot(side, - z, - col, - box->border[side].style, - box->border[side].width * scale, - square_end_1 && square_end_2, - clip, - ctx); - if (res != NSERROR_OK) { - return false; - } - break; - - case BOTTOM: - if (clip->y1 < p[5]) { - /* clip rectangle is above border; nothing to - * plot - */ - continue; - } - - square_end_1 = (left == 0); - square_end_2 = (right == 0); - - z[0] = p[4]; z[1] = p[5]; - z[2] = p[6]; z[3] = p[7]; - z[4] = p[0]; z[5] = p[7]; - z[6] = p[2]; z[7] = p[5]; - - if (box->border[BOTTOM].style == CSS_BORDER_STYLE_SOLID && - box->border[BOTTOM].c == box->border[LEFT].c) { - /* don't bother overlapping left corner if - * it's the same colour anyway - */ - z[4] += left; - square_end_1 = true; - } - if (box->border[BOTTOM].style == CSS_BORDER_STYLE_SOLID && - box->border[BOTTOM].c == box->border[RIGHT].c) { - /* don't bother overlapping right corner if - * it's the same colour anyway - */ - z[2] -= right; - square_end_2 = true; - } - - col = nscss_color_to_ns(box->border[side].c); - - res = html_redraw_border_plot(side, - z, - col, - box->border[side].style, - box->border[side].width * scale, - square_end_1 && square_end_2, - clip, - ctx); - if (res != NSERROR_OK) { - return false; - } - break; - - default: - assert(side == TOP || side == BOTTOM || - side == LEFT || side == RIGHT); - break; - } - } - - return true; -} - - -/** - * Draw an inline's borders. - * - * \param box BOX_INLINE which created the border - * \param b coordinates of border edge rectangle - * \param clip cliping area for redrawing border. - * \param scale scale for redraw - * \param first true if this is the first rectangle associated with the inline - * \param last true if this is the last rectangle associated with the inline - * \param ctx current redraw context - * \return true if successful, false otherwise - */ -bool -html_redraw_inline_borders(struct box *box, - struct rect b, - const struct rect *clip, - float scale, - bool first, - bool last, - const struct redraw_context *ctx) -{ - int top = box->border[TOP].width; - int right = box->border[RIGHT].width; - int bottom = box->border[BOTTOM].width; - int left = box->border[LEFT].width; - colour col; - int p[8]; /* Box border vertices */ - int z[8]; /* Border vertices */ - bool square_end_1; - bool square_end_2; - nserror res; - - if (scale != 1.0) { - top *= scale; - right *= scale; - bottom *= scale; - left *= scale; - } - - /* Calculate border vertices - * - * A----------------------+ - * | \ / | - * | B--------------+ | - * | | | | - * | +--------------C | - * | / \ | - * +----------------------D - */ - p[0] = b.x0; p[1] = b.y0; /* A */ - p[2] = first ? b.x0 + left : b.x0; p[3] = b.y0 + top; /* B */ - p[4] = last ? b.x1 - right : b.x1; p[5] = b.y1 - bottom; /* C */ - p[6] = b.x1; p[7] = b.y1; /* D */ - - assert(box->style); - - /* Left */ - square_end_1 = (top == 0); - square_end_2 = (bottom == 0); - if (left != 0 && - first && - nscss_color_is_transparent(box->border[LEFT].c) == false) { - col = nscss_color_to_ns(box->border[LEFT].c); - - z[0] = p[0]; z[1] = p[7]; - z[2] = p[2]; z[3] = p[5]; - z[4] = p[2]; z[5] = p[3]; - z[6] = p[0]; z[7] = p[1]; - - if (nscss_color_is_transparent(box->border[TOP].c) == false && - box->border[TOP].style != CSS_BORDER_STYLE_DOUBLE) { - /* make border overhang top corner fully, - * if top border is opaque - */ - z[5] -= top; - square_end_1 = true; - } - - if (nscss_color_is_transparent(box->border[BOTTOM].c) == false && - box->border[BOTTOM].style != CSS_BORDER_STYLE_DOUBLE) { - /* make border overhang bottom corner fully, - * if bottom border is opaque - */ - z[3] += bottom; - square_end_2 = true; - } - - res = html_redraw_border_plot(LEFT, - z, - col, - box->border[LEFT].style, - left, - square_end_1 && square_end_2, - clip, - ctx); - if (res != NSERROR_OK) { - return false; - } - } - - /* Right */ - square_end_1 = (top == 0); - square_end_2 = (bottom == 0); - if (right != 0 && - last && - nscss_color_is_transparent(box->border[RIGHT].c) == false) { - col = nscss_color_to_ns(box->border[RIGHT].c); - - z[0] = p[6]; z[1] = p[1]; - z[2] = p[4]; z[3] = p[3]; - z[4] = p[4]; z[5] = p[5]; - z[6] = p[6]; z[7] = p[7]; - - if (nscss_color_is_transparent(box->border[TOP].c) == false && - box->border[TOP].style != CSS_BORDER_STYLE_DOUBLE) { - /* make border overhang top corner fully, - * if top border is opaque - */ - z[3] -= top; - square_end_1 = true; - } - - if (nscss_color_is_transparent(box->border[BOTTOM].c) == false && - box->border[BOTTOM].style != CSS_BORDER_STYLE_DOUBLE) { - /* make border overhang bottom corner fully, - * if bottom border is opaque - */ - z[5] += bottom; - square_end_2 = true; - } - - res = html_redraw_border_plot(RIGHT, - z, - col, - box->border[RIGHT].style, - right, - square_end_1 && square_end_2, - clip, - ctx); - if (res != NSERROR_OK) { - return false; - } - } - - /* Top */ - square_end_1 = (left == 0); - square_end_2 = (right == 0); - if (top != 0 && - nscss_color_is_transparent(box->border[TOP].c) == false) { - col = nscss_color_to_ns(box->border[TOP].c); - - z[0] = p[2]; z[1] = p[3]; - z[2] = p[0]; z[3] = p[1]; - z[4] = p[6]; z[5] = p[1]; - z[6] = p[4]; z[7] = p[3]; - - if (first && - box->border[TOP].style == CSS_BORDER_STYLE_SOLID && - box->border[TOP].c == box->border[LEFT].c) { - /* don't bother overlapping left corner if - * it's the same colour anyway - */ - z[2] += left; - square_end_1 = true; - } - - if (last && - box->border[TOP].style == CSS_BORDER_STYLE_SOLID && - box->border[TOP].c == box->border[RIGHT].c) { - /* don't bother overlapping right corner if - * it's the same colour anyway - */ - z[4] -= right; - square_end_2 = true; - } - - res = html_redraw_border_plot(TOP, - z, - col, - box->border[TOP].style, - top, - square_end_1 && square_end_2, - clip, - ctx); - if (res != NSERROR_OK) { - return false; - } - } - - /* Bottom */ - square_end_1 = (left == 0); - square_end_2 = (right == 0); - if (bottom != 0 && - nscss_color_is_transparent(box->border[BOTTOM].c) == false) { - col = nscss_color_to_ns(box->border[BOTTOM].c); - - z[0] = p[4]; z[1] = p[5]; - z[2] = p[6]; z[3] = p[7]; - z[4] = p[0]; z[5] = p[7]; - z[6] = p[2]; z[7] = p[5]; - - if (first && - box->border[BOTTOM].style == CSS_BORDER_STYLE_SOLID && - box->border[BOTTOM].c == box->border[LEFT].c) { - /* don't bother overlapping left corner if - * it's the same colour anyway - */ - z[4] += left; - square_end_1 = true; - } - - if (last && - box->border[BOTTOM].style == CSS_BORDER_STYLE_SOLID && - box->border[BOTTOM].c == box->border[RIGHT].c) { - /* don't bother overlapping right corner if - * it's the same colour anyway - */ - z[2] -= right; - square_end_2 = true; - } - - res = html_redraw_border_plot(BOTTOM, - z, - col, - box->border[BOTTOM].style, - bottom, - square_end_1 && square_end_2, - clip, - ctx); - if (res != NSERROR_OK) { - return false; - } - } - - return true; -} diff --git a/content/handlers/html/html_script.c b/content/handlers/html/html_script.c deleted file mode 100644 index 81bdccd..0000000 --- a/content/handlers/html/html_script.c +++ /dev/null @@ -1,666 +0,0 @@ -/* - * Copyright 2012 Vincent Sanders <vince(a)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 - * implementation of content handling for text/html scripts. - */ - -#include <assert.h> -#include <ctype.h> -#include <stdint.h> -#include <stdbool.h> -#include <string.h> -#include <strings.h> -#include <stdlib.h> - -#include "utils/config.h" -#include "utils/corestrings.h" -#include "utils/log.h" -#include "utils/messages.h" -#include "netsurf/content.h" -#include "javascript/js.h" -#include "content/content_protected.h" -#include "content/fetch.h" -#include "content/hlcache.h" - -#include "html/html.h" -#include "html/html_internal.h" - -typedef bool (script_handler_t)(struct jsthread *jsthread, const uint8_t *data, size_t size, const char *name); - - -static script_handler_t *select_script_handler(content_type ctype) -{ - if (ctype == CONTENT_JS) { - return js_exec; - } - return NULL; -} - - -/* exported internal interface documented in html/html_internal.h */ -nserror html_script_exec(html_content *c, bool allow_defer) -{ - unsigned int i; - struct html_script *s; - script_handler_t *script_handler; - bool have_run_something = false; - - if (c->jsthread == NULL) { - return NSERROR_BAD_PARAMETER; - } - - for (i = 0, s = c->scripts; i != c->scripts_count; i++, s++) { - if (s->already_started) { - continue; - } - - if ((s->type == HTML_SCRIPT_ASYNC) || - (allow_defer && (s->type == HTML_SCRIPT_DEFER))) { - /* ensure script content is present */ - if (s->data.handle == NULL) - continue; - - /* ensure script content fetch status is not an error */ - if (content_get_status(s->data.handle) == - CONTENT_STATUS_ERROR) - continue; - - /* ensure script handler for content type */ - script_handler = select_script_handler( - content_get_type(s->data.handle)); - if (script_handler == NULL) - continue; /* unsupported type */ - - if (content_get_status(s->data.handle) == - CONTENT_STATUS_DONE) { - /* external script is now available */ - const uint8_t *data; - size_t size; - data = content_get_source_data( - s->data.handle, &size ); - script_handler(c->jsthread, data, size, - nsurl_access(hlcache_handle_get_url(s->data.handle))); - have_run_something = true; - /* We have to re-acquire this here since the - * c->scripts array may have been reallocated - * as a result of executing this script. - */ - s = &(c->scripts[i]); - - s->already_started = true; - - } - } - } - - if (have_run_something) { - return html_proceed_to_done(c); - } - - return NSERROR_OK; -} - -/* create new html script entry */ -static struct html_script * -html_process_new_script(html_content *c, - dom_string *mimetype, - enum html_script_type type) -{ - struct html_script *nscript; - /* add space for new script entry */ - nscript = realloc(c->scripts, - sizeof(struct html_script) * (c->scripts_count + 1)); - if (nscript == NULL) { - return NULL; - } - - c->scripts = nscript; - - /* increment script entry count */ - nscript = &c->scripts[c->scripts_count]; - c->scripts_count++; - - nscript->already_started = false; - nscript->parser_inserted = false; - nscript->force_async = true; - nscript->ready_exec = false; - nscript->async = false; - nscript->defer = false; - - nscript->type = type; - - nscript->mimetype = dom_string_ref(mimetype); /* reference mimetype */ - - return nscript; -} - -/** - * Callback for asyncronous scripts - */ -static nserror -convert_script_async_cb(hlcache_handle *script, - const hlcache_event *event, - void *pw) -{ - html_content *parent = pw; - unsigned int i; - struct html_script *s; - - /* Find script */ - for (i = 0, s = parent->scripts; i != parent->scripts_count; i++, s++) { - if (s->type == HTML_SCRIPT_ASYNC && s->data.handle == script) - break; - } - - assert(i != parent->scripts_count); - - switch (event->type) { - case CONTENT_MSG_LOADING: - break; - - case CONTENT_MSG_READY: - break; - - case CONTENT_MSG_DONE: - NSLOG(netsurf, INFO, "script %d done '%s'", i, - nsurl_access(hlcache_handle_get_url(script))); - parent->base.active--; - NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); - - break; - - case CONTENT_MSG_ERROR: - NSLOG(netsurf, INFO, "script %s failed: %s", - nsurl_access(hlcache_handle_get_url(script)), - event->data.errordata.errormsg); - - hlcache_handle_release(script); - s->data.handle = NULL; - parent->base.active--; - NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); - content_add_error(&parent->base, "?", 0); - - break; - - default: - break; - } - - /* if there are no active fetches remaining begin post parse - * conversion - */ - if (html_can_begin_conversion(parent)) { - html_begin_conversion(parent); - } - - /* if we have already started converting though, then we can handle the - * scripts as they come in. - */ - else if (parent->conversion_begun) { - return html_script_exec(parent, false); - } - - return NSERROR_OK; -} - -/** - * Callback for defer scripts - */ -static nserror -convert_script_defer_cb(hlcache_handle *script, - const hlcache_event *event, - void *pw) -{ - html_content *parent = pw; - unsigned int i; - struct html_script *s; - - /* Find script */ - for (i = 0, s = parent->scripts; i != parent->scripts_count; i++, s++) { - if (s->type == HTML_SCRIPT_DEFER && s->data.handle == script) - break; - } - - assert(i != parent->scripts_count); - - switch (event->type) { - - case CONTENT_MSG_DONE: - NSLOG(netsurf, INFO, "script %d done '%s'", i, - nsurl_access(hlcache_handle_get_url(script))); - parent->base.active--; - NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); - - break; - - case CONTENT_MSG_ERROR: - NSLOG(netsurf, INFO, "script %s failed: %s", - nsurl_access(hlcache_handle_get_url(script)), - event->data.errordata.errormsg); - - hlcache_handle_release(script); - s->data.handle = NULL; - parent->base.active--; - NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); - content_add_error(&parent->base, "?", 0); - - break; - - default: - break; - } - - /* if there are no active fetches remaining begin post parse - * conversion - */ - if (html_can_begin_conversion(parent)) { - html_begin_conversion(parent); - } - - return NSERROR_OK; -} - -/** - * Callback for syncronous scripts - */ -static nserror -convert_script_sync_cb(hlcache_handle *script, - const hlcache_event *event, - void *pw) -{ - html_content *parent = pw; - unsigned int i; - struct html_script *s; - script_handler_t *script_handler; - dom_hubbub_error err; - unsigned int active_sync_scripts = 0; - - /* Count sync scripts which have yet to complete (other than us) */ - for (i = 0, s = parent->scripts; i != parent->scripts_count; i++, s++) { - if (s->type == HTML_SCRIPT_SYNC && - s->data.handle != script && s->already_started == false) { - active_sync_scripts++; - } - } - - /* Find script */ - for (i = 0, s = parent->scripts; i != parent->scripts_count; i++, s++) { - if (s->type == HTML_SCRIPT_SYNC && s->data.handle == script) - break; - } - - assert(i != parent->scripts_count); - - switch (event->type) { - case CONTENT_MSG_DONE: - NSLOG(netsurf, INFO, "script %d done '%s'", i, - nsurl_access(hlcache_handle_get_url(script))); - parent->base.active--; - NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); - - s->already_started = true; - - /* attempt to execute script */ - script_handler = select_script_handler(content_get_type(s->data.handle)); - if (script_handler != NULL && parent->jsthread != NULL) { - /* script has a handler */ - const uint8_t *data; - size_t size; - data = content_get_source_data(s->data.handle, &size ); - script_handler(parent->jsthread, data, size, - nsurl_access(hlcache_handle_get_url(s->data.handle))); - } - - /* continue parse */ - if (parent->parser != NULL && active_sync_scripts == 0) { - err = dom_hubbub_parser_pause(parent->parser, false); - if (err != DOM_HUBBUB_OK) { - NSLOG(netsurf, INFO, "unpause returned 0x%x", err); - } - } - - break; - - case CONTENT_MSG_ERROR: - NSLOG(netsurf, INFO, "script %s failed: %s", - nsurl_access(hlcache_handle_get_url(script)), - event->data.errordata.errormsg); - - hlcache_handle_release(script); - s->data.handle = NULL; - parent->base.active--; - - NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); - content_add_error(&parent->base, "?", 0); - - s->already_started = true; - - /* continue parse */ - if (parent->parser != NULL && active_sync_scripts == 0) { - err = dom_hubbub_parser_pause(parent->parser, false); - if (err != DOM_HUBBUB_OK) { - NSLOG(netsurf, INFO, "unpause returned 0x%x", err); - } - } - - break; - - default: - break; - } - - /* if there are no active fetches remaining begin post parse - * conversion - */ - if (html_can_begin_conversion(parent)) { - html_begin_conversion(parent); - } - - return NSERROR_OK; -} - -/** - * process a script with a src tag - */ -static dom_hubbub_error -exec_src_script(html_content *c, - dom_node *node, - dom_string *mimetype, - dom_string *src) -{ - nserror ns_error; - nsurl *joined; - hlcache_child_context child; - struct html_script *nscript; - bool async; - bool defer; - enum html_script_type script_type; - hlcache_handle_callback script_cb; - dom_hubbub_error ret = DOM_HUBBUB_OK; - dom_exception exc; /* returned by libdom functions */ - - /* src url */ - ns_error = nsurl_join(c->base_url, dom_string_data(src), &joined); - if (ns_error != NSERROR_OK) { - content_broadcast_error(&c->base, NSERROR_NOMEM, NULL); - return DOM_HUBBUB_NOMEM; - } - - NSLOG(netsurf, INFO, "script %i '%s'", c->scripts_count, - nsurl_access(joined)); - - /* there are three ways to process the script tag at this point: - * - * Syncronously pause the parent parse and continue after - * the script has downloaded and executed. (default) - * Async Start the script downloading and execute it when it - * becomes available. - * Defered Start the script downloading and execute it when - * the page has completed parsing, may be set along - * with async where it is ignored. - */ - - /* we interpret the presence of the async and defer attribute - * as true and ignore its value, technically only the empty - * value or the attribute name itself are valid. However - * various browsers interpret this in various ways the most - * compatible approach is to be liberal and accept any - * value. Note setting the values to "false" still makes them true! - */ - exc = dom_element_has_attribute(node, corestring_dom_async, &async); - if (exc != DOM_NO_ERR) { - return DOM_HUBBUB_OK; /* dom error */ - } - - if (c->parse_completed) { - /* After parse completed, all scripts are essentially async */ - async = true; - defer = false; - } - - if (async) { - /* asyncronous script */ - script_type = HTML_SCRIPT_ASYNC; - script_cb = convert_script_async_cb; - - } else { - exc = dom_element_has_attribute(node, - corestring_dom_defer, &defer); - if (exc != DOM_NO_ERR) { - return DOM_HUBBUB_OK; /* dom error */ - } - - if (defer) { - /* defered script */ - script_type = HTML_SCRIPT_DEFER; - script_cb = convert_script_defer_cb; - } else { - /* syncronous script */ - script_type = HTML_SCRIPT_SYNC; - script_cb = convert_script_sync_cb; - } - } - - nscript = html_process_new_script(c, mimetype, script_type); - if (nscript == NULL) { - nsurl_unref(joined); - content_broadcast_error(&c->base, NSERROR_NOMEM, NULL); - return DOM_HUBBUB_NOMEM; - } - - /* set up child fetch encoding and quirks */ - child.charset = c->encoding; - child.quirks = c->base.quirks; - - ns_error = hlcache_handle_retrieve(joined, - 0, - content_get_url(&c->base), - NULL, - script_cb, - c, - &child, - CONTENT_SCRIPT, - &nscript->data.handle); - - - nsurl_unref(joined); - - if (ns_error != NSERROR_OK) { - /* @todo Deal with fetch error better. currently assume - * fetch never became active - */ - /* mark duff script fetch as already started */ - nscript->already_started = true; - NSLOG(netsurf, INFO, "Fetch failed with error %d", ns_error); - } else { - /* update base content active fetch count */ - c->base.active++; - NSLOG(netsurf, INFO, "%d fetches active", c->base.active); - - switch (script_type) { - case HTML_SCRIPT_SYNC: - ret = DOM_HUBBUB_HUBBUB_ERR | HUBBUB_PAUSED; - - case HTML_SCRIPT_ASYNC: - break; - - case HTML_SCRIPT_DEFER: - break; - - default: - assert(0); - } - } - - return ret; -} - -static dom_hubbub_error -exec_inline_script(html_content *c, dom_node *node, dom_string *mimetype) -{ - dom_string *script; - dom_exception exc; /* returned by libdom functions */ - struct lwc_string_s *lwcmimetype; - script_handler_t *script_handler; - struct html_script *nscript; - - /* does not appear to be a src so script is inline content */ - exc = dom_node_get_text_content(node, &script); - if ((exc != DOM_NO_ERR) || (script == NULL)) { - return DOM_HUBBUB_OK; /* no contents, skip */ - } - - nscript = html_process_new_script(c, mimetype, HTML_SCRIPT_INLINE); - if (nscript == NULL) { - dom_string_unref(script); - - content_broadcast_error(&c->base, NSERROR_NOMEM, NULL); - return DOM_HUBBUB_NOMEM; - - } - - nscript->data.string = script; - nscript->already_started = true; - - /* ensure script handler for content type */ - exc = dom_string_intern(mimetype, &lwcmimetype); - if (exc != DOM_NO_ERR) { - return DOM_HUBBUB_DOM; - } - - script_handler = select_script_handler(content_factory_type_from_mime_type(lwcmimetype)); - lwc_string_unref(lwcmimetype); - - if (script_handler != NULL) { - script_handler(c->jsthread, - (const uint8_t *)dom_string_data(script), - dom_string_byte_length(script), - "?inline script?"); - } - return DOM_HUBBUB_OK; -} - - -/** - * process script node parser callback - * - * - */ -dom_hubbub_error -html_process_script(void *ctx, dom_node *node) -{ - html_content *c = (html_content *)ctx; - dom_exception exc; /* returned by libdom functions */ - dom_string *src, *mimetype; - dom_hubbub_error err = DOM_HUBBUB_OK; - - /* ensure javascript context is available */ - /* We should only ever be here if scripting was enabled for this - * content so it's correct to make a javascript context if there - * isn't one already. */ - if (c->jsthread == NULL) { - union content_msg_data msg_data; - - msg_data.jsthread = &c->jsthread; - content_broadcast(&c->base, CONTENT_MSG_GETTHREAD, &msg_data); - NSLOG(netsurf, INFO, "javascript context %p ", c->jsthread); - if (c->jsthread == NULL) { - /* no context and it could not be created, abort */ - return DOM_HUBBUB_OK; - } - } - - NSLOG(netsurf, INFO, "content %p parser %p node %p", c, c->parser, - node); - - exc = dom_element_get_attribute(node, corestring_dom_type, &mimetype); - if (exc != DOM_NO_ERR || mimetype == NULL) { - mimetype = dom_string_ref(corestring_dom_text_javascript); - } - - exc = dom_element_get_attribute(node, corestring_dom_src, &src); - if (exc != DOM_NO_ERR || src == NULL) { - err = exec_inline_script(c, node, mimetype); - } else { - err = exec_src_script(c, node, mimetype, src); - dom_string_unref(src); - } - - dom_string_unref(mimetype); - - return err; -} - -/* exported internal interface documented in html/html_internal.h */ -bool html_saw_insecure_scripts(html_content *htmlc) -{ - struct html_script *s; - unsigned int i; - - for (i = 0, s = htmlc->scripts; i != htmlc->scripts_count; i++, s++) { - if (s->type == HTML_SCRIPT_INLINE) { - /* Inline scripts are no less secure than their - * containing HTML content - */ - continue; - } - if (s->data.handle == NULL) { - /* We've not begun loading this? */ - continue; - } - if (content_saw_insecure_objects(s->data.handle)) { - return true; - } - } - - return false; -} - -/* exported internal interface documented in html/html_internal.h */ -nserror html_script_free(html_content *html) -{ - unsigned int i; - - for (i = 0; i != html->scripts_count; i++) { - if (html->scripts[i].mimetype != NULL) { - dom_string_unref(html->scripts[i].mimetype); - } - - switch (html->scripts[i].type) { - case HTML_SCRIPT_INLINE: - if (html->scripts[i].data.string != NULL) { - dom_string_unref(html->scripts[i].data.string); - } - break; - case HTML_SCRIPT_SYNC: - /* fallthrough */ - case HTML_SCRIPT_ASYNC: - /* fallthrough */ - case HTML_SCRIPT_DEFER: - if (html->scripts[i].data.handle != NULL) { - hlcache_handle_release(html->scripts[i].data.handle); - } - break; - } - } - free(html->scripts); - - return NSERROR_OK; -} diff --git a/content/handlers/html/object.c b/content/handlers/html/object.c new file mode 100644 index 0000000..587c487 --- /dev/null +++ b/content/handlers/html/object.c @@ -0,0 +1,729 @@ +/* + * Copyright 2013 Vincent Sanders <vince(a)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 + * Processing for html content object operations. + */ + +#include <assert.h> +#include <ctype.h> +#include <stdint.h> +#include <string.h> +#include <strings.h> +#include <stdlib.h> +#include <nsutils/time.h> + +#include "utils/corestrings.h" +#include "utils/config.h" +#include "utils/log.h" +#include "utils/nsoption.h" +#include "netsurf/content.h" +#include "netsurf/misc.h" +#include "content/hlcache.h" +#include "css/utils.h" +#include "desktop/scrollbar.h" +#include "desktop/gui_internal.h" + +#include "html/html.h" +#include "html/box.h" +#include "html/box_inspect.h" +#include "html/html_internal.h" + +/* break reference loop */ +static void html_object_refresh(void *p); + +/** + * Retrieve objects used by HTML document + * + * \param h Content to retrieve objects from + * \param n Pointer to location to receive number of objects + * \return Pointer to list of objects + */ +struct content_html_object *html_get_objects(hlcache_handle *h, unsigned int *n) +{ + html_content *c = (html_content *) hlcache_handle_get_content(h); + + assert(c != NULL); + assert(n != NULL); + + *n = c->num_objects; + + return c->object_list; +} + +/** + * Handle object fetching or loading failure. + * + * \param box box containing object which failed to load + * \param content document of type CONTENT_HTML + * \param background the object was the background image for the box + */ + +static void +html_object_failed(struct box *box, html_content *content, bool background) +{ + /* Nothing to do */ + return; +} + +/** + * Update a box whose content has completed rendering. + */ + +static void +html_object_done(struct box *box, + hlcache_handle *object, + bool background) +{ + struct box *b; + + if (background) { + box->background = object; + return; + } + + box->object = object; + + /* Normalise the box type, now it has been replaced. */ + switch (box->type) { + case BOX_TABLE: + box->type = BOX_BLOCK; + break; + default: + /* TODO: Any other box types need mapping? */ + break; + } + + if (!(box->flags & REPLACE_DIM)) { + /* invalidate parent min, max widths */ + for (b = box; b; b = b->parent) + b->max_width = UNKNOWN_MAX_WIDTH; + + /* delete any clones of this box */ + while (box->next && (box->next->flags & CLONE)) { + /* box_free_box(box->next); */ + box->next = box->next->next; + } + } +} + +/** + * Callback for hlcache_handle_retrieve() for objects. + */ + +static nserror +html_object_callback(hlcache_handle *object, + const hlcache_event *event, + void *pw) +{ + struct content_html_object *o = pw; + html_content *c = (html_content *) o->parent; + int x, y; + struct box *box; + + box = o->box; + if (box == NULL && event->type != CONTENT_MSG_ERROR) { + return NSERROR_OK; + } + + switch (event->type) { + case CONTENT_MSG_LOADING: + if (c->base.status != CONTENT_STATUS_LOADING && c->bw != NULL) + content_open(object, + c->bw, &c->base, + box->object_params); + break; + + case CONTENT_MSG_READY: + if (content_can_reformat(object)) { + /* TODO: avoid knowledge of box internals here */ + content_reformat(object, false, + box->max_width != UNKNOWN_MAX_WIDTH ? + box->width : 0, + box->max_width != UNKNOWN_MAX_WIDTH ? + box->height : 0); + + /* Adjust parent content for new object size */ + html_object_done(box, object, o->background); + if (c->base.status == CONTENT_STATUS_READY || + c->base.status == CONTENT_STATUS_DONE) + content__reformat(&c->base, false, + c->base.available_width, + c->base.available_height); + } + break; + + case CONTENT_MSG_DONE: + c->base.active--; + NSLOG(netsurf, INFO, "%d fetches active", c->base.active); + + html_object_done(box, object, o->background); + + if (c->base.status != CONTENT_STATUS_LOADING && + box->flags & REPLACE_DIM) { + union content_msg_data data; + + if (c->had_initial_layout == false) { + break; + } + + if (!box_visible(box)) + break; + + box_coords(box, &x, &y); + + data.redraw.x = x + box->padding[LEFT]; + data.redraw.y = y + box->padding[TOP]; + data.redraw.width = box->width; + data.redraw.height = box->height; + + content_broadcast(&c->base, CONTENT_MSG_REDRAW, &data); + } + break; + + case CONTENT_MSG_ERROR: + hlcache_handle_release(object); + + o->content = NULL; + + if (box != NULL) { + c->base.active--; + NSLOG(netsurf, INFO, "%d fetches active", + c->base.active); + + content_add_error(&c->base, "?", 0); + html_object_failed(box, c, o->background); + } + break; + + case CONTENT_MSG_REDRAW: + if (c->base.status != CONTENT_STATUS_LOADING) { + union content_msg_data data = event->data; + + if (c->had_initial_layout == false) { + break; + } + + if (!box_visible(box)) + break; + + box_coords(box, &x, &y); + + if (object == box->background) { + /* Redraw request is for background */ + css_fixed hpos = 0, vpos = 0; + css_unit hunit = CSS_UNIT_PX; + css_unit vunit = CSS_UNIT_PX; + int width = box->padding[LEFT] + box->width + + box->padding[RIGHT]; + int height = box->padding[TOP] + box->height + + box->padding[BOTTOM]; + int t, h, l, w; + + /* Need to know background-position */ + css_computed_background_position(box->style, + &hpos, &hunit, &vpos, &vunit); + + w = content_get_width(box->background); + if (hunit == CSS_UNIT_PCT) { + l = (width - w) * hpos / INTTOFIX(100); + } else { + l = FIXTOINT(nscss_len2px(&c->len_ctx, + hpos, hunit, + box->style)); + } + + h = content_get_height(box->background); + if (vunit == CSS_UNIT_PCT) { + t = (height - h) * vpos / INTTOFIX(100); + } else { + t = FIXTOINT(nscss_len2px(&c->len_ctx, + vpos, vunit, + box->style)); + } + + /* Redraw area depends on background-repeat */ + switch (css_computed_background_repeat( + box->style)) { + case CSS_BACKGROUND_REPEAT_REPEAT: + data.redraw.x = 0; + data.redraw.y = 0; + data.redraw.width = box->width; + data.redraw.height = box->height; + break; + + case CSS_BACKGROUND_REPEAT_REPEAT_X: + data.redraw.x = 0; + data.redraw.y += t; + data.redraw.width = box->width; + break; + + case CSS_BACKGROUND_REPEAT_REPEAT_Y: + data.redraw.x += l; + data.redraw.y = 0; + data.redraw.height = box->height; + break; + + case CSS_BACKGROUND_REPEAT_NO_REPEAT: + data.redraw.x += l; + data.redraw.y += t; + break; + + default: + break; + } + + /* Add offset to box */ + data.redraw.x += x; + data.redraw.y += y; + + } else { + /* Non-background case */ + int w = content_get_width(object); + int h = content_get_height(object); + + if (w != 0 && box->width != w) { + /* Not showing image at intrinsic + * width; need to scale the redraw + * request area. */ + data.redraw.x = data.redraw.x * + box->width / w; + data.redraw.width = + data.redraw.width * + box->width / w; + } + + if (h != 0 && box->height != w) { + /* Not showing image at intrinsic + * height; need to scale the redraw + * request area. */ + data.redraw.y = data.redraw.y * + box->height / h; + data.redraw.height = + data.redraw.height * + box->height / h; + } + + data.redraw.x += x + box->padding[LEFT]; + data.redraw.y += y + box->padding[TOP]; + } + + content_broadcast(&c->base, CONTENT_MSG_REDRAW, &data); + } + break; + + case CONTENT_MSG_REFRESH: + if (content_get_type(object) == CONTENT_HTML) { + /* only for HTML objects */ + guit->misc->schedule(event->data.delay * 1000, + html_object_refresh, o); + } + + break; + + case CONTENT_MSG_LINK: + /* Don't care about favicons that aren't on top level content */ + break; + + case CONTENT_MSG_GETTHREAD: + /* Objects don't have JS threads */ + *(event->data.jsthread) = NULL; + break; + + case CONTENT_MSG_GETDIMS: + *(event->data.getdims.viewport_width) = + content__get_width(&c->base); + *(event->data.getdims.viewport_height) = + content__get_height(&c->base); + break; + + case CONTENT_MSG_SCROLL: + if (box->scroll_x != NULL) + scrollbar_set(box->scroll_x, event->data.scroll.x0, + false); + if (box->scroll_y != NULL) + scrollbar_set(box->scroll_y, event->data.scroll.y0, + false); + break; + + case CONTENT_MSG_DRAGSAVE: + { + union content_msg_data msg_data; + if (event->data.dragsave.content == NULL) + msg_data.dragsave.content = object; + else + msg_data.dragsave.content = + event->data.dragsave.content; + + content_broadcast(&c->base, CONTENT_MSG_DRAGSAVE, &msg_data); + } + break; + + case CONTENT_MSG_SAVELINK: + case CONTENT_MSG_POINTER: + case CONTENT_MSG_SELECTMENU: + case CONTENT_MSG_GADGETCLICK: + /* These messages are for browser window layer. + * we're not interested, so pass them on. */ + content_broadcast(&c->base, event->type, &event->data); + break; + + case CONTENT_MSG_CARET: + { + union html_focus_owner focus_owner; + focus_owner.content = box; + + switch (event->data.caret.type) { + case CONTENT_CARET_REMOVE: + case CONTENT_CARET_HIDE: + html_set_focus(c, HTML_FOCUS_CONTENT, focus_owner, + true, 0, 0, 0, NULL); + break; + case CONTENT_CARET_SET_POS: + html_set_focus(c, HTML_FOCUS_CONTENT, focus_owner, + false, event->data.caret.pos.x, + event->data.caret.pos.y, + event->data.caret.pos.height, + event->data.caret.pos.clip); + break; + } + } + break; + + case CONTENT_MSG_DRAG: + { + html_drag_type drag_type = HTML_DRAG_NONE; + union html_drag_owner drag_owner; + drag_owner.content = box; + + switch (event->data.drag.type) { + case CONTENT_DRAG_NONE: + drag_type = HTML_DRAG_NONE; + drag_owner.no_owner = true; + break; + case CONTENT_DRAG_SCROLL: + drag_type = HTML_DRAG_CONTENT_SCROLL; + break; + case CONTENT_DRAG_SELECTION: + drag_type = HTML_DRAG_CONTENT_SELECTION; + break; + } + html_set_drag_type(c, drag_type, drag_owner, + event->data.drag.rect); + } + break; + + case CONTENT_MSG_SELECTION: + { + html_selection_type sel_type; + union html_selection_owner sel_owner; + + if (event->data.selection.selection) { + sel_type = HTML_SELECTION_CONTENT; + sel_owner.content = box; + } else { + sel_type = HTML_SELECTION_NONE; + sel_owner.none = true; + } + html_set_selection(c, sel_type, sel_owner, + event->data.selection.read_only); + } + break; + + default: + break; + } + + if (c->base.status == CONTENT_STATUS_READY && + c->base.active == 0 && + (event->type == CONTENT_MSG_LOADING || + event->type == CONTENT_MSG_DONE || + event->type == CONTENT_MSG_ERROR)) { + /* all objects have arrived */ + content__reformat(&c->base, false, c->base.available_width, + c->base.available_height); + content_set_done(&c->base); + } else if (nsoption_bool(incremental_reflow) && + event->type == CONTENT_MSG_DONE && + box != NULL && + !(box->flags & REPLACE_DIM) && + (c->base.status == CONTENT_STATUS_READY || + c->base.status == CONTENT_STATUS_DONE)) { + /* 1) the configuration option to reflow pages while + * objects are fetched is set + * 2) an object is newly fetched & converted, + * 3) the box's dimensions need to change due to being replaced + * 4) the object's parent HTML is ready for reformat, + */ + uint64_t ms_now; + nsu_getmonotonic_ms(&ms_now); + if (ms_now > c->base.reformat_time) { + /* The time since the previous reformat is + * more than the configured minimum time + * between reformats so reformat the page to + * display newly fetched objects + */ + content__reformat(&c->base, + false, + c->base.available_width, + c->base.available_height); + } + } + + return NSERROR_OK; +} + +/** + * Start a fetch for an object required by a page, replacing an existing object. + * + * \param object Object to replace + * \param url URL of object to fetch (copied) + * \return true on success, false on memory exhaustion + */ + +static bool html_replace_object(struct content_html_object *object, nsurl *url) +{ + html_content *c; + hlcache_child_context child; + html_content *page; + nserror error; + + assert(object != NULL); + assert(object->box != NULL); + + c = (html_content *) object->parent; + + child.charset = c->encoding; + child.quirks = c->base.quirks; + + if (object->content != NULL) { + /* remove existing object */ + if (content_get_status(object->content) != CONTENT_STATUS_DONE) { + c->base.active--; + NSLOG(netsurf, INFO, "%d fetches active", + c->base.active); + } + + hlcache_handle_release(object->content); + object->content = NULL; + + object->box->object = NULL; + } + + /* initialise fetch */ + error = hlcache_handle_retrieve(url, HLCACHE_RETRIEVE_SNIFF_TYPE, + content_get_url(&c->base), NULL, + html_object_callback, object, &child, + object->permitted_types, + &object->content); + + if (error != NSERROR_OK) + return false; + + for (page = c; page != NULL; page = page->page) { + page->base.active++; + NSLOG(netsurf, INFO, "%d fetches active", c->base.active); + + page->base.status = CONTENT_STATUS_READY; + } + + return true; +} + +/** + * schedule callback for object refresh + */ + +static void html_object_refresh(void *p) +{ + struct content_html_object *object = p; + nsurl *refresh_url; + + assert(content_get_type(object->content) == CONTENT_HTML); + + refresh_url = content_get_refresh_url(object->content); + + /* Ignore if refresh URL has gone + * (may happen if fetch errored) */ + if (refresh_url == NULL) + return; + + content_invalidate_reuse_data(object->content); + + if (!html_replace_object(object, refresh_url)) { + /** \todo handle memory exhaustion */ + } +} + +nserror html_object_open_objects(html_content *html, struct browser_window *bw) +{ + struct content_html_object *object, *next; + + for (object = html->object_list; object != NULL; object = next) { + next = object->next; + + if (object->content == NULL || object->box == NULL) + continue; + + if (content_get_type(object->content) == CONTENT_NONE) + continue; + + content_open(object->content, + bw, + &html->base, + object->box->object_params); + } + return NSERROR_OK; +} + +nserror html_object_abort_objects(html_content *htmlc) +{ + struct content_html_object *object; + + for (object = htmlc->object_list; + object != NULL; + object = object->next) { + if (object->content == NULL) + continue; + + switch (content_get_status(object->content)) { + case CONTENT_STATUS_DONE: + /* already loaded: do nothing */ + break; + + case CONTENT_STATUS_READY: + hlcache_handle_abort(object->content); + /* Active count will be updated when + * html_object_callback receives + * CONTENT_MSG_DONE from this object + */ + break; + + default: + hlcache_handle_abort(object->content); + hlcache_handle_release(object->content); + object->content = NULL; + if (object->box != NULL) { + htmlc->base.active--; + NSLOG(netsurf, INFO, "%d fetches active", + htmlc->base.active); + } + break; + + } + } + + return NSERROR_OK; +} + +nserror html_object_close_objects(html_content *html) +{ + struct content_html_object *object, *next; + + for (object = html->object_list; object != NULL; object = next) { + next = object->next; + + if (object->content == NULL || object->box == NULL) + continue; + + if (content_get_type(object->content) == CONTENT_NONE) + continue; + + if (content_get_type(object->content) == CONTENT_HTML) { + guit->misc->schedule(-1, html_object_refresh, object); + } + + content_close(object->content); + } + return NSERROR_OK; +} + +nserror html_object_free_objects(html_content *html) +{ + while (html->object_list != NULL) { + struct content_html_object *victim = html->object_list; + + if (victim->content != NULL) { + NSLOG(netsurf, INFO, "object %p", victim->content); + + if (content_get_type(victim->content) == CONTENT_HTML) { + guit->misc->schedule(-1, html_object_refresh, victim); + } + hlcache_handle_release(victim->content); + } + + html->object_list = victim->next; + free(victim); + } + return NSERROR_OK; +} + + + +/* exported interface documented in html/html_internal.h */ +bool html_fetch_object(html_content *c, nsurl *url, struct box *box, + content_type permitted_types, + int available_width, int available_height, + bool background) +{ + struct content_html_object *object; + hlcache_child_context child; + nserror error; + + /* If we've already been aborted, don't bother attempting the fetch */ + if (c->aborted) + return true; + + child.charset = c->encoding; + child.quirks = c->base.quirks; + + object = calloc(1, sizeof(struct content_html_object)); + if (object == NULL) { + return false; + } + + object->parent = (struct content *) c; + object->next = NULL; + object->content = NULL; + object->box = box; + object->permitted_types = permitted_types; + object->background = background; + + error = hlcache_handle_retrieve(url, + HLCACHE_RETRIEVE_SNIFF_TYPE, + content_get_url(&c->base), NULL, + html_object_callback, object, &child, + object->permitted_types, &object->content); + if (error != NSERROR_OK) { + free(object); + return error != NSERROR_NOMEM; + } + + /* add to content object list */ + object->next = c->object_list; + c->object_list = object; + + c->num_objects++; + if (box != NULL) { + c->base.active++; + NSLOG(netsurf, INFO, "%d fetches active", c->base.active); + } + + return true; +} diff --git a/content/handlers/html/redraw.c b/content/handlers/html/redraw.c new file mode 100644 index 0000000..ee6fab2 --- /dev/null +++ b/content/handlers/html/redraw.c @@ -0,0 +1,1961 @@ +/* + * Copyright 2004-2008 James Bursa <bursa(a)users.sourceforge.net> + * Copyright 2004-2007 John M Bell <jmb202(a)ecs.soton.ac.uk> + * Copyright 2004-2007 Richard Wilson <info(a)tinct.net> + * Copyright 2005-2006 Adrian Lees <adrianl(a)users.sourceforge.net> + * Copyright 2006 Rob Kendrick <rjek(a)netsurf-browser.org> + * Copyright 2008 Michael Drake <tlsa(a)netsurf-browser.org> + * Copyright 2009 Paul Blokus <paul_pl(a)users.sourceforge.net> + * + * 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 + * + * Redrawing CONTENT_HTML implementation. + */ + +#include "utils/config.h" +#include <assert.h> +#include <stdbool.h> +#include <stdlib.h> +#include <string.h> +#include <math.h> +#include <dom/dom.h> + +#include "utils/log.h" +#include "utils/messages.h" +#include "utils/utils.h" +#include "utils/nsoption.h" +#include "netsurf/content.h" +#include "netsurf/browser_window.h" +#include "netsurf/plotters.h" +#include "netsurf/bitmap.h" +#include "netsurf/layout.h" +#include "content/content_protected.h" +#include "css/utils.h" +#include "desktop/selection.h" +#include "desktop/print.h" +#include "desktop/scrollbar.h" +#include "desktop/textarea.h" +#include "desktop/gui_internal.h" + +#include "html/box.h" +#include "html/box_inspect.h" +#include "html/box_manipulate.h" +#include "html/font.h" +#include "html/form_internal.h" +#include "html/html_internal.h" +#include "html/layout.h" +#include "html/search.h" + + +bool html_redraw_debug = false; + +/** + * Determine if a box has a background that needs drawing + * + * \param box Box to consider + * \return True if box has a background, false otherwise. + */ +static bool html_redraw_box_has_background(struct box *box) +{ + if (box->background != NULL) + return true; + + if (box->style != NULL) { + css_color colour; + + css_computed_background_color(box->style, &colour); + + if (nscss_color_is_transparent(colour) == false) + return true; + } + + return false; +} + +/** + * Find the background box for a box + * + * \param box Box to find background box for + * \return Pointer to background box, or NULL if there is none + */ +static struct box *html_redraw_find_bg_box(struct box *box) +{ + /* Thanks to backwards compatibility, CSS defines the following: + * + * + If the box is for the root element and it has a background, + * use that (and then process the body box with no special case) + * + If the box is for the root element and it has no background, + * then use the background (if any) from the body element as if + * it were specified on the root. Then, when the box for the body + * element is processed, ignore the background. + * + For any other box, just use its own styling. + */ + if (box->parent == NULL) { + /* Root box */ + if (html_redraw_box_has_background(box)) + return box; + + /* No background on root box: consider body box, if any */ + if (box->children != NULL) { + if (html_redraw_box_has_background(box->children)) + return box->children; + } + } else if (box->parent != NULL && box->parent->parent == NULL) { + /* Body box: only render background if root has its own */ + if (html_redraw_box_has_background(box) && + html_redraw_box_has_background(box->parent)) + return box; + } else { + /* Any other box */ + if (html_redraw_box_has_background(box)) + return box; + } + + return NULL; +} + +/** + * Redraw a short text string, complete with highlighting + * (for selection/search) + * + * \param utf8_text pointer to UTF-8 text string + * \param utf8_len length of string, in bytes + * \param offset byte offset within textual representation + * \param space width of space that follows string (0 = no space) + * \param fstyle text style to use (pass text size unscaled) + * \param x x ordinate at which to plot text + * \param y y ordinate at which to plot text + * \param clip pointer to current clip rectangle + * \param height height of text string + * \param scale current display scale (1.0 = 100%) + * \param excluded exclude this text string from the selection + * \param c Content being redrawn. + * \param sel Selection context + * \param search Search context + * \param ctx current redraw context + * \return true iff successful and redraw should proceed + */ + +static bool +text_redraw(const char *utf8_text, + size_t utf8_len, + size_t offset, + int space, + const plot_font_style_t *fstyle, + int x, + int y, + const struct rect *clip, + int height, + float scale, + bool excluded, + struct content *c, + const struct selection *sel, + struct search_context *search, + const struct redraw_context *ctx) +{ + bool highlighted = false; + plot_font_style_t plot_fstyle = *fstyle; + nserror res; + + /* Need scaled text size to pass to plotters */ + plot_fstyle.size *= scale; + + /* is this box part of a selection? */ + if (!excluded && ctx->interactive == true) { + unsigned len = utf8_len + (space ? 1 : 0); + unsigned start_idx; + unsigned end_idx; + + /* first try the browser window's current selection */ + if (selection_defined(sel) && selection_highlighted(sel, + offset, offset + len, + &start_idx, &end_idx)) { + highlighted = true; + } + + /* what about the current search operation, if any? */ + if (!highlighted && (search != NULL) && + search_term_highlighted(c, + offset, offset + len, + &start_idx, &end_idx, + search)) { + highlighted = true; + } + + /* \todo make search terms visible within selected text */ + if (highlighted) { + struct rect r; + unsigned endtxt_idx = end_idx; + bool clip_changed = false; + bool text_visible = true; + int startx, endx; + plot_style_t pstyle_fill_hback = *plot_style_fill_white; + plot_font_style_t fstyle_hback = plot_fstyle; + + if (end_idx > utf8_len) { + /* adjust for trailing space, not present in + * utf8_text */ + assert(end_idx == utf8_len + 1); + endtxt_idx = utf8_len; + } + + res = guit->layout->width(fstyle, + utf8_text, start_idx, + &startx); + if (res != NSERROR_OK) { + startx = 0; + } + + res = guit->layout->width(fstyle, + utf8_text, endtxt_idx, + &endx); + if (res != NSERROR_OK) { + endx = 0; + } + + /* is there a trailing space that should be highlighted + * as well? */ + if (end_idx > utf8_len) { + endx += space; + } + + if (scale != 1.0) { + startx *= scale; + endx *= scale; + } + + /* draw any text preceding highlighted portion */ + if ((start_idx > 0) && + (ctx->plot->text(ctx, + &plot_fstyle, + x, + y + (int)(height * 0.75 * scale), + utf8_text, + start_idx) != NSERROR_OK)) + return false; + + pstyle_fill_hback.fill_colour = fstyle->foreground; + + /* highlighted portion */ + r.x0 = x + startx; + r.y0 = y; + r.x1 = x + endx; + r.y1 = y + height * scale; + res = ctx->plot->rectangle(ctx, &pstyle_fill_hback, &r); + if (res != NSERROR_OK) { + return false; + } + + if (start_idx > 0) { + int px0 = max(x + startx, clip->x0); + int px1 = min(x + endx, clip->x1); + + if (px0 < px1) { + r.x0 = px0; + r.y0 = clip->y0; + r.x1 = px1; + r.y1 = clip->y1; + res = ctx->plot->clip(ctx, &r); + if (res != NSERROR_OK) { + return false; + } + + clip_changed = true; + } else { + text_visible = false; + } + } + + fstyle_hback.background = + pstyle_fill_hback.fill_colour; + fstyle_hback.foreground = colour_to_bw_furthest( + pstyle_fill_hback.fill_colour); + + if (text_visible && + (ctx->plot->text(ctx, + &fstyle_hback, + x, + y + (int)(height * 0.75 * scale), + utf8_text, + endtxt_idx) != NSERROR_OK)) { + return false; + } + + /* draw any text succeeding highlighted portion */ + if (endtxt_idx < utf8_len) { + int px0 = max(x + endx, clip->x0); + if (px0 < clip->x1) { + + r.x0 = px0; + r.y0 = clip->y0; + r.x1 = clip->x1; + r.y1 = clip->y1; + res = ctx->plot->clip(ctx, &r); + if (res != NSERROR_OK) { + return false; + } + + clip_changed = true; + + res = ctx->plot->text(ctx, + &plot_fstyle, + x, + y + (int)(height * 0.75 * scale), + utf8_text, + utf8_len); + if (res != NSERROR_OK) { + return false; + } + } + } + + if (clip_changed && + (ctx->plot->clip(ctx, clip) != NSERROR_OK)) { + return false; + } + } + } + + if (!highlighted) { + res = ctx->plot->text(ctx, + &plot_fstyle, + x, + y + (int) (height * 0.75 * scale), + utf8_text, + utf8_len); + if (res != NSERROR_OK) { + return false; + } + } + return true; +} + + +/** + * Plot a checkbox. + * + * \param x left coordinate + * \param y top coordinate + * \param width dimensions of checkbox + * \param height dimensions of checkbox + * \param selected the checkbox is selected + * \param ctx current redraw context + * \return true if successful, false otherwise + */ + +static bool html_redraw_checkbox(int x, int y, int width, int height, + bool selected, const struct redraw_context *ctx) +{ + double z; + nserror res; + struct rect rect; + + z = width * 0.15; + if (z == 0) { + z = 1; + } + + rect.x0 = x; + rect.y0 = y ; + rect.x1 = x + width; + rect.y1 = y + height; + res = ctx->plot->rectangle(ctx, plot_style_fill_wbasec, &rect); + if (res != NSERROR_OK) { + return false; + } + + /* dark line across top */ + rect.y1 = y; + res = ctx->plot->line(ctx, plot_style_stroke_darkwbasec, &rect); + if (res != NSERROR_OK) { + return false; + } + + /* dark line across left */ + rect.x1 = x; + rect.y1 = y + height; + res = ctx->plot->line(ctx, plot_style_stroke_darkwbasec, &rect); + if (res != NSERROR_OK) { + return false; + } + + /* light line across right */ + rect.x0 = x + width; + rect.x1 = x + width; + res = ctx->plot->line(ctx, plot_style_stroke_lightwbasec, &rect); + if (res != NSERROR_OK) { + return false; + } + + /* light line across bottom */ + rect.x0 = x; + rect.y0 = y + height; + res = ctx->plot->line(ctx, plot_style_stroke_lightwbasec, &rect); + if (res != NSERROR_OK) { + return false; + } + + if (selected) { + if (width < 12 || height < 12) { + /* render a solid box instead of a tick */ + rect.x0 = x + z + z; + rect.y0 = y + z + z; + rect.x1 = x + width - z; + rect.y1 = y + height - z; + res = ctx->plot->rectangle(ctx, plot_style_fill_wblobc, &rect); + if (res != NSERROR_OK) { + return false; + } + } else { + /* render a tick, as it'll fit comfortably */ + rect.x0 = x + width - z; + rect.y0 = y + z; + rect.x1 = x + (z * 3); + rect.y1 = y + height - z; + res = ctx->plot->line(ctx, plot_style_stroke_wblobc, &rect); + if (res != NSERROR_OK) { + return false; + } + + rect.x0 = x + (z * 3); + rect.y0 = y + height - z; + rect.x1 = x + z + z; + rect.y1 = y + (height / 2); + res = ctx->plot->line(ctx, plot_style_stroke_wblobc, &rect); + if (res != NSERROR_OK) { + return false; + } + } + } + return true; +} + + +/** + * Plot a radio icon. + * + * \param x left coordinate + * \param y top coordinate + * \param width dimensions of radio icon + * \param height dimensions of radio icon + * \param selected the radio icon is selected + * \param ctx current redraw context + * \return true if successful, false otherwise + */ +static bool html_redraw_radio(int x, int y, int width, int height, + bool selected, const struct redraw_context *ctx) +{ + nserror res; + + /* plot background of radio button */ + res = ctx->plot->disc(ctx, + plot_style_fill_wbasec, + x + width * 0.5, + y + height * 0.5, + width * 0.5 - 1); + if (res != NSERROR_OK) { + return false; + } + + /* plot dark arc */ + res = ctx->plot->arc(ctx, + plot_style_fill_darkwbasec, + x + width * 0.5, + y + height * 0.5, + width * 0.5 - 1, + 45, + 225); + if (res != NSERROR_OK) { + return false; + } + + /* plot light arc */ + res = ctx->plot->arc(ctx, + plot_style_fill_lightwbasec, + x + width * 0.5, + y + height * 0.5, + width * 0.5 - 1, + 225, + 45); + if (res != NSERROR_OK) { + return false; + } + + if (selected) { + /* plot selection blob */ + res = ctx->plot->disc(ctx, + plot_style_fill_wblobc, + x + width * 0.5, + y + height * 0.5, + width * 0.3 - 1); + if (res != NSERROR_OK) { + return false; + } + } + + return true; +} + + +/** + * Plot a file upload input. + * + * \param x left coordinate + * \param y top coordinate + * \param width dimensions of input + * \param height dimensions of input + * \param box box of input + * \param scale scale for redraw + * \param background_colour current background colour + * \param len_ctx Length conversion context + * \param ctx current redraw context + * \return true if successful, false otherwise + */ + +static bool html_redraw_file(int x, int y, int width, int height, + struct box *box, float scale, colour background_colour, + const nscss_len_ctx *len_ctx, + const struct redraw_context *ctx) +{ + int text_width; + const char *text; + size_t length; + plot_font_style_t fstyle; + nserror res; + + font_plot_style_from_css(len_ctx, box->style, &fstyle); + fstyle.background = background_colour; + + if (box->gadget->value) { + text = box->gadget->value; + } else { + text = messages_get("Form_Drop"); + } + length = strlen(text); + + res = guit->layout->width(&fstyle, text, length, &text_width); + if (res != NSERROR_OK) { + return false; + } + text_width *= scale; + if (width < text_width + 8) { + x = x + width - text_width - 4; + } else { + x = x + 4; + } + + res = ctx->plot->text(ctx, &fstyle, x, y + height * 0.75, text, length); + if (res != NSERROR_OK) { + return false; + } + return true; +} + + +/** + * Plot background images. + * + * The reason for the presence of \a background is the backwards compatibility + * mess that is backgrounds on <body>. The background will be drawn relative + * to \a box, using the background information contained within \a background. + * + * \param x coordinate of box + * \param y coordinate of box + * \param box box to draw background image of + * \param scale scale for redraw + * \param clip current clip rectangle + * \param background_colour current background colour + * \param background box containing background details (usually \a box) + * \param len_ctx Length conversion context + * \param ctx current redraw context + * \return true if successful, false otherwise + */ + +static bool html_redraw_background(int x, int y, struct box *box, float scale, + const struct rect *clip, colour *background_colour, + struct box *background, + const nscss_len_ctx *len_ctx, + const struct redraw_context *ctx) +{ + bool repeat_x = false; + bool repeat_y = false; + bool plot_colour = true; + bool plot_content; + bool clip_to_children = false; + struct box *clip_box = box; + int ox = x, oy = y; + int width, height; + css_fixed hpos = 0, vpos = 0; + css_unit hunit = CSS_UNIT_PX, vunit = CSS_UNIT_PX; + struct box *parent; + struct rect r = *clip; + css_color bgcol; + plot_style_t pstyle_fill_bg = { + .fill_type = PLOT_OP_TYPE_SOLID, + .fill_colour = *background_colour, + }; + nserror res; + + if (ctx->background_images == false) + return true; + + plot_content = (background->background != NULL); + + if (plot_content) { + if (!box->parent) { + /* Root element, special case: + * background origin calc. is based on margin box */ + x -= box->margin[LEFT] * scale; + y -= box->margin[TOP] * scale; + width = box->margin[LEFT] + box->padding[LEFT] + + box->width + box->padding[RIGHT] + + box->margin[RIGHT]; + height = box->margin[TOP] + box->padding[TOP] + + box->height + box->padding[BOTTOM] + + box->margin[BOTTOM]; + } else { + width = box->padding[LEFT] + box->width + + box->padding[RIGHT]; + height = box->padding[TOP] + box->height + + box->padding[BOTTOM]; + } + /* handle background-repeat */ + switch (css_computed_background_repeat(background->style)) { + case CSS_BACKGROUND_REPEAT_REPEAT: + repeat_x = repeat_y = true; + /* optimisation: only plot the colour if + * bitmap is not opaque */ + plot_colour = !content_get_opaque(background->background); + break; + + case CSS_BACKGROUND_REPEAT_REPEAT_X: + repeat_x = true; + break; + + case CSS_BACKGROUND_REPEAT_REPEAT_Y: + repeat_y = true; + break; + + case CSS_BACKGROUND_REPEAT_NO_REPEAT: + break; + + default: + break; + } + + /* handle background-position */ + css_computed_background_position(background->style, + &hpos, &hunit, &vpos, &vunit); + if (hunit == CSS_UNIT_PCT) { + x += (width - + content_get_width(background->background)) * + scale * FIXTOFLT(hpos) / 100.; + } else { + x += (int) (FIXTOFLT(nscss_len2px(len_ctx, hpos, hunit, + background->style)) * scale); + } + + if (vunit == CSS_UNIT_PCT) { + y += (height - + content_get_height(background->background)) * + scale * FIXTOFLT(vpos) / 100.; + } else { + y += (int) (FIXTOFLT(nscss_len2px(len_ctx, vpos, vunit, + background->style)) * scale); + } + } + + /* special case for table rows as their background needs + * to be clipped to all the cells */ + if (box->type == BOX_TABLE_ROW) { + css_fixed h = 0, v = 0; + css_unit hu = CSS_UNIT_PX, vu = CSS_UNIT_PX; + + for (parent = box->parent; + ((parent) && (parent->type != BOX_TABLE)); + parent = parent->parent); + assert(parent && (parent->style)); + + css_computed_border_spacing(parent->style, &h, &hu, &v, &vu); + + clip_to_children = (h > 0) || (v > 0); + + if (clip_to_children) + clip_box = box->children; + } + + for (; clip_box; clip_box = clip_box->next) { + /* clip to child boxes if needed */ + if (clip_to_children) { + assert(clip_box->type == BOX_TABLE_CELL); + + /* update clip.* to the child cell */ + r.x0 = ox + (clip_box->x * scale); + r.y0 = oy + (clip_box->y * scale); + r.x1 = r.x0 + (clip_box->padding[LEFT] + + clip_box->width + + clip_box->padding[RIGHT]) * scale; + r.y1 = r.y0 + (clip_box->padding[TOP] + + clip_box->height + + clip_box->padding[BOTTOM]) * scale; + + if (r.x0 < clip->x0) r.x0 = clip->x0; + if (r.y0 < clip->y0) r.y0 = clip->y0; + if (r.x1 > clip->x1) r.x1 = clip->x1; + if (r.y1 > clip->y1) r.y1 = clip->y1; + + css_computed_background_color(clip_box->style, &bgcol); + + /* <td> attributes override <tr> */ + /* if the background content is opaque there + * is no need to plot underneath it. + */ + if ((r.x0 >= r.x1) || + (r.y0 >= r.y1) || + (nscss_color_is_transparent(bgcol) == false) || + ((clip_box->background != NULL) && + content_get_opaque(clip_box->background))) + continue; + } + + /* plot the background colour */ + css_computed_background_color(background->style, &bgcol); + + if (nscss_color_is_transparent(bgcol) == false) { + *background_colour = nscss_color_to_ns(bgcol); + pstyle_fill_bg.fill_colour = *background_colour; + if (plot_colour) { + res = ctx->plot->rectangle(ctx, &pstyle_fill_bg, &r); + if (res != NSERROR_OK) { + return false; + } + } + } + /* and plot the image */ + if (plot_content) { + width = content_get_width(background->background); + height = content_get_height(background->background); + + /* ensure clip area only as large as required */ + if (!repeat_x) { + if (r.x0 < x) + r.x0 = x; + if (r.x1 > x + width * scale) + r.x1 = x + width * scale; + } + if (!repeat_y) { + if (r.y0 < y) + r.y0 = y; + if (r.y1 > y + height * scale) + r.y1 = y + height * scale; + } + /* valid clipping rectangles only */ + if ((r.x0 < r.x1) && (r.y0 < r.y1)) { + struct content_redraw_data bg_data; + + res = ctx->plot->clip(ctx, &r); + if (res != NSERROR_OK) { + return false; + } + + bg_data.x = x; + bg_data.y = y; + bg_data.width = ceilf(width * scale); + bg_data.height = ceilf(height * scale); + bg_data.background_colour = *background_colour; + bg_data.scale = scale; + bg_data.repeat_x = repeat_x; + bg_data.repeat_y = repeat_y; + + /* We just continue if redraw fails */ + content_redraw(background->background, + &bg_data, &r, ctx); + } + } + + /* only <tr> rows being clipped to child boxes loop */ + if (!clip_to_children) + return true; + } + return true; +} + + +/** + * Plot an inline's background and/or background image. + * + * \param x coordinate of box + * \param y coordinate of box + * \param box BOX_INLINE which created the background + * \param scale scale for redraw + * \param clip coordinates of clip rectangle + * \param b coordinates of border edge rectangle + * \param first true if this is the first rectangle associated with the inline + * \param last true if this is the last rectangle associated with the inline + * \param background_colour updated to current background colour if plotted + * \param len_ctx Length conversion context + * \param ctx current redraw context + * \return true if successful, false otherwise + */ + +static bool html_redraw_inline_background(int x, int y, struct box *box, + float scale, const struct rect *clip, struct rect b, + bool first, bool last, colour *background_colour, + const nscss_len_ctx *len_ctx, + const struct redraw_context *ctx) +{ + struct rect r = *clip; + bool repeat_x = false; + bool repeat_y = false; + bool plot_colour = true; + bool plot_content; + css_fixed hpos = 0, vpos = 0; + css_unit hunit = CSS_UNIT_PX, vunit = CSS_UNIT_PX; + css_color bgcol; + plot_style_t pstyle_fill_bg = { + .fill_type = PLOT_OP_TYPE_SOLID, + .fill_colour = *background_colour, + }; + nserror res; + + plot_content = (box->background != NULL); + + if (html_redraw_printing && nsoption_bool(remove_backgrounds)) + return true; + + if (plot_content) { + /* handle background-repeat */ + switch (css_computed_background_repeat(box->style)) { + case CSS_BACKGROUND_REPEAT_REPEAT: + repeat_x = repeat_y = true; + /* optimisation: only plot the colour if + * bitmap is not opaque + */ + plot_colour = !content_get_opaque(box->background); + break; + + case CSS_BACKGROUND_REPEAT_REPEAT_X: + repeat_x = true; + break; + + case CSS_BACKGROUND_REPEAT_REPEAT_Y: + repeat_y = true; + break; + + case CSS_BACKGROUND_REPEAT_NO_REPEAT: + break; + + default: + break; + } + + /* handle background-position */ + css_computed_background_position(box->style, + &hpos, &hunit, &vpos, &vunit); + if (hunit == CSS_UNIT_PCT) { + x += (b.x1 - b.x0 - + content_get_width(box->background) * + scale) * FIXTOFLT(hpos) / 100.; + + if (!repeat_x && ((hpos < 2 && !first) || + (hpos > 98 && !last))){ + plot_content = false; + } + } else { + x += (int) (FIXTOFLT(nscss_len2px(len_ctx, hpos, hunit, + box->style)) * scale); + } + + if (vunit == CSS_UNIT_PCT) { + y += (b.y1 - b.y0 - + content_get_height(box->background) * + scale) * FIXTOFLT(vpos) / 100.; + } else { + y += (int) (FIXTOFLT(nscss_len2px(len_ctx, vpos, vunit, + box->style)) * scale); + } + } + + /* plot the background colour */ + css_computed_background_color(box->style, &bgcol); + + if (nscss_color_is_transparent(bgcol) == false) { + *background_colour = nscss_color_to_ns(bgcol); + pstyle_fill_bg.fill_colour = *background_colour; + + if (plot_colour) { + res = ctx->plot->rectangle(ctx, &pstyle_fill_bg, &r); + if (res != NSERROR_OK) { + return false; + } + } + } + /* and plot the image */ + if (plot_content) { + int width = content_get_width(box->background); + int height = content_get_height(box->background); + + if (!repeat_x) { + if (r.x0 < x) + r.x0 = x; + if (r.x1 > x + width * scale) + r.x1 = x + width * scale; + } + if (!repeat_y) { + if (r.y0 < y) + r.y0 = y; + if (r.y1 > y + height * scale) + r.y1 = y + height * scale; + } + /* valid clipping rectangles only */ + if ((r.x0 < r.x1) && (r.y0 < r.y1)) { + struct content_redraw_data bg_data; + + res = ctx->plot->clip(ctx, &r); + if (res != NSERROR_OK) { + return false; + } + + bg_data.x = x; + bg_data.y = y; + bg_data.width = ceilf(width * scale); + bg_data.height = ceilf(height * scale); + bg_data.background_colour = *background_colour; + bg_data.scale = scale; + bg_data.repeat_x = repeat_x; + bg_data.repeat_y = repeat_y; + + /* We just continue if redraw fails */ + content_redraw(box->background, &bg_data, &r, ctx); + } + } + + return true; +} + + +/** + * Plot text decoration for an inline box. + * + * \param box box to plot decorations for, of type BOX_INLINE + * \param x x coordinate of parent of box + * \param y y coordinate of parent of box + * \param scale scale for redraw + * \param colour colour for decorations + * \param ratio position of line as a ratio of line height + * \param ctx current redraw context + * \return true if successful, false otherwise + */ + +static bool +html_redraw_text_decoration_inline(struct box *box, + int x, int y, + float scale, + colour colour, + float ratio, + const struct redraw_context *ctx) +{ + struct box *c; + plot_style_t plot_style_box = { + .stroke_type = PLOT_OP_TYPE_SOLID, + .stroke_colour = colour, + }; + nserror res; + struct rect rect; + + for (c = box->next; + c && c != box->inline_end; + c = c->next) { + if (c->type != BOX_TEXT) { + continue; + } + rect.x0 = (x + c->x) * scale; + rect.y0 = (y + c->y + c->height * ratio) * scale; + rect.x1 = (x + c->x + c->width) * scale; + rect.y1 = (y + c->y + c->height * ratio) * scale; + res = ctx->plot->line(ctx, &plot_style_box, &rect); + if (res != NSERROR_OK) { + return false; + } + } + return true; +} + + +/** + * Plot text decoration for an non-inline box. + * + * \param box box to plot decorations for, of type other than BOX_INLINE + * \param x x coordinate of box + * \param y y coordinate of box + * \param scale scale for redraw + * \param colour colour for decorations + * \param ratio position of line as a ratio of line height + * \param ctx current redraw context + * \return true if successful, false otherwise + */ + +static bool +html_redraw_text_decoration_block(struct box *box, + int x, int y, + float scale, + colour colour, + float ratio, + const struct redraw_context *ctx) +{ + struct box *c; + plot_style_t plot_style_box = { + .stroke_type = PLOT_OP_TYPE_SOLID, + .stroke_colour = colour, + }; + nserror res; + struct rect rect; + + /* draw through text descendants */ + for (c = box->children; c; c = c->next) { + if (c->type == BOX_TEXT) { + rect.x0 = (x + c->x) * scale; + rect.y0 = (y + c->y + c->height * ratio) * scale; + rect.x1 = (x + c->x + c->width) * scale; + rect.y1 = (y + c->y + c->height * ratio) * scale; + res = ctx->plot->line(ctx, &plot_style_box, &rect); + if (res != NSERROR_OK) { + return false; + } + } else if ((c->type == BOX_INLINE_CONTAINER) || (c->type == BOX_BLOCK)) { + if (!html_redraw_text_decoration_block(c, + x + c->x, y + c->y, + scale, colour, ratio, ctx)) + return false; + } + } + return true; +} + + +/** + * Plot text decoration for a box. + * + * \param box box to plot decorations for + * \param x_parent x coordinate of parent of box + * \param y_parent y coordinate of parent of box + * \param scale scale for redraw + * \param background_colour current background colour + * \param ctx current redraw context + * \return true if successful, false otherwise + */ + +static bool html_redraw_text_decoration(struct box *box, + int x_parent, int y_parent, float scale, + colour background_colour, const struct redraw_context *ctx) +{ + static const enum css_text_decoration_e decoration[] = { + CSS_TEXT_DECORATION_UNDERLINE, CSS_TEXT_DECORATION_OVERLINE, + CSS_TEXT_DECORATION_LINE_THROUGH }; + static const float line_ratio[] = { 0.9, 0.1, 0.5 }; + colour fgcol; + unsigned int i; + css_color col; + + css_computed_color(box->style, &col); + fgcol = nscss_color_to_ns(col); + + /* antialias colour for under/overline */ + if (html_redraw_printing == false) + fgcol = blend_colour(background_colour, fgcol); + + if (box->type == BOX_INLINE) { + if (!box->inline_end) + return true; + for (i = 0; i != NOF_ELEMENTS(decoration); i++) + if (css_computed_text_decoration(box->style) & + decoration[i]) + if (!html_redraw_text_decoration_inline(box, + x_parent, y_parent, scale, + fgcol, line_ratio[i], ctx)) + return false; + } else { + for (i = 0; i != NOF_ELEMENTS(decoration); i++) + if (css_computed_text_decoration(box->style) & + decoration[i]) + if (!html_redraw_text_decoration_block(box, + x_parent + box->x, + y_parent + box->y, + scale, + fgcol, line_ratio[i], ctx)) + return false; + } + + return true; +} + + +/** + * Redraw the text content of a box, possibly partially highlighted + * because the text has been selected, or matches a search operation. + * + * \param html The html content to redraw text within. + * \param box box with text content + * \param x x co-ord of box + * \param y y co-ord of box + * \param clip current clip rectangle + * \param scale current scale setting (1.0 = 100%) + * \param current_background_color + * \param ctx current redraw context + * \return true iff successful and redraw should proceed + */ + +static bool html_redraw_text_box(const html_content *html, struct box *box, + int x, int y, const struct rect *clip, float scale, + colour current_background_color, + const struct redraw_context *ctx) +{ + bool excluded = (box->object != NULL); + plot_font_style_t fstyle; + + font_plot_style_from_css(&html->len_ctx, box->style, &fstyle); + fstyle.background = current_background_color; + + if (!text_redraw(box->text, box->length, box->byte_offset, + box->space, &fstyle, x, y, + clip, box->height, scale, excluded, + (struct content *)html, &html->sel, + html->search, ctx)) + return false; + + return true; +} + +bool html_redraw_box(const html_content *html, struct box *box, + int x_parent, int y_parent, + const struct rect *clip, float scale, + colour current_background_color, + const struct redraw_context *ctx); + +/** + * Draw the various children of a box. + * + * \param html html content + * \param box box to draw children of + * \param x_parent coordinate of parent box + * \param y_parent coordinate of parent box + * \param clip clip rectangle + * \param scale scale for redraw + * \param current_background_color background colour under this box + * \param ctx current redraw context + * \return true if successful, false otherwise + */ + +static bool html_redraw_box_children(const html_content *html, struct box *box, + int x_parent, int y_parent, + const struct rect *clip, float scale, + colour current_background_color, + const struct redraw_context *ctx) +{ + struct box *c; + + for (c = box->children; c; c = c->next) { + + if (c->type != BOX_FLOAT_LEFT && c->type != BOX_FLOAT_RIGHT) + if (!html_redraw_box(html, c, + x_parent + box->x - + scrollbar_get_offset(box->scroll_x), + y_parent + box->y - + scrollbar_get_offset(box->scroll_y), + clip, scale, current_background_color, + ctx)) + return false; + } + for (c = box->float_children; c; c = c->next_float) + if (!html_redraw_box(html, c, + x_parent + box->x - + scrollbar_get_offset(box->scroll_x), + y_parent + box->y - + scrollbar_get_offset(box->scroll_y), + clip, scale, current_background_color, + ctx)) + return false; + + return true; +} + +/** + * Recursively draw a box. + * + * \param html html content + * \param box box to draw + * \param x_parent coordinate of parent box + * \param y_parent coordinate of parent box + * \param clip clip rectangle + * \param scale scale for redraw + * \param current_background_color background colour under this box + * \param ctx current redraw context + * \return true if successful, false otherwise + * + * x, y, clip_[xy][01] are in target coordinates. + */ + +bool html_redraw_box(const html_content *html, struct box *box, + int x_parent, int y_parent, + const struct rect *clip, const float scale, + colour current_background_color, + const struct redraw_context *ctx) +{ + const struct plotter_table *plot = ctx->plot; + int x, y; + int width, height; + int padding_left, padding_top, padding_width, padding_height; + int border_left, border_top, border_right, border_bottom; + struct rect r; + struct rect rect; + int x_scrolled, y_scrolled; + struct box *bg_box = NULL; + css_computed_clip_rect css_rect; + enum css_overflow_e overflow_x = CSS_OVERFLOW_VISIBLE; + enum css_overflow_e overflow_y = CSS_OVERFLOW_VISIBLE; + + if (html_redraw_printing && (box->flags & PRINTED)) + return true; + + if (box->style != NULL) { + overflow_x = css_computed_overflow_x(box->style); + overflow_y = css_computed_overflow_y(box->style); + } + + /* avoid trivial FP maths */ + if (scale == 1.0) { + x = x_parent + box->x; + y = y_parent + box->y; + width = box->width; + height = box->height; + padding_left = box->padding[LEFT]; + padding_top = box->padding[TOP]; + padding_width = padding_left + box->width + box->padding[RIGHT]; + padding_height = padding_top + box->height + + box->padding[BOTTOM]; + border_left = box->border[LEFT].width; + border_top = box->border[TOP].width; + border_right = box->border[RIGHT].width; + border_bottom = box->border[BOTTOM].width; + } else { + x = (x_parent + box->x) * scale; + y = (y_parent + box->y) * scale; + width = box->width * scale; + height = box->height * scale; + /* left and top padding values are normally zero, + * so avoid trivial FP maths */ + padding_left = box->padding[LEFT] ? box->padding[LEFT] * scale + : 0; + padding_top = box->padding[TOP] ? box->padding[TOP] * scale + : 0; + padding_width = (box->padding[LEFT] + box->width + + box->padding[RIGHT]) * scale; + padding_height = (box->padding[TOP] + box->height + + box->padding[BOTTOM]) * scale; + border_left = box->border[LEFT].width * scale; + border_top = box->border[TOP].width * scale; + border_right = box->border[RIGHT].width * scale; + border_bottom = box->border[BOTTOM].width * scale; + } + + /* calculate rectangle covering this box and descendants */ + if (box->style && overflow_x != CSS_OVERFLOW_VISIBLE && + box->parent != NULL) { + /* box contents clipped to box size */ + r.x0 = x - border_left; + r.x1 = x + padding_width + border_right; + } else { + /* box contents can hang out of the box; use descendant box */ + if (scale == 1.0) { + r.x0 = x + box->descendant_x0; + r.x1 = x + box->descendant_x1 + 1; + } else { + r.x0 = x + box->descendant_x0 * scale; + r.x1 = x + box->descendant_x1 * scale + 1; + } + if (!box->parent) { + /* root element */ + int margin_left, margin_right; + if (scale == 1.0) { + margin_left = box->margin[LEFT]; + margin_right = box->margin[RIGHT]; + } else { + margin_left = box->margin[LEFT] * scale; + margin_right = box->margin[RIGHT] * scale; + } + r.x0 = x - border_left - margin_left < r.x0 ? + x - border_left - margin_left : r.x0; + r.x1 = x + padding_width + border_right + + margin_right > r.x1 ? + x + padding_width + border_right + + margin_right : r.x1; + } + } + + /* calculate rectangle covering this box and descendants */ + if (box->style && overflow_y != CSS_OVERFLOW_VISIBLE && + box->parent != NULL) { + /* box contents clipped to box size */ + r.y0 = y - border_top; + r.y1 = y + padding_height + border_bottom; + } else { + /* box contents can hang out of the box; use descendant box */ + if (scale == 1.0) { + r.y0 = y + box->descendant_y0; + r.y1 = y + box->descendant_y1 + 1; + } else { + r.y0 = y + box->descendant_y0 * scale; + r.y1 = y + box->descendant_y1 * scale + 1; + } + if (!box->parent) { + /* root element */ + int margin_top, margin_bottom; + if (scale == 1.0) { + margin_top = box->margin[TOP]; + margin_bottom = box->margin[BOTTOM]; + } else { + margin_top = box->margin[TOP] * scale; + margin_bottom = box->margin[BOTTOM] * scale; + } + r.y0 = y - border_top - margin_top < r.y0 ? + y - border_top - margin_top : r.y0; + r.y1 = y + padding_height + border_bottom + + margin_bottom > r.y1 ? + y + padding_height + border_bottom + + margin_bottom : r.y1; + } + } + + /* return if the rectangle is completely outside the clip rectangle */ + if (clip->y1 < r.y0 || r.y1 < clip->y0 || + clip->x1 < r.x0 || r.x1 < clip->x0) + return true; + + /*if the rectangle is under the page bottom but it can fit in a page, + don't print it now*/ + if (html_redraw_printing) { + if (r.y1 > html_redraw_printing_border) { + if (r.y1 - r.y0 <= html_redraw_printing_border && + (box->type == BOX_TEXT || + box->type == BOX_TABLE_CELL + || box->object || box->gadget)) { + /*remember the highest of all points from the + not printed elements*/ + if (r.y0 < html_redraw_printing_top_cropped) + html_redraw_printing_top_cropped = r.y0; + return true; + } + } + else box->flags |= PRINTED; /*it won't be printed anymore*/ + } + + /* if visibility is hidden render children only */ + if (box->style && css_computed_visibility(box->style) == + CSS_VISIBILITY_HIDDEN) { + if ((ctx->plot->group_start) && + (ctx->plot->group_start(ctx, "hidden box") != NSERROR_OK)) + return false; + if (!html_redraw_box_children(html, box, x_parent, y_parent, + &r, scale, current_background_color, ctx)) + return false; + return ((!ctx->plot->group_end) || (ctx->plot->group_end(ctx) == NSERROR_OK)); + } + + if ((ctx->plot->group_start) && + (ctx->plot->group_start(ctx,"vis box") != NSERROR_OK)) { + return false; + } + + if (box->style != NULL && + css_computed_position(box->style) == + CSS_POSITION_ABSOLUTE && + css_computed_clip(box->style, &css_rect) == + CSS_CLIP_RECT) { + /* We have an absolutly positioned box with a clip rect */ + if (css_rect.left_auto == false) + r.x0 = x - border_left + FIXTOINT(nscss_len2px( + &html->len_ctx, + css_rect.left, css_rect.lunit, + box->style)); + + if (css_rect.top_auto == false) + r.y0 = y - border_top + FIXTOINT(nscss_len2px( + &html->len_ctx, + css_rect.top, css_rect.tunit, + box->style)); + + if (css_rect.right_auto == false) + r.x1 = x - border_left + FIXTOINT(nscss_len2px( + &html->len_ctx, + css_rect.right, css_rect.runit, + box->style)); + + if (css_rect.bottom_auto == false) + r.y1 = y - border_top + FIXTOINT(nscss_len2px( + &html->len_ctx, + css_rect.bottom, css_rect.bunit, + box->style)); + + /* find intersection of clip rectangle and box */ + if (r.x0 < clip->x0) r.x0 = clip->x0; + if (r.y0 < clip->y0) r.y0 = clip->y0; + if (clip->x1 < r.x1) r.x1 = clip->x1; + if (clip->y1 < r.y1) r.y1 = clip->y1; + /* Nothing to do for invalid rectangles */ + if (r.x0 >= r.x1 || r.y0 >= r.y1) + /* not an error */ + return ((!ctx->plot->group_end) || + (ctx->plot->group_end(ctx) == NSERROR_OK)); + /* clip to it */ + if (ctx->plot->clip(ctx, &r) != NSERROR_OK) + return false; + + } else if (box->type == BOX_BLOCK || box->type == BOX_INLINE_BLOCK || + box->type == BOX_TABLE_CELL || box->object) { + /* find intersection of clip rectangle and box */ + if (r.x0 < clip->x0) r.x0 = clip->x0; + if (r.y0 < clip->y0) r.y0 = clip->y0; + if (clip->x1 < r.x1) r.x1 = clip->x1; + if (clip->y1 < r.y1) r.y1 = clip->y1; + /* no point trying to draw 0-width/height boxes */ + if (r.x0 == r.x1 || r.y0 == r.y1) + /* not an error */ + return ((!ctx->plot->group_end) || + (ctx->plot->group_end(ctx) == NSERROR_OK)); + /* clip to it */ + if (ctx->plot->clip(ctx, &r) != NSERROR_OK) + return false; + } else { + /* clip box is fine, clip to it */ + r = *clip; + if (ctx->plot->clip(ctx, &r) != NSERROR_OK) + return false; + } + + /* background colour and image for block level content and replaced + * inlines */ + + bg_box = html_redraw_find_bg_box(box); + + /* bg_box == NULL implies that this box should not have + * its background rendered. Otherwise filter out linebreaks, + * optimize away non-differing inlines, only plot background + * for BOX_TEXT it's in an inline */ + if (bg_box && bg_box->type != BOX_BR && + bg_box->type != BOX_TEXT && + bg_box->type != BOX_INLINE_END && + (bg_box->type != BOX_INLINE || bg_box->object || + bg_box->flags & IFRAME || box->flags & REPLACE_DIM || + (bg_box->gadget != NULL && + (bg_box->gadget->type == GADGET_TEXTAREA || + bg_box->gadget->type == GADGET_TEXTBOX || + bg_box->gadget->type == GADGET_PASSWORD)))) { + /* find intersection of clip box and border edge */ + struct rect p; + p.x0 = x - border_left < r.x0 ? r.x0 : x - border_left; + p.y0 = y - border_top < r.y0 ? r.y0 : y - border_top; + p.x1 = x + padding_width + border_right < r.x1 ? + x + padding_width + border_right : r.x1; + p.y1 = y + padding_height + border_bottom < r.y1 ? + y + padding_height + border_bottom : r.y1; + if (!box->parent) { + /* Root element, special case: + * background covers margins too */ + int m_left, m_top, m_right, m_bottom; + if (scale == 1.0) { + m_left = box->margin[LEFT]; + m_top = box->margin[TOP]; + m_right = box->margin[RIGHT]; + m_bottom = box->margin[BOTTOM]; + } else { + m_left = box->margin[LEFT] * scale; + m_top = box->margin[TOP] * scale; + m_right = box->margin[RIGHT] * scale; + m_bottom = box->margin[BOTTOM] * scale; + } + p.x0 = p.x0 - m_left < r.x0 ? r.x0 : p.x0 - m_left; + p.y0 = p.y0 - m_top < r.y0 ? r.y0 : p.y0 - m_top; + p.x1 = p.x1 + m_right < r.x1 ? p.x1 + m_right : r.x1; + p.y1 = p.y1 + m_bottom < r.y1 ? p.y1 + m_bottom : r.y1; + } + /* valid clipping rectangles only */ + if ((p.x0 < p.x1) && (p.y0 < p.y1)) { + /* plot background */ + if (!html_redraw_background(x, y, box, scale, &p, + &current_background_color, bg_box, + &html->len_ctx, ctx)) + return false; + /* restore previous graphics window */ + if (ctx->plot->clip(ctx, &r) != NSERROR_OK) + return false; + } + } + + /* borders for block level content and replaced inlines */ + if (box->style && + box->type != BOX_TEXT && + box->type != BOX_INLINE_END && + (box->type != BOX_INLINE || box->object || + box->flags & IFRAME || box->flags & REPLACE_DIM || + (box->gadget != NULL && + (box->gadget->type == GADGET_TEXTAREA || + box->gadget->type == GADGET_TEXTBOX || + box->gadget->type == GADGET_PASSWORD))) && + (border_top || border_right || border_bottom || border_left)) { + if (!html_redraw_borders(box, x_parent, y_parent, + padding_width, padding_height, &r, + scale, ctx)) + return false; + } + + /* backgrounds and borders for non-replaced inlines */ + if (box->style && box->type == BOX_INLINE && box->inline_end && + (html_redraw_box_has_background(box) || + border_top || border_right || + border_bottom || border_left)) { + /* inline backgrounds and borders span other boxes and may + * wrap onto separate lines */ + struct box *ib; + struct rect b; /* border edge rectangle */ + struct rect p; /* clipped rect */ + bool first = true; + int ib_x; + int ib_y = y; + int ib_p_width; + int ib_b_left, ib_b_right; + + b.x0 = x - border_left; + b.x1 = x + padding_width + border_right; + b.y0 = y - border_top; + b.y1 = y + padding_height + border_bottom; + + p.x0 = b.x0 < r.x0 ? r.x0 : b.x0; + p.x1 = b.x1 < r.x1 ? b.x1 : r.x1; + p.y0 = b.y0 < r.y0 ? r.y0 : b.y0; + p.y1 = b.y1 < r.y1 ? b.y1 : r.y1; + for (ib = box; ib; ib = ib->next) { + /* to get extents of rectangle(s) associated with + * inline, cycle though all boxes in inline, skipping + * over floats */ + if (ib->type == BOX_FLOAT_LEFT || + ib->type == BOX_FLOAT_RIGHT) + continue; + if (scale == 1.0) { + ib_x = x_parent + ib->x; + ib_y = y_parent + ib->y; + ib_p_width = ib->padding[LEFT] + ib->width + + ib->padding[RIGHT]; + ib_b_left = ib->border[LEFT].width; + ib_b_right = ib->border[RIGHT].width; + } else { + ib_x = (x_parent + ib->x) * scale; + ib_y = (y_parent + ib->y) * scale; + ib_p_width = (ib->padding[LEFT] + ib->width + + ib->padding[RIGHT]) * scale; + ib_b_left = ib->border[LEFT].width * scale; + ib_b_right = ib->border[RIGHT].width * scale; + } + + if ((ib->flags & NEW_LINE) && ib != box) { + /* inline element has wrapped, plot background + * and borders */ + if (!html_redraw_inline_background( + x, y, box, scale, &p, b, + first, false, + &current_background_color, + &html->len_ctx, ctx)) + return false; + /* restore previous graphics window */ + if (ctx->plot->clip(ctx, &r) != NSERROR_OK) + return false; + if (!html_redraw_inline_borders(box, b, &r, + scale, first, false, ctx)) + return false; + /* reset coords */ + b.x0 = ib_x - ib_b_left; + b.y0 = ib_y - border_top - padding_top; + b.y1 = ib_y + padding_height - padding_top + + border_bottom; + + p.x0 = b.x0 < r.x0 ? r.x0 : b.x0; + p.y0 = b.y0 < r.y0 ? r.y0 : b.y0; + p.y1 = b.y1 < r.y1 ? b.y1 : r.y1; + + first = false; + } + + /* increase width for current box */ + b.x1 = ib_x + ib_p_width + ib_b_right; + p.x1 = b.x1 < r.x1 ? b.x1 : r.x1; + + if (ib == box->inline_end) + /* reached end of BOX_INLINE span */ + break; + } + /* plot background and borders for last rectangle of + * the inline */ + if (!html_redraw_inline_background(x, ib_y, box, scale, &p, b, + first, true, &current_background_color, + &html->len_ctx, ctx)) + return false; + /* restore previous graphics window */ + if (ctx->plot->clip(ctx, &r) != NSERROR_OK) + return false; + if (!html_redraw_inline_borders(box, b, &r, scale, first, true, + ctx)) + return false; + + } + + /* Debug outlines */ + if (html_redraw_debug) { + int margin_left, margin_right; + int margin_top, margin_bottom; + if (scale == 1.0) { + /* avoid trivial fp maths */ + margin_left = box->margin[LEFT]; + margin_top = box->margin[TOP]; + margin_right = box->margin[RIGHT]; + margin_bottom = box->margin[BOTTOM]; + } else { + margin_left = box->margin[LEFT] * scale; + margin_top = box->margin[TOP] * scale; + margin_right = box->margin[RIGHT] * scale; + margin_bottom = box->margin[BOTTOM] * scale; + } + /* Content edge -- blue */ + rect.x0 = x + padding_left; + rect.y0 = y + padding_top; + rect.x1 = x + padding_left + width; + rect.y1 = y + padding_top + height; + if (ctx->plot->rectangle(ctx, plot_style_content_edge, &rect) != NSERROR_OK) + return false; + + /* Padding edge -- red */ + rect.x0 = x; + rect.y0 = y; + rect.x1 = x + padding_width; + rect.y1 = y + padding_height; + if (ctx->plot->rectangle(ctx, plot_style_padding_edge, &rect) != NSERROR_OK) + return false; + + /* Margin edge -- yellow */ + rect.x0 = x - border_left - margin_left; + rect.y0 = y - border_top - margin_top; + rect.x1 = x + padding_width + border_right + margin_right; + rect.y1 = y + padding_height + border_bottom + margin_bottom; + if (ctx->plot->rectangle(ctx, plot_style_margin_edge, &rect) != NSERROR_OK) + return false; + } + + /* clip to the padding edge for objects, or boxes with overflow hidden + * or scroll, unless it's the root element */ + if (box->parent != NULL) { + bool need_clip = false; + if (box->object || box->flags & IFRAME || + (overflow_x != CSS_OVERFLOW_VISIBLE && + overflow_y != CSS_OVERFLOW_VISIBLE)) { + r.x0 = x; + r.y0 = y; + r.x1 = x + padding_width; + r.y1 = y + padding_height; + if (r.x0 < clip->x0) r.x0 = clip->x0; + if (r.y0 < clip->y0) r.y0 = clip->y0; + if (clip->x1 < r.x1) r.x1 = clip->x1; + if (clip->y1 < r.y1) r.y1 = clip->y1; + if (r.x1 <= r.x0 || r.y1 <= r.y0) { + return (!ctx->plot->group_end || + (ctx->plot->group_end(ctx) == NSERROR_OK)); + } + need_clip = true; + + } else if (overflow_x != CSS_OVERFLOW_VISIBLE) { + r.x0 = x; + r.y0 = clip->y0; + r.x1 = x + padding_width; + r.y1 = clip->y1; + if (r.x0 < clip->x0) r.x0 = clip->x0; + if (clip->x1 < r.x1) r.x1 = clip->x1; + if (r.x1 <= r.x0) { + return (!ctx->plot->group_end || + (ctx->plot->group_end(ctx) == NSERROR_OK)); + } + need_clip = true; + + } else if (overflow_y != CSS_OVERFLOW_VISIBLE) { + r.x0 = clip->x0; + r.y0 = y; + r.x1 = clip->x1; + r.y1 = y + padding_height; + if (r.y0 < clip->y0) r.y0 = clip->y0; + if (clip->y1 < r.y1) r.y1 = clip->y1; + if (r.y1 <= r.y0) { + return (!ctx->plot->group_end || + (ctx->plot->group_end(ctx) == NSERROR_OK)); + } + need_clip = true; + } + + if (need_clip && + (box->type == BOX_BLOCK || + box->type == BOX_INLINE_BLOCK || + box->type == BOX_TABLE_CELL || box->object)) { + if (ctx->plot->clip(ctx, &r) != NSERROR_OK) + return false; + } + } + + /* text decoration */ + if ((box->type != BOX_TEXT) && + box->style && + css_computed_text_decoration(box->style) != CSS_TEXT_DECORATION_NONE) { + if (!html_redraw_text_decoration(box, x_parent, y_parent, + scale, current_background_color, ctx)) + return false; + } + + if (box->object && width != 0 && height != 0) { + struct content_redraw_data obj_data; + + x_scrolled = x - scrollbar_get_offset(box->scroll_x) * scale; + y_scrolled = y - scrollbar_get_offset(box->scroll_y) * scale; + + obj_data.x = x_scrolled + padding_left; + obj_data.y = y_scrolled + padding_top; + obj_data.width = width; + obj_data.height = height; + obj_data.background_colour = current_background_color; + obj_data.scale = scale; + obj_data.repeat_x = false; + obj_data.repeat_y = false; + + if (content_get_type(box->object) == CONTENT_HTML) { + obj_data.x /= scale; + obj_data.y /= scale; + } + + if (!content_redraw(box->object, &obj_data, &r, ctx)) { + /* Show image fail */ + /* Unicode (U+FFFC) 'OBJECT REPLACEMENT CHARACTER' */ + const char *obj = "\xef\xbf\xbc"; + int obj_width; + int obj_x = x + padding_left; + nserror res; + + rect.x0 = x + padding_left; + rect.y0 = y + padding_top; + rect.x1 = x + padding_left + width - 1; + rect.y1 = y + padding_top + height - 1; + res = ctx->plot->rectangle(ctx, plot_style_broken_object, &rect); + if (res != NSERROR_OK) { + return false; + } + + res = guit->layout->width(plot_fstyle_broken_object, + obj, + sizeof(obj) - 1, + &obj_width); + if (res != NSERROR_OK) { + obj_x += 1; + } else { + obj_x += width / 2 - obj_width / 2; + } + + if (ctx->plot->text(ctx, + plot_fstyle_broken_object, + obj_x, y + padding_top + (int)(height * 0.75), + obj, sizeof(obj) - 1) != NSERROR_OK) + return false; + } + + } else if (box->iframe) { + /* Offset is passed to browser window redraw unscaled */ + browser_window_redraw(box->iframe, + x + padding_left, + y + padding_top, &r, ctx); + + } else if (box->gadget && box->gadget->type == GADGET_CHECKBOX) { + if (!html_redraw_checkbox(x + padding_left, y + padding_top, + width, height, box->gadget->selected, ctx)) + return false; + + } else if (box->gadget && box->gadget->type == GADGET_RADIO) { + if (!html_redraw_radio(x + padding_left, y + padding_top, + width, height, box->gadget->selected, ctx)) + return false; + + } else if (box->gadget && box->gadget->type == GADGET_FILE) { + if (!html_redraw_file(x + padding_left, y + padding_top, + width, height, box, scale, + current_background_color, &html->len_ctx, ctx)) + return false; + + } else if (box->gadget && + (box->gadget->type == GADGET_TEXTAREA || + box->gadget->type == GADGET_PASSWORD || + box->gadget->type == GADGET_TEXTBOX)) { + textarea_redraw(box->gadget->data.text.ta, x, y, + current_background_color, scale, &r, ctx); + + } else if (box->text) { + if (!html_redraw_text_box(html, box, x, y, &r, scale, + current_background_color, ctx)) + return false; + + } else { + if (!html_redraw_box_children(html, box, x_parent, y_parent, &r, + scale, current_background_color, ctx)) + return false; + } + + if (box->type == BOX_BLOCK || box->type == BOX_INLINE_BLOCK || + box->type == BOX_TABLE_CELL || box->type == BOX_INLINE) + if (ctx->plot->clip(ctx, clip) != NSERROR_OK) + return false; + + /* list marker */ + if (box->list_marker) { + if (!html_redraw_box(html, box->list_marker, + x_parent + box->x - + scrollbar_get_offset(box->scroll_x), + y_parent + box->y - + scrollbar_get_offset(box->scroll_y), + clip, scale, current_background_color, ctx)) + return false; + } + + /* scrollbars */ + if (((box->style && box->type != BOX_BR && + box->type != BOX_TABLE && box->type != BOX_INLINE && + (box->gadget == NULL || box->gadget->type != GADGET_TEXTAREA) && + (overflow_x == CSS_OVERFLOW_SCROLL || + overflow_x == CSS_OVERFLOW_AUTO || + overflow_y == CSS_OVERFLOW_SCROLL || + overflow_y == CSS_OVERFLOW_AUTO)) || + (box->object && content_get_type(box->object) == + CONTENT_HTML)) && box->parent != NULL) { + nserror res; + bool has_x_scroll = (overflow_x == CSS_OVERFLOW_SCROLL); + bool has_y_scroll = (overflow_y == CSS_OVERFLOW_SCROLL); + + has_x_scroll |= (overflow_x == CSS_OVERFLOW_AUTO) && + box_hscrollbar_present(box); + has_y_scroll |= (overflow_y == CSS_OVERFLOW_AUTO) && + box_vscrollbar_present(box); + + res = box_handle_scrollbars((struct content *)html, + box, has_x_scroll, has_y_scroll); + if (res != NSERROR_OK) { + NSLOG(netsurf, INFO, "%s", messages_get_errorcode(res)); + return false; + } + + if (box->scroll_x != NULL) + scrollbar_redraw(box->scroll_x, + x_parent + box->x, + y_parent + box->y + box->padding[TOP] + + box->height + box->padding[BOTTOM] - + SCROLLBAR_WIDTH, clip, scale, ctx); + if (box->scroll_y != NULL) + scrollbar_redraw(box->scroll_y, + x_parent + box->x + box->padding[LEFT] + + box->width + box->padding[RIGHT] - + SCROLLBAR_WIDTH, + y_parent + box->y, clip, scale, ctx); + } + + if (box->type == BOX_BLOCK || box->type == BOX_INLINE_BLOCK || + box->type == BOX_TABLE_CELL || box->type == BOX_INLINE) { + if (ctx->plot->clip(ctx, clip) != NSERROR_OK) + return false; + } + + return ((!plot->group_end) || (ctx->plot->group_end(ctx) == NSERROR_OK)); +} + +/** + * Draw a CONTENT_HTML using the current set of plotters (plot). + * + * \param c content of type CONTENT_HTML + * \param data redraw data for this content redraw + * \param clip current clip region + * \param ctx current redraw context + * \return true if successful, false otherwise + * + * x, y, clip_[xy][01] are in target coordinates. + */ + +bool html_redraw(struct content *c, struct content_redraw_data *data, + const struct rect *clip, const struct redraw_context *ctx) +{ + html_content *html = (html_content *) c; + struct box *box; + bool result = true; + bool select, select_only; + plot_style_t pstyle_fill_bg = { + .fill_type = PLOT_OP_TYPE_SOLID, + .fill_colour = data->background_colour, + }; + + box = html->layout; + assert(box); + + /* The select menu needs special treating because, when opened, it + * reaches beyond its layout box. + */ + select = false; + select_only = false; + if (ctx->interactive && html->visible_select_menu != NULL) { + struct form_control *control = html->visible_select_menu; + select = true; + /* check if the redraw rectangle is completely inside of the + select menu */ + select_only = form_clip_inside_select_menu(control, + data->scale, clip); + } + + if (!select_only) { + /* clear to background colour */ + result = (ctx->plot->clip(ctx, clip) == NSERROR_OK); + + if (html->background_colour != NS_TRANSPARENT) + pstyle_fill_bg.fill_colour = html->background_colour; + + result &= (ctx->plot->rectangle(ctx, &pstyle_fill_bg, clip) == NSERROR_OK); + + result &= html_redraw_box(html, box, data->x, data->y, clip, + data->scale, pstyle_fill_bg.fill_colour, ctx); + } + + if (select) { + int menu_x, menu_y; + box = html->visible_select_menu->box; + box_coords(box, &menu_x, &menu_y); + + menu_x -= box->border[LEFT].width; + menu_y += box->height + box->border[BOTTOM].width + + box->padding[BOTTOM] + box->padding[TOP]; + result &= form_redraw_select_menu(html->visible_select_menu, + data->x + menu_x, data->y + menu_y, + data->scale, clip, ctx); + } + + return result; + +} diff --git a/content/handlers/html/redraw_border.c b/content/handlers/html/redraw_border.c new file mode 100644 index 0000000..0b3d858 --- /dev/null +++ b/content/handlers/html/redraw_border.c @@ -0,0 +1,928 @@ +/* + * Copyright 2017 Vincent Sanders <vince(a)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 + * + * Redrawing CONTENT_HTML borders implementation. + */ + +#include <stdbool.h> +#include <stdlib.h> + +#include "utils/log.h" +#include "netsurf/plotters.h" +#include "netsurf/css.h" + +#include "html/box.h" +#include "html/html_internal.h" + + +static plot_style_t plot_style_bdr = { + .stroke_type = PLOT_OP_TYPE_DASH, +}; +static plot_style_t plot_style_fillbdr = { + .fill_type = PLOT_OP_TYPE_SOLID, +}; +static plot_style_t plot_style_fillbdr_dark = { + .fill_type = PLOT_OP_TYPE_SOLID, +}; +static plot_style_t plot_style_fillbdr_light = { + .fill_type = PLOT_OP_TYPE_SOLID, +}; +static plot_style_t plot_style_fillbdr_ddark = { + .fill_type = PLOT_OP_TYPE_SOLID, +}; +static plot_style_t plot_style_fillbdr_dlight = { + .fill_type = PLOT_OP_TYPE_SOLID, +}; + + +static inline nserror +plot_clipped_rectangle(const struct redraw_context *ctx, + const plot_style_t *style, + const struct rect *clip, + struct rect *rect) +{ + nserror res; + + rect->x0 = (clip->x0 > rect->x0) ? clip->x0 : rect->x0; + rect->y0 = (clip->y0 > rect->y0) ? clip->y0 : rect->y0; + rect->x1 = (clip->x1 < rect->x1) ? clip->x1 : rect->x1; + rect->y1 = (clip->y1 < rect->y1) ? clip->y1 : rect->y1; + if ((rect->x0 < rect->x1) && (rect->y0 < rect->y1)) { + /* valid clip rectangles only */ + res = ctx->plot->rectangle(ctx, style, rect); + } else { + res = NSERROR_OK; + } + return res; +} + + +/** + * Draw one border. + * + * \param side index of border side (TOP, RIGHT, BOTTOM, LEFT) + * \param p array of precomputed border vertices + * \param c colour for border + * \param style border line style + * \param thickness border thickness + * \param rectangular whether border is rectangular + * \param clip cliping area for redrawing border. + * \param ctx current redraw context + * \return NSERROR_OK if successful otherwise appropriate error code + */ +static nserror +html_redraw_border_plot(const int side, + const int *p, + colour c, + enum css_border_style_e style, + int thickness, + bool rectangular, + const struct rect *clip, + const struct redraw_context *ctx) +{ + int z[8]; /* Vertices of border part */ + unsigned int light = side; + plot_style_t *plot_style_bdr_in; + plot_style_t *plot_style_bdr_out; + nserror res = NSERROR_OK; + struct rect rect; + + if (c == NS_TRANSPARENT) { + return res; + } + + plot_style_bdr.stroke_type = PLOT_OP_TYPE_DASH; + plot_style_bdr.stroke_colour = c; + plot_style_bdr.stroke_width = (thickness << PLOT_STYLE_RADIX); + plot_style_fillbdr.fill_colour = c; + plot_style_fillbdr_dark.fill_colour = darken_colour(c); + plot_style_fillbdr_light.fill_colour = lighten_colour(c); + plot_style_fillbdr_ddark.fill_colour = double_darken_colour(c); + plot_style_fillbdr_dlight.fill_colour = double_lighten_colour(c); + + switch (style) { + case CSS_BORDER_STYLE_DOTTED: + plot_style_bdr.stroke_type = PLOT_OP_TYPE_DOT; + /* fall through */ + case CSS_BORDER_STYLE_DASHED: + rect.x0 = (p[0] + p[2]) / 2; + rect.y0 = (p[1] + p[3]) / 2; + rect.x1 = (p[4] + p[6]) / 2; + rect.y1 = (p[5] + p[7]) / 2; + res = ctx->plot->line(ctx, &plot_style_bdr, &rect); + break; + + case CSS_BORDER_STYLE_SOLID: + /* fall through to default */ + default: + if (rectangular || thickness == 1) { + + if (side == TOP || side == RIGHT) { + rect.x0 = p[2]; + rect.y0 = p[3]; + if ((side == TOP) && + (p[4] - p[6] != 0)) { + rect.x1 = p[4]; + } else { + rect.x1 = p[6]; + } + rect.y1 = p[7]; + } else { + rect.x0 = p[6]; + rect.y0 = p[7]; + rect.x1 = p[2]; + if ((side == LEFT) && + (p[1] - p[3] != 0)) { + rect.y1 = p[1]; + } else { + rect.y1 = p[3]; + } + } + res = plot_clipped_rectangle(ctx, + &plot_style_fillbdr, + clip, + &rect); + } else { + res = ctx->plot->polygon(ctx, &plot_style_fillbdr, p, 4); + } + break; + + case CSS_BORDER_STYLE_DOUBLE: + z[0] = p[0]; + z[1] = p[1]; + z[2] = (p[0] * 2 + p[2]) / 3; + z[3] = (p[1] * 2 + p[3]) / 3; + z[4] = (p[6] * 2 + p[4]) / 3; + z[5] = (p[7] * 2 + p[5]) / 3; + z[6] = p[6]; + z[7] = p[7]; + res = ctx->plot->polygon(ctx, &plot_style_fillbdr, z, 4); + if (res == NSERROR_OK) { + z[0] = p[2]; + z[1] = p[3]; + z[2] = (p[2] * 2 + p[0]) / 3; + z[3] = (p[3] * 2 + p[1]) / 3; + z[4] = (p[4] * 2 + p[6]) / 3; + z[5] = (p[5] * 2 + p[7]) / 3; + z[6] = p[4]; + z[7] = p[5]; + res = ctx->plot->polygon(ctx, &plot_style_fillbdr, z, 4); + } + break; + + case CSS_BORDER_STYLE_GROOVE: + light = 3 - light; + /* fall through */ + case CSS_BORDER_STYLE_RIDGE: + /* choose correct colours for each part of the border line */ + if (light <= 1) { + plot_style_bdr_in = &plot_style_fillbdr_dark; + plot_style_bdr_out = &plot_style_fillbdr_light; + } else { + plot_style_bdr_in = &plot_style_fillbdr_light; + plot_style_bdr_out = &plot_style_fillbdr_dark; + } + + /* Render border */ + if ((rectangular || thickness == 2) && thickness != 1) { + /* Border made up from two parts and can be + * plotted with rectangles + */ + + /* First part */ + if (side == TOP || side == RIGHT) { + rect.x0 = (p[0] + p[2]) / 2; + rect.y0 = (p[1] + p[3]) / 2; + rect.x1 = p[6]; + rect.y1 = p[7]; + } else { + rect.x0 = p[6]; + rect.y0 = p[7]; + rect.x1 = (p[0] + p[2]) / 2; + rect.y1 = (p[1] + p[3]) / 2; + } + res = plot_clipped_rectangle(ctx, + plot_style_bdr_in, + clip, + &rect); + if (res != NSERROR_OK) { + return res; + } + + /* Second part */ + if (side == TOP || side == RIGHT) { + rect.x0 = p[2]; + rect.y0 = p[3]; + rect.x1 = (p[6] + p[4]) / 2; + rect.y1 = (p[7] + p[5]) / 2; + } else { + rect.x0 = (p[6] + p[4]) / 2; + rect.y0 = (p[7] + p[5]) / 2; + rect.x1 = p[2]; + rect.y1 = p[3]; + } + res = plot_clipped_rectangle(ctx, + plot_style_bdr_out, + clip, + &rect); + } else if (thickness == 1) { + /* Border made up from one part which can be + * plotted as a rectangle + */ + + if (side == TOP || side == RIGHT) { + rect.x0 = p[2]; + rect.y0 = p[3]; + rect.x1 = p[6]; + rect.y1 = p[7]; + rect.x1 = ((side == TOP) && (p[4] - p[6] != 0)) ? + rect.x1 + p[4] - p[6] : rect.x1; + + res = plot_clipped_rectangle(ctx, + plot_style_bdr_in, + clip, + &rect); + } else { + rect.x0 = p[6]; + rect.y0 = p[7]; + rect.x1 = p[2]; + rect.y1 = p[3]; + rect.y1 = ((side == LEFT) && (p[1] - p[3] != 0)) ? + rect.y1 + p[1] - p[3] : rect.y1; + res = plot_clipped_rectangle(ctx, + plot_style_bdr_out, + clip, + &rect); + } + } else { + /* Border made up from two parts and can't be + * plotted with rectangles + */ + z[0] = p[0]; + z[1] = p[1]; + z[2] = (p[0] + p[2]) / 2; + z[3] = (p[1] + p[3]) / 2; + z[4] = (p[6] + p[4]) / 2; + z[5] = (p[7] + p[5]) / 2; + z[6] = p[6]; + z[7] = p[7]; + res = ctx->plot->polygon(ctx, plot_style_bdr_in, z, 4); + if (res == NSERROR_OK) { + z[0] = p[2]; + z[1] = p[3]; + z[6] = p[4]; + z[7] = p[5]; + res = ctx->plot->polygon(ctx, + plot_style_bdr_out, + z, + 4); + } + } + break; + + case CSS_BORDER_STYLE_INSET: + light = (light + 2) % 4; + /* fall through */ + case CSS_BORDER_STYLE_OUTSET: + /* choose correct colours for each part of the border line */ + switch (light) { + case 0: + plot_style_bdr_in = &plot_style_fillbdr_light; + plot_style_bdr_out = &plot_style_fillbdr_dlight; + break; + case 1: + plot_style_bdr_in = &plot_style_fillbdr_ddark; + plot_style_bdr_out = &plot_style_fillbdr_dark; + break; + case 2: + plot_style_bdr_in = &plot_style_fillbdr_dark; + plot_style_bdr_out = &plot_style_fillbdr_ddark; + break; + case 3: + plot_style_bdr_in = &plot_style_fillbdr_dlight; + plot_style_bdr_out = &plot_style_fillbdr_light; + break; + default: + plot_style_bdr_in = &plot_style_fillbdr; + plot_style_bdr_out = &plot_style_fillbdr; + break; + } + + /* Render border */ + if ((rectangular || thickness == 2) && thickness != 1) { + /* Border made up from two parts and can be + * plotted with rectangles + */ + + /* First part */ + if (side == TOP || side == RIGHT) { + rect.x0 = (p[0] + p[2]) / 2; + rect.y0 = (p[1] + p[3]) / 2; + rect.x1 = p[6]; + rect.y1 = p[7]; + } else { + rect.x0 = p[6]; + rect.y0 = p[7]; + rect.x1 = (p[0] + p[2]) / 2; + rect.y1 = (p[1] + p[3]) / 2; + } + res = plot_clipped_rectangle(ctx, + plot_style_bdr_in, + clip, + &rect); + if (res != NSERROR_OK) { + return res; + } + + /* Second part */ + if (side == TOP || side == RIGHT) { + rect.x0 = p[2]; + rect.y0 = p[3]; + rect.x1 = (p[6] + p[4]) / 2; + rect.y1 = (p[7] + p[5]) / 2; + } else { + rect.x0 = (p[6] + p[4]) / 2; + rect.y0 = (p[7] + p[5]) / 2; + rect.x1 = p[2]; + rect.y1 = p[3]; + } + res = plot_clipped_rectangle(ctx, + plot_style_bdr_out, + clip, + &rect); + } else if (thickness == 1) { + /* Border made up from one part which can be + * plotted as a rectangle + */ + + if (side == TOP || side == RIGHT) { + rect.x0 = p[2]; + rect.y0 = p[3]; + rect.x1 = p[6]; + rect.y1 = p[7]; + rect.x1 = ((side == TOP) && (p[4] - p[6] != 0)) ? + rect.x1 + p[4] - p[6] : rect.x1; + res = plot_clipped_rectangle(ctx, + plot_style_bdr_in, + clip, + &rect); + } else { + rect.x0 = p[6]; + rect.y0 = p[7]; + rect.x1 = p[2]; + rect.y1 = p[3]; + rect.y1 = ((side == LEFT) && (p[1] - p[3] != 0)) ? + rect.y1 + p[1] - p[3] : rect.y1; + res = plot_clipped_rectangle(ctx, + plot_style_bdr_out, + clip, + &rect); + } + } else { + /* Border made up from two parts and can't be + * plotted with rectangles + */ + + z[0] = p[0]; + z[1] = p[1]; + z[2] = (p[0] + p[2]) / 2; + z[3] = (p[1] + p[3]) / 2; + z[4] = (p[6] + p[4]) / 2; + z[5] = (p[7] + p[5]) / 2; + z[6] = p[6]; + z[7] = p[7]; + res = ctx->plot->polygon(ctx, plot_style_bdr_in, z, 4); + if (res != NSERROR_OK) { + return res; + } + z[0] = p[2]; + z[1] = p[3]; + z[6] = p[4]; + z[7] = p[5]; + res = ctx->plot->polygon(ctx, plot_style_bdr_out, z, 4); + } + break; + } + + return res; +} + + +/** + * Draw borders for a box. + * + * \param box box to draw + * \param x_parent coordinate of left padding edge of parent of box + * \param y_parent coordinate of top padding edge of parent of box + * \param p_width width of padding box + * \param p_height height of padding box + * \param clip cliping area for redrawing border. + * \param scale scale for redraw + * \param ctx current redraw context + * \return true if successful, false otherwise + */ +bool +html_redraw_borders(struct box *box, + int x_parent, + int y_parent, + int p_width, + int p_height, + const struct rect *clip, + float scale, + const struct redraw_context *ctx) +{ + unsigned int sides[] = { LEFT, RIGHT, TOP, BOTTOM }; + int top = box->border[TOP].width; + int right = box->border[RIGHT].width; + int bottom = box->border[BOTTOM].width; + int left = box->border[LEFT].width; + int x, y; + unsigned int i, side; + int p[8]; /* Box border vertices */ + int z[8]; /* Border vertices */ + bool square_end_1 = false; + bool square_end_2 = false; + nserror res; + + x = x_parent + box->x; + y = y_parent + box->y; + + if (scale != 1.0) { + top *= scale; + right *= scale; + bottom *= scale; + left *= scale; + x *= scale; + y *= scale; + } + + assert(box->style); + + /* Calculate border vertices + * + * A----------------------+ + * | \ / | + * | B--------------+ | + * | | | | + * | +--------------C | + * | / \ | + * +----------------------D + */ + p[0] = x - left; p[1] = y - top; /* A */ + p[2] = x; p[3] = y; /* B */ + p[4] = x + p_width; p[5] = y + p_height; /* C */ + p[6] = x + p_width + right; p[7] = y + p_height + bottom; /* D */ + + for (i = 0; i != 4; i++) { + colour col = 0; + side = sides[i]; /* plot order */ + + if (box->border[side].width == 0 || + nscss_color_is_transparent(box->border[side].c)) { + continue; + } + + switch (side) { + case LEFT: + square_end_1 = (top == 0); + square_end_2 = (bottom == 0); + + z[0] = p[0]; z[1] = p[7]; + z[2] = p[2]; z[3] = p[5]; + z[4] = p[2]; z[5] = p[3]; + z[6] = p[0]; z[7] = p[1]; + + if (nscss_color_is_transparent(box->border[TOP].c) == false && + box->border[TOP].style != CSS_BORDER_STYLE_DOUBLE) { + /* make border overhang top corner fully, + * if top border is opaque + */ + z[5] -= top; + square_end_1 = true; + } + if (nscss_color_is_transparent(box->border[BOTTOM].c) == false && + box->border[BOTTOM].style != CSS_BORDER_STYLE_DOUBLE) { + /* make border overhang bottom corner fully, + * if bottom border is opaque + */ + z[3] += bottom; + square_end_2 = true; + } + + col = nscss_color_to_ns(box->border[side].c); + + res = html_redraw_border_plot(side, + z, + col, + box->border[side].style, + box->border[side].width * scale, + square_end_1 && square_end_2, + clip, + ctx); + if (res != NSERROR_OK) { + return false; + } + break; + + case RIGHT: + square_end_1 = (top == 0); + square_end_2 = (bottom == 0); + + z[0] = p[6]; z[1] = p[1]; + z[2] = p[4]; z[3] = p[3]; + z[4] = p[4]; z[5] = p[5]; + z[6] = p[6]; z[7] = p[7]; + + if (nscss_color_is_transparent(box->border[TOP].c) == false && + box->border[TOP].style != CSS_BORDER_STYLE_DOUBLE) { + /* make border overhang top corner fully, + * if top border is opaque + */ + z[3] -= top; + square_end_1 = true; + } + if (nscss_color_is_transparent(box->border[BOTTOM].c) == false && + box->border[BOTTOM].style != CSS_BORDER_STYLE_DOUBLE) { + /* make border overhang bottom corner fully, + * if bottom border is opaque + */ + z[5] += bottom; + square_end_2 = true; + } + + col = nscss_color_to_ns(box->border[side].c); + + res = html_redraw_border_plot(side, + z, + col, + box->border[side].style, + box->border[side].width * scale, + square_end_1 && square_end_2, + clip, + ctx); + if (res != NSERROR_OK) { + return false; + } + break; + + case TOP: + if (clip->y0 > p[3]) { + /* clip rectangle is below border; nothing to + * plot + */ + continue; + } + + square_end_1 = (left == 0); + square_end_2 = (right == 0); + + z[0] = p[2]; z[1] = p[3]; + z[2] = p[0]; z[3] = p[1]; + z[4] = p[6]; z[5] = p[1]; + z[6] = p[4]; z[7] = p[3]; + + if (box->border[TOP].style == CSS_BORDER_STYLE_SOLID && + box->border[TOP].c == box->border[LEFT].c) { + /* don't bother overlapping left corner if + * it's the same colour anyway + */ + z[2] += left; + square_end_1 = true; + } + if (box->border[TOP].style == CSS_BORDER_STYLE_SOLID && + box->border[TOP].c == box->border[RIGHT].c) { + /* don't bother overlapping right corner if + * it's the same colour anyway + */ + z[4] -= right; + square_end_2 = true; + } + + col = nscss_color_to_ns(box->border[side].c); + + res = html_redraw_border_plot(side, + z, + col, + box->border[side].style, + box->border[side].width * scale, + square_end_1 && square_end_2, + clip, + ctx); + if (res != NSERROR_OK) { + return false; + } + break; + + case BOTTOM: + if (clip->y1 < p[5]) { + /* clip rectangle is above border; nothing to + * plot + */ + continue; + } + + square_end_1 = (left == 0); + square_end_2 = (right == 0); + + z[0] = p[4]; z[1] = p[5]; + z[2] = p[6]; z[3] = p[7]; + z[4] = p[0]; z[5] = p[7]; + z[6] = p[2]; z[7] = p[5]; + + if (box->border[BOTTOM].style == CSS_BORDER_STYLE_SOLID && + box->border[BOTTOM].c == box->border[LEFT].c) { + /* don't bother overlapping left corner if + * it's the same colour anyway + */ + z[4] += left; + square_end_1 = true; + } + if (box->border[BOTTOM].style == CSS_BORDER_STYLE_SOLID && + box->border[BOTTOM].c == box->border[RIGHT].c) { + /* don't bother overlapping right corner if + * it's the same colour anyway + */ + z[2] -= right; + square_end_2 = true; + } + + col = nscss_color_to_ns(box->border[side].c); + + res = html_redraw_border_plot(side, + z, + col, + box->border[side].style, + box->border[side].width * scale, + square_end_1 && square_end_2, + clip, + ctx); + if (res != NSERROR_OK) { + return false; + } + break; + + default: + assert(side == TOP || side == BOTTOM || + side == LEFT || side == RIGHT); + break; + } + } + + return true; +} + + +/** + * Draw an inline's borders. + * + * \param box BOX_INLINE which created the border + * \param b coordinates of border edge rectangle + * \param clip cliping area for redrawing border. + * \param scale scale for redraw + * \param first true if this is the first rectangle associated with the inline + * \param last true if this is the last rectangle associated with the inline + * \param ctx current redraw context + * \return true if successful, false otherwise + */ +bool +html_redraw_inline_borders(struct box *box, + struct rect b, + const struct rect *clip, + float scale, + bool first, + bool last, + const struct redraw_context *ctx) +{ + int top = box->border[TOP].width; + int right = box->border[RIGHT].width; + int bottom = box->border[BOTTOM].width; + int left = box->border[LEFT].width; + colour col; + int p[8]; /* Box border vertices */ + int z[8]; /* Border vertices */ + bool square_end_1; + bool square_end_2; + nserror res; + + if (scale != 1.0) { + top *= scale; + right *= scale; + bottom *= scale; + left *= scale; + } + + /* Calculate border vertices + * + * A----------------------+ + * | \ / | + * | B--------------+ | + * | | | | + * | +--------------C | + * | / \ | + * +----------------------D + */ + p[0] = b.x0; p[1] = b.y0; /* A */ + p[2] = first ? b.x0 + left : b.x0; p[3] = b.y0 + top; /* B */ + p[4] = last ? b.x1 - right : b.x1; p[5] = b.y1 - bottom; /* C */ + p[6] = b.x1; p[7] = b.y1; /* D */ + + assert(box->style); + + /* Left */ + square_end_1 = (top == 0); + square_end_2 = (bottom == 0); + if (left != 0 && + first && + nscss_color_is_transparent(box->border[LEFT].c) == false) { + col = nscss_color_to_ns(box->border[LEFT].c); + + z[0] = p[0]; z[1] = p[7]; + z[2] = p[2]; z[3] = p[5]; + z[4] = p[2]; z[5] = p[3]; + z[6] = p[0]; z[7] = p[1]; + + if (nscss_color_is_transparent(box->border[TOP].c) == false && + box->border[TOP].style != CSS_BORDER_STYLE_DOUBLE) { + /* make border overhang top corner fully, + * if top border is opaque + */ + z[5] -= top; + square_end_1 = true; + } + + if (nscss_color_is_transparent(box->border[BOTTOM].c) == false && + box->border[BOTTOM].style != CSS_BORDER_STYLE_DOUBLE) { + /* make border overhang bottom corner fully, + * if bottom border is opaque + */ + z[3] += bottom; + square_end_2 = true; + } + + res = html_redraw_border_plot(LEFT, + z, + col, + box->border[LEFT].style, + left, + square_end_1 && square_end_2, + clip, + ctx); + if (res != NSERROR_OK) { + return false; + } + } + + /* Right */ + square_end_1 = (top == 0); + square_end_2 = (bottom == 0); + if (right != 0 && + last && + nscss_color_is_transparent(box->border[RIGHT].c) == false) { + col = nscss_color_to_ns(box->border[RIGHT].c); + + z[0] = p[6]; z[1] = p[1]; + z[2] = p[4]; z[3] = p[3]; + z[4] = p[4]; z[5] = p[5]; + z[6] = p[6]; z[7] = p[7]; + + if (nscss_color_is_transparent(box->border[TOP].c) == false && + box->border[TOP].style != CSS_BORDER_STYLE_DOUBLE) { + /* make border overhang top corner fully, + * if top border is opaque + */ + z[3] -= top; + square_end_1 = true; + } + + if (nscss_color_is_transparent(box->border[BOTTOM].c) == false && + box->border[BOTTOM].style != CSS_BORDER_STYLE_DOUBLE) { + /* make border overhang bottom corner fully, + * if bottom border is opaque + */ + z[5] += bottom; + square_end_2 = true; + } + + res = html_redraw_border_plot(RIGHT, + z, + col, + box->border[RIGHT].style, + right, + square_end_1 && square_end_2, + clip, + ctx); + if (res != NSERROR_OK) { + return false; + } + } + + /* Top */ + square_end_1 = (left == 0); + square_end_2 = (right == 0); + if (top != 0 && + nscss_color_is_transparent(box->border[TOP].c) == false) { + col = nscss_color_to_ns(box->border[TOP].c); + + z[0] = p[2]; z[1] = p[3]; + z[2] = p[0]; z[3] = p[1]; + z[4] = p[6]; z[5] = p[1]; + z[6] = p[4]; z[7] = p[3]; + + if (first && + box->border[TOP].style == CSS_BORDER_STYLE_SOLID && + box->border[TOP].c == box->border[LEFT].c) { + /* don't bother overlapping left corner if + * it's the same colour anyway + */ + z[2] += left; + square_end_1 = true; + } + + if (last && + box->border[TOP].style == CSS_BORDER_STYLE_SOLID && + box->border[TOP].c == box->border[RIGHT].c) { + /* don't bother overlapping right corner if + * it's the same colour anyway + */ + z[4] -= right; + square_end_2 = true; + } + + res = html_redraw_border_plot(TOP, + z, + col, + box->border[TOP].style, + top, + square_end_1 && square_end_2, + clip, + ctx); + if (res != NSERROR_OK) { + return false; + } + } + + /* Bottom */ + square_end_1 = (left == 0); + square_end_2 = (right == 0); + if (bottom != 0 && + nscss_color_is_transparent(box->border[BOTTOM].c) == false) { + col = nscss_color_to_ns(box->border[BOTTOM].c); + + z[0] = p[4]; z[1] = p[5]; + z[2] = p[6]; z[3] = p[7]; + z[4] = p[0]; z[5] = p[7]; + z[6] = p[2]; z[7] = p[5]; + + if (first && + box->border[BOTTOM].style == CSS_BORDER_STYLE_SOLID && + box->border[BOTTOM].c == box->border[LEFT].c) { + /* don't bother overlapping left corner if + * it's the same colour anyway + */ + z[4] += left; + square_end_1 = true; + } + + if (last && + box->border[BOTTOM].style == CSS_BORDER_STYLE_SOLID && + box->border[BOTTOM].c == box->border[RIGHT].c) { + /* don't bother overlapping right corner if + * it's the same colour anyway + */ + z[2] -= right; + square_end_2 = true; + } + + res = html_redraw_border_plot(BOTTOM, + z, + col, + box->border[BOTTOM].style, + bottom, + square_end_1 && square_end_2, + clip, + ctx); + if (res != NSERROR_OK) { + return false; + } + } + + return true; +} diff --git a/content/handlers/html/script.c b/content/handlers/html/script.c new file mode 100644 index 0000000..81bdccd --- /dev/null +++ b/content/handlers/html/script.c @@ -0,0 +1,666 @@ +/* + * Copyright 2012 Vincent Sanders <vince(a)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 + * implementation of content handling for text/html scripts. + */ + +#include <assert.h> +#include <ctype.h> +#include <stdint.h> +#include <stdbool.h> +#include <string.h> +#include <strings.h> +#include <stdlib.h> + +#include "utils/config.h" +#include "utils/corestrings.h" +#include "utils/log.h" +#include "utils/messages.h" +#include "netsurf/content.h" +#include "javascript/js.h" +#include "content/content_protected.h" +#include "content/fetch.h" +#include "content/hlcache.h" + +#include "html/html.h" +#include "html/html_internal.h" + +typedef bool (script_handler_t)(struct jsthread *jsthread, const uint8_t *data, size_t size, const char *name); + + +static script_handler_t *select_script_handler(content_type ctype) +{ + if (ctype == CONTENT_JS) { + return js_exec; + } + return NULL; +} + + +/* exported internal interface documented in html/html_internal.h */ +nserror html_script_exec(html_content *c, bool allow_defer) +{ + unsigned int i; + struct html_script *s; + script_handler_t *script_handler; + bool have_run_something = false; + + if (c->jsthread == NULL) { + return NSERROR_BAD_PARAMETER; + } + + for (i = 0, s = c->scripts; i != c->scripts_count; i++, s++) { + if (s->already_started) { + continue; + } + + if ((s->type == HTML_SCRIPT_ASYNC) || + (allow_defer && (s->type == HTML_SCRIPT_DEFER))) { + /* ensure script content is present */ + if (s->data.handle == NULL) + continue; + + /* ensure script content fetch status is not an error */ + if (content_get_status(s->data.handle) == + CONTENT_STATUS_ERROR) + continue; + + /* ensure script handler for content type */ + script_handler = select_script_handler( + content_get_type(s->data.handle)); + if (script_handler == NULL) + continue; /* unsupported type */ + + if (content_get_status(s->data.handle) == + CONTENT_STATUS_DONE) { + /* external script is now available */ + const uint8_t *data; + size_t size; + data = content_get_source_data( + s->data.handle, &size ); + script_handler(c->jsthread, data, size, + nsurl_access(hlcache_handle_get_url(s->data.handle))); + have_run_something = true; + /* We have to re-acquire this here since the + * c->scripts array may have been reallocated + * as a result of executing this script. + */ + s = &(c->scripts[i]); + + s->already_started = true; + + } + } + } + + if (have_run_something) { + return html_proceed_to_done(c); + } + + return NSERROR_OK; +} + +/* create new html script entry */ +static struct html_script * +html_process_new_script(html_content *c, + dom_string *mimetype, + enum html_script_type type) +{ + struct html_script *nscript; + /* add space for new script entry */ + nscript = realloc(c->scripts, + sizeof(struct html_script) * (c->scripts_count + 1)); + if (nscript == NULL) { + return NULL; + } + + c->scripts = nscript; + + /* increment script entry count */ + nscript = &c->scripts[c->scripts_count]; + c->scripts_count++; + + nscript->already_started = false; + nscript->parser_inserted = false; + nscript->force_async = true; + nscript->ready_exec = false; + nscript->async = false; + nscript->defer = false; + + nscript->type = type; + + nscript->mimetype = dom_string_ref(mimetype); /* reference mimetype */ + + return nscript; +} + +/** + * Callback for asyncronous scripts + */ +static nserror +convert_script_async_cb(hlcache_handle *script, + const hlcache_event *event, + void *pw) +{ + html_content *parent = pw; + unsigned int i; + struct html_script *s; + + /* Find script */ + for (i = 0, s = parent->scripts; i != parent->scripts_count; i++, s++) { + if (s->type == HTML_SCRIPT_ASYNC && s->data.handle == script) + break; + } + + assert(i != parent->scripts_count); + + switch (event->type) { + case CONTENT_MSG_LOADING: + break; + + case CONTENT_MSG_READY: + break; + + case CONTENT_MSG_DONE: + NSLOG(netsurf, INFO, "script %d done '%s'", i, + nsurl_access(hlcache_handle_get_url(script))); + parent->base.active--; + NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); + + break; + + case CONTENT_MSG_ERROR: + NSLOG(netsurf, INFO, "script %s failed: %s", + nsurl_access(hlcache_handle_get_url(script)), + event->data.errordata.errormsg); + + hlcache_handle_release(script); + s->data.handle = NULL; + parent->base.active--; + NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); + content_add_error(&parent->base, "?", 0); + + break; + + default: + break; + } + + /* if there are no active fetches remaining begin post parse + * conversion + */ + if (html_can_begin_conversion(parent)) { + html_begin_conversion(parent); + } + + /* if we have already started converting though, then we can handle the + * scripts as they come in. + */ + else if (parent->conversion_begun) { + return html_script_exec(parent, false); + } + + return NSERROR_OK; +} + +/** + * Callback for defer scripts + */ +static nserror +convert_script_defer_cb(hlcache_handle *script, + const hlcache_event *event, + void *pw) +{ + html_content *parent = pw; + unsigned int i; + struct html_script *s; + + /* Find script */ + for (i = 0, s = parent->scripts; i != parent->scripts_count; i++, s++) { + if (s->type == HTML_SCRIPT_DEFER && s->data.handle == script) + break; + } + + assert(i != parent->scripts_count); + + switch (event->type) { + + case CONTENT_MSG_DONE: + NSLOG(netsurf, INFO, "script %d done '%s'", i, + nsurl_access(hlcache_handle_get_url(script))); + parent->base.active--; + NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); + + break; + + case CONTENT_MSG_ERROR: + NSLOG(netsurf, INFO, "script %s failed: %s", + nsurl_access(hlcache_handle_get_url(script)), + event->data.errordata.errormsg); + + hlcache_handle_release(script); + s->data.handle = NULL; + parent->base.active--; + NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); + content_add_error(&parent->base, "?", 0); + + break; + + default: + break; + } + + /* if there are no active fetches remaining begin post parse + * conversion + */ + if (html_can_begin_conversion(parent)) { + html_begin_conversion(parent); + } + + return NSERROR_OK; +} + +/** + * Callback for syncronous scripts + */ +static nserror +convert_script_sync_cb(hlcache_handle *script, + const hlcache_event *event, + void *pw) +{ + html_content *parent = pw; + unsigned int i; + struct html_script *s; + script_handler_t *script_handler; + dom_hubbub_error err; + unsigned int active_sync_scripts = 0; + + /* Count sync scripts which have yet to complete (other than us) */ + for (i = 0, s = parent->scripts; i != parent->scripts_count; i++, s++) { + if (s->type == HTML_SCRIPT_SYNC && + s->data.handle != script && s->already_started == false) { + active_sync_scripts++; + } + } + + /* Find script */ + for (i = 0, s = parent->scripts; i != parent->scripts_count; i++, s++) { + if (s->type == HTML_SCRIPT_SYNC && s->data.handle == script) + break; + } + + assert(i != parent->scripts_count); + + switch (event->type) { + case CONTENT_MSG_DONE: + NSLOG(netsurf, INFO, "script %d done '%s'", i, + nsurl_access(hlcache_handle_get_url(script))); + parent->base.active--; + NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); + + s->already_started = true; + + /* attempt to execute script */ + script_handler = select_script_handler(content_get_type(s->data.handle)); + if (script_handler != NULL && parent->jsthread != NULL) { + /* script has a handler */ + const uint8_t *data; + size_t size; + data = content_get_source_data(s->data.handle, &size ); + script_handler(parent->jsthread, data, size, + nsurl_access(hlcache_handle_get_url(s->data.handle))); + } + + /* continue parse */ + if (parent->parser != NULL && active_sync_scripts == 0) { + err = dom_hubbub_parser_pause(parent->parser, false); + if (err != DOM_HUBBUB_OK) { + NSLOG(netsurf, INFO, "unpause returned 0x%x", err); + } + } + + break; + + case CONTENT_MSG_ERROR: + NSLOG(netsurf, INFO, "script %s failed: %s", + nsurl_access(hlcache_handle_get_url(script)), + event->data.errordata.errormsg); + + hlcache_handle_release(script); + s->data.handle = NULL; + parent->base.active--; + + NSLOG(netsurf, INFO, "%d fetches active", parent->base.active); + content_add_error(&parent->base, "?", 0); + + s->already_started = true; + + /* continue parse */ + if (parent->parser != NULL && active_sync_scripts == 0) { + err = dom_hubbub_parser_pause(parent->parser, false); + if (err != DOM_HUBBUB_OK) { + NSLOG(netsurf, INFO, "unpause returned 0x%x", err); + } + } + + break; + + default: + break; + } + + /* if there are no active fetches remaining begin post parse + * conversion + */ + if (html_can_begin_conversion(parent)) { + html_begin_conversion(parent); + } + + return NSERROR_OK; +} + +/** + * process a script with a src tag + */ +static dom_hubbub_error +exec_src_script(html_content *c, + dom_node *node, + dom_string *mimetype, + dom_string *src) +{ + nserror ns_error; + nsurl *joined; + hlcache_child_context child; + struct html_script *nscript; + bool async; + bool defer; + enum html_script_type script_type; + hlcache_handle_callback script_cb; + dom_hubbub_error ret = DOM_HUBBUB_OK; + dom_exception exc; /* returned by libdom functions */ + + /* src url */ + ns_error = nsurl_join(c->base_url, dom_string_data(src), &joined); + if (ns_error != NSERROR_OK) { + content_broadcast_error(&c->base, NSERROR_NOMEM, NULL); + return DOM_HUBBUB_NOMEM; + } + + NSLOG(netsurf, INFO, "script %i '%s'", c->scripts_count, + nsurl_access(joined)); + + /* there are three ways to process the script tag at this point: + * + * Syncronously pause the parent parse and continue after + * the script has downloaded and executed. (default) + * Async Start the script downloading and execute it when it + * becomes available. + * Defered Start the script downloading and execute it when + * the page has completed parsing, may be set along + * with async where it is ignored. + */ + + /* we interpret the presence of the async and defer attribute + * as true and ignore its value, technically only the empty + * value or the attribute name itself are valid. However + * various browsers interpret this in various ways the most + * compatible approach is to be liberal and accept any + * value. Note setting the values to "false" still makes them true! + */ + exc = dom_element_has_attribute(node, corestring_dom_async, &async); + if (exc != DOM_NO_ERR) { + return DOM_HUBBUB_OK; /* dom error */ + } + + if (c->parse_completed) { + /* After parse completed, all scripts are essentially async */ + async = true; + defer = false; + } + + if (async) { + /* asyncronous script */ + script_type = HTML_SCRIPT_ASYNC; + script_cb = convert_script_async_cb; + + } else { + exc = dom_element_has_attribute(node, + corestring_dom_defer, &defer); + if (exc != DOM_NO_ERR) { + return DOM_HUBBUB_OK; /* dom error */ + } + + if (defer) { + /* defered script */ + script_type = HTML_SCRIPT_DEFER; + script_cb = convert_script_defer_cb; + } else { + /* syncronous script */ + script_type = HTML_SCRIPT_SYNC; + script_cb = convert_script_sync_cb; + } + } + + nscript = html_process_new_script(c, mimetype, script_type); + if (nscript == NULL) { + nsurl_unref(joined); + content_broadcast_error(&c->base, NSERROR_NOMEM, NULL); + return DOM_HUBBUB_NOMEM; + } + + /* set up child fetch encoding and quirks */ + child.charset = c->encoding; + child.quirks = c->base.quirks; + + ns_error = hlcache_handle_retrieve(joined, + 0, + content_get_url(&c->base), + NULL, + script_cb, + c, + &child, + CONTENT_SCRIPT, + &nscript->data.handle); + + + nsurl_unref(joined); + + if (ns_error != NSERROR_OK) { + /* @todo Deal with fetch error better. currently assume + * fetch never became active + */ + /* mark duff script fetch as already started */ + nscript->already_started = true; + NSLOG(netsurf, INFO, "Fetch failed with error %d", ns_error); + } else { + /* update base content active fetch count */ + c->base.active++; + NSLOG(netsurf, INFO, "%d fetches active", c->base.active); + + switch (script_type) { + case HTML_SCRIPT_SYNC: + ret = DOM_HUBBUB_HUBBUB_ERR | HUBBUB_PAUSED; + + case HTML_SCRIPT_ASYNC: + break; + + case HTML_SCRIPT_DEFER: + break; + + default: + assert(0); + } + } + + return ret; +} + +static dom_hubbub_error +exec_inline_script(html_content *c, dom_node *node, dom_string *mimetype) +{ + dom_string *script; + dom_exception exc; /* returned by libdom functions */ + struct lwc_string_s *lwcmimetype; + script_handler_t *script_handler; + struct html_script *nscript; + + /* does not appear to be a src so script is inline content */ + exc = dom_node_get_text_content(node, &script); + if ((exc != DOM_NO_ERR) || (script == NULL)) { + return DOM_HUBBUB_OK; /* no contents, skip */ + } + + nscript = html_process_new_script(c, mimetype, HTML_SCRIPT_INLINE); + if (nscript == NULL) { + dom_string_unref(script); + + content_broadcast_error(&c->base, NSERROR_NOMEM, NULL); + return DOM_HUBBUB_NOMEM; + + } + + nscript->data.string = script; + nscript->already_started = true; + + /* ensure script handler for content type */ + exc = dom_string_intern(mimetype, &lwcmimetype); + if (exc != DOM_NO_ERR) { + return DOM_HUBBUB_DOM; + } + + script_handler = select_script_handler(content_factory_type_from_mime_type(lwcmimetype)); + lwc_string_unref(lwcmimetype); + + if (script_handler != NULL) { + script_handler(c->jsthread, + (const uint8_t *)dom_string_data(script), + dom_string_byte_length(script), + "?inline script?"); + } + return DOM_HUBBUB_OK; +} + + +/** + * process script node parser callback + * + * + */ +dom_hubbub_error +html_process_script(void *ctx, dom_node *node) +{ + html_content *c = (html_content *)ctx; + dom_exception exc; /* returned by libdom functions */ + dom_string *src, *mimetype; + dom_hubbub_error err = DOM_HUBBUB_OK; + + /* ensure javascript context is available */ + /* We should only ever be here if scripting was enabled for this + * content so it's correct to make a javascript context if there + * isn't one already. */ + if (c->jsthread == NULL) { + union content_msg_data msg_data; + + msg_data.jsthread = &c->jsthread; + content_broadcast(&c->base, CONTENT_MSG_GETTHREAD, &msg_data); + NSLOG(netsurf, INFO, "javascript context %p ", c->jsthread); + if (c->jsthread == NULL) { + /* no context and it could not be created, abort */ + return DOM_HUBBUB_OK; + } + } + + NSLOG(netsurf, INFO, "content %p parser %p node %p", c, c->parser, + node); + + exc = dom_element_get_attribute(node, corestring_dom_type, &mimetype); + if (exc != DOM_NO_ERR || mimetype == NULL) { + mimetype = dom_string_ref(corestring_dom_text_javascript); + } + + exc = dom_element_get_attribute(node, corestring_dom_src, &src); + if (exc != DOM_NO_ERR || src == NULL) { + err = exec_inline_script(c, node, mimetype); + } else { + err = exec_src_script(c, node, mimetype, src); + dom_string_unref(src); + } + + dom_string_unref(mimetype); + + return err; +} + +/* exported internal interface documented in html/html_internal.h */ +bool html_saw_insecure_scripts(html_content *htmlc) +{ + struct html_script *s; + unsigned int i; + + for (i = 0, s = htmlc->scripts; i != htmlc->scripts_count; i++, s++) { + if (s->type == HTML_SCRIPT_INLINE) { + /* Inline scripts are no less secure than their + * containing HTML content + */ + continue; + } + if (s->data.handle == NULL) { + /* We've not begun loading this? */ + continue; + } + if (content_saw_insecure_objects(s->data.handle)) { + return true; + } + } + + return false; +} + +/* exported internal interface documented in html/html_internal.h */ +nserror html_script_free(html_content *html) +{ + unsigned int i; + + for (i = 0; i != html->scripts_count; i++) { + if (html->scripts[i].mimetype != NULL) { + dom_string_unref(html->scripts[i].mimetype); + } + + switch (html->scripts[i].type) { + case HTML_SCRIPT_INLINE: + if (html->scripts[i].data.string != NULL) { + dom_string_unref(html->scripts[i].data.string); + } + break; + case HTML_SCRIPT_SYNC: + /* fallthrough */ + case HTML_SCRIPT_ASYNC: + /* fallthrough */ + case HTML_SCRIPT_DEFER: + if (html->scripts[i].data.handle != NULL) { + hlcache_handle_release(html->scripts[i].data.handle); + } + break; + } + } + free(html->scripts); + + return NSERROR_OK; +} ----------------------------------------------------------------------- Summary of changes: content/handlers/html/Makefile | 20 ++++++++--------- content/handlers/html/box_construct.c | 17 +++++++++------ content/handlers/html/box_special.c | 23 ++++++++++---------- content/handlers/html/{html_css.c => css.c} | 0 .../html/{html_css_fetcher.c => css_fetcher.c} | 0 content/handlers/html/{html_forms.c => forms.c} | 0 content/handlers/html/html.c | 2 +- content/handlers/html/html_internal.h | 7 +----- content/handlers/html/{html_object.c => object.c} | 22 ++++++++++++------- content/handlers/html/{html_redraw.c => redraw.c} | 0 .../html/{html_redraw_border.c => redraw_border.c} | 0 content/handlers/html/{html_script.c => script.c} | 0 12 files changed, 47 insertions(+), 44 deletions(-) rename content/handlers/html/{html_css.c => css.c} (100%) rename content/handlers/html/{html_css_fetcher.c => css_fetcher.c} (100%) rename content/handlers/html/{html_forms.c => forms.c} (100%) rename content/handlers/html/{html_object.c => object.c} (98%) rename content/handlers/html/{html_redraw.c => redraw.c} (100%) rename content/handlers/html/{html_redraw_border.c => redraw_border.c} (100%) rename content/handlers/html/{html_script.c => script.c} (100%) diff --git a/content/handlers/html/Makefile b/content/handlers/html/Makefile index 1976624..bdc0513 100644 --- a/content/handlers/html/Makefile +++ b/content/handlers/html/Makefile @@ -6,18 +6,18 @@ S_HTML := box_construct.c \ box_normalise.c \ box_special.c \ box_textarea.c \ + css.c \ + css_fetcher.c \ font.c \ form.c \ + forms.c \ + html.c \ imagemap.c \ + interaction.c \ layout.c \ + object.c \ + redraw.c \ + redraw_border.c \ + script.c \ search.c \ - table.c \ - html.c \ - html_css.c \ - html_css_fetcher.c \ - html_script.c \ - interaction.c \ - html_redraw.c \ - html_redraw_border.c \ - html_forms.c \ - html_object.c + table.c diff --git a/content/handlers/html/box_construct.c b/content/handlers/html/box_construct.c index 1637c0f..fba9764 100644 --- a/content/handlers/html/box_construct.c +++ b/content/handlers/html/box_construct.c @@ -470,9 +470,11 @@ box_construct_marker(struct box *box, if (error != NSERROR_OK) return false; - if (html_fetch_object(ctx->content, url, marker, image_types, - ctx->content->base.available_width, 1000, false) == - false) { + if (html_fetch_object(ctx->content, + url, + marker, + image_types, + false) == false) { nsurl_unref(url); return false; } @@ -705,10 +707,11 @@ box_construct_element(struct box_construct_ctx *ctx, bool *convert_children) error = nsurl_create(lwc_string_data(bgimage_uri), &url); if (error == NSERROR_OK) { /* Fetch image if we got a valid URL */ - if (html_fetch_object(ctx->content, url, box, - image_types, - ctx->content->base.available_width, - 1000, true) == false) { + if (html_fetch_object(ctx->content, + url, + box, + image_types, + true) == false) { nsurl_unref(url); return false; } diff --git a/content/handlers/html/box_special.c b/content/handlers/html/box_special.c index 38031ce..9f4a512 100644 --- a/content/handlers/html/box_special.c +++ b/content/handlers/html/box_special.c @@ -956,8 +956,7 @@ box_embed(dom_node *n, /* start fetch */ box->flags |= IS_REPLACED; - return html_fetch_object(content, params->data, box, CONTENT_ANY, - content->base.available_width, 1000, false); + return html_fetch_object(content, params->data, box, CONTENT_ANY, false); } @@ -1189,8 +1188,7 @@ box_image(dom_node *n, /* start fetch */ box->flags |= IS_REPLACED; - ok = html_fetch_object(content, url, box, image_types, - content->base.available_width, 1000, false); + ok = html_fetch_object(content, url, box, image_types, false); nsurl_unref(url); wtype = css_computed_width(box->style, &value, &wunit); @@ -1332,11 +1330,11 @@ box_input(dom_node *n, */ if (nsurl_compare(url, content->base_url, NSURL_COMPLETE) == false) { - if (!html_fetch_object(content, url, - box, image_types, - content->base. - available_width, - 1000, false)) { + if (!html_fetch_object(content, + url, + box, + image_types, + false)) { nsurl_unref(url); goto no_memory; } @@ -1613,9 +1611,10 @@ box_object(dom_node *n, /* start fetch (MIME type is ok or not specified) */ box->flags |= IS_REPLACED; if (!html_fetch_object(content, - params->data ? params->data : params->classid, - box, CONTENT_ANY, content->base.available_width, 1000, - false)) + params->data ? params->data : params->classid, + box, + CONTENT_ANY, + false)) return false; *convert_children = false; diff --git a/content/handlers/html/html_css.c b/content/handlers/html/css.c similarity index 100% rename from content/handlers/html/html_css.c rename to content/handlers/html/css.c diff --git a/content/handlers/html/html_css_fetcher.c b/content/handlers/html/css_fetcher.c similarity index 100% rename from content/handlers/html/html_css_fetcher.c rename to content/handlers/html/css_fetcher.c diff --git a/content/handlers/html/html_forms.c b/content/handlers/html/forms.c similarity index 100% rename from content/handlers/html/html_forms.c rename to content/handlers/html/forms.c diff --git a/content/handlers/html/html.c b/content/handlers/html/html.c index 01244cc..7230526 100644 --- a/content/handlers/html/html.c +++ b/content/handlers/html/html.c @@ -687,7 +687,7 @@ static bool html_process_img(html_content *c, dom_node *node) dom_string_unref(src); /* Speculatively fetch the image */ - success = html_fetch_object(c, url, NULL, CONTENT_IMAGE, 0, 0, false); + success = html_fetch_object(c, url, NULL, CONTENT_IMAGE, false); nsurl_unref(url); return success; diff --git a/content/handlers/html/html_internal.h b/content/handlers/html/html_internal.h index d981017..6b55334 100644 --- a/content/handlers/html/html_internal.h +++ b/content/handlers/html/html_internal.h @@ -376,15 +376,10 @@ nserror html_css_fetcher_add_item(dom_string *data, nsurl *base_url, * \param url URL of object to fetch (copied) * \param box box that will contain the object * \param permitted_types bitmap of acceptable types - * \param available_width estimate of width of object - * \param available_height estimate of height of object * \param background this is a background image * \return true on success, false on memory exhaustion */ -bool html_fetch_object(html_content *c, nsurl *url, struct box *box, - content_type permitted_types, - int available_width, int available_height, - bool background); +bool html_fetch_object(html_content *c, nsurl *url, struct box *box, content_type permitted_types, bool background); nserror html_object_free_objects(html_content *html); nserror html_object_close_objects(html_content *html); diff --git a/content/handlers/html/html_object.c b/content/handlers/html/object.c similarity index 98% rename from content/handlers/html/html_object.c rename to content/handlers/html/object.c index 587c487..c20118d 100644 --- a/content/handlers/html/html_object.c +++ b/content/handlers/html/object.c @@ -677,10 +677,12 @@ nserror html_object_free_objects(html_content *html) /* exported interface documented in html/html_internal.h */ -bool html_fetch_object(html_content *c, nsurl *url, struct box *box, - content_type permitted_types, - int available_width, int available_height, - bool background) +bool +html_fetch_object(html_content *c, + nsurl *url, + struct box *box, + content_type permitted_types, + bool background) { struct content_html_object *object; hlcache_child_context child; @@ -706,10 +708,14 @@ bool html_fetch_object(html_content *c, nsurl *url, struct box *box, object->background = background; error = hlcache_handle_retrieve(url, - HLCACHE_RETRIEVE_SNIFF_TYPE, - content_get_url(&c->base), NULL, - html_object_callback, object, &child, - object->permitted_types, &object->content); + HLCACHE_RETRIEVE_SNIFF_TYPE, + content_get_url(&c->base), + NULL, + html_object_callback, + object, + &child, + object->permitted_types, + &object->content); if (error != NSERROR_OK) { free(object); return error != NSERROR_NOMEM; diff --git a/content/handlers/html/html_redraw.c b/content/handlers/html/redraw.c similarity index 100% rename from content/handlers/html/html_redraw.c rename to content/handlers/html/redraw.c diff --git a/content/handlers/html/html_redraw_border.c b/content/handlers/html/redraw_border.c similarity index 100% rename from content/handlers/html/html_redraw_border.c rename to content/handlers/html/redraw_border.c diff --git a/content/handlers/html/html_script.c b/content/handlers/html/script.c similarity index 100% rename from content/handlers/html/html_script.c rename to content/handlers/html/script.c -- NetSurf Browser

2 years, 10 months

1
0
0 / 0

netsurf: branch tlsa/flex created. release/3.9-406-geba2131

by NetSurf Browser Project

Gitweb links: ...log http://git.netsurf-browser.org/netsurf.git/shortlog/eba213195070847cd7352... ...commit http://git.netsurf-browser.org/netsurf.git/commit/eba213195070847cd7352f0... ...tree http://git.netsurf-browser.org/netsurf.git/tree/eba213195070847cd7352f039... The branch, tlsa/flex has been created at eba213195070847cd7352f039956cf832a40e9e0 (commit) - Log ----------------------------------------------------------------- commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=eba213195070847cd73... commit eba213195070847cd7352f039956cf832a40e9e0 Author: Michael Drake <michael.drake(a)codethink.co.uk> Commit: Michael Drake <michael.drake(a)codethink.co.uk> WIP: flex diff --git a/content/handlers/html/box.h b/content/handlers/html/box.h index 8ab2875..fbe7cb0 100644 --- a/content/handlers/html/box.h +++ b/content/handlers/html/box.h @@ -118,7 +118,8 @@ typedef enum { BOX_TABLE_ROW_GROUP, BOX_FLOAT_LEFT, BOX_FLOAT_RIGHT, BOX_INLINE_BLOCK, BOX_BR, BOX_TEXT, - BOX_INLINE_END, BOX_NONE + BOX_INLINE_END, BOX_NONE, + BOX_FLEX, BOX_INLINE_FLEX, } box_type; @@ -389,6 +390,19 @@ static inline bool box_is_first_child(struct box *b) return (b->parent == NULL || b == b->parent->children); } +static inline unsigned box_count_children(const struct box *b) +{ + const struct box *c = b->children; + unsigned count = 0; + + while (c != NULL) { + count++; + c = c->next; + } + + return count; +} + /** * Retrieve the box for a dom node, if there is one * diff --git a/content/handlers/html/box_construct.c b/content/handlers/html/box_construct.c index f545785..1932b69 100644 --- a/content/handlers/html/box_construct.c +++ b/content/handlers/html/box_construct.c @@ -230,8 +230,8 @@ static const box_type box_map[] = { BOX_TABLE_CELL, /* CSS_DISPLAY_TABLE_CELL */ BOX_INLINE, /* CSS_DISPLAY_TABLE_CAPTION */ BOX_NONE, /* CSS_DISPLAY_NONE */ - BOX_BLOCK, /* CSS_DISPLAY_FLEX */ - BOX_INLINE_BLOCK, /* CSS_DISPLAY_INLINE_FLEX */ + BOX_FLEX, /* CSS_DISPLAY_FLEX */ + BOX_INLINE_FLEX, /* CSS_DISPLAY_INLINE_FLEX */ }; /* Exported function, see box.h */ @@ -946,6 +946,7 @@ bool box_construct_element(struct box_construct_ctx *ctx, (box->type == BOX_INLINE || box->type == BOX_BR || box->type == BOX_INLINE_BLOCK || + box->type == BOX_INLINE_FLEX || css_computed_float(box->style) == CSS_FLOAT_LEFT || css_computed_float(box->style) == CSS_FLOAT_RIGHT) && props.node_is_root == false) { @@ -994,6 +995,7 @@ bool box_construct_element(struct box_construct_ctx *ctx, box->flags |= CONVERT_CHILDREN; if (box->type == BOX_INLINE || box->type == BOX_BR || + box->type == BOX_INLINE_FLEX || box->type == BOX_INLINE_BLOCK) { /* Inline container must exist, as we'll have * created it above if it didn't */ diff --git a/content/handlers/html/box_normalise.c b/content/handlers/html/box_normalise.c index 7155cb7..6bb107d 100644 --- a/content/handlers/html/box_normalise.c +++ b/content/handlers/html/box_normalise.c @@ -93,6 +93,180 @@ static bool box_normalise_inline_container( const struct box *root, html_content *c); +static bool box_normalise_flex( + struct box *flex_container, + const struct box *root, + html_content *c) +{ + struct box *child; + struct box *next_child; + struct box *implied_flex_item; + css_computed_style *style; + nscss_select_ctx ctx; + + assert(flex_container != NULL); + assert(root != NULL); + + ctx.root_style = root->style; + +#ifdef BOX_NORMALISE_DEBUG + NSLOG(netsurf, INFO, "flex_container %p, flex_container->type %u", + flex_container, flex_container->type); +#endif + + assert(flex_container->type == BOX_FLEX || + flex_container->type == BOX_INLINE_FLEX); + + for (child = flex_container->children; child != NULL; child = next_child) { +#ifdef BOX_NORMALISE_DEBUG + NSLOG(netsurf, INFO, "child %p, child->type = %d", + child, child->type); +#endif + + next_child = child->next; /* child may be destroyed */ + + switch (child->type) { + case BOX_FLEX: + /* ok */ + if (box_normalise_flex(child, root, c) == false) + return false; + break; + case BOX_BLOCK: + /* ok */ + if (box_normalise_block(child, root, c) == false) + return false; + break; + case BOX_INLINE_CONTAINER: + /* insert implied flex item */ + assert(flex_container->style != NULL); + + ctx.ctx = c->select_ctx; + ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); + ctx.base_url = c->base_url; + ctx.universal = c->universal; + + style = nscss_get_blank_style(&ctx, flex_container->style); + if (style == NULL) + return false; + + implied_flex_item = box_create(NULL, style, true, + flex_container->href, + flex_container->target, + NULL, NULL, c->bctx); + if (implied_flex_item == NULL) { + css_computed_style_destroy(style); + return false; + } + implied_flex_item->type = BOX_BLOCK; + + if (child->prev == NULL) + flex_container->children = implied_flex_item; + else + child->prev->next = implied_flex_item; + + implied_flex_item->prev = child->prev; + + while (child != NULL && + child->type == BOX_INLINE_CONTAINER) { + box_add_child(implied_flex_item, child); + + next_child = child->next; + child->next = NULL; + child = next_child; + } + + implied_flex_item->last->next = NULL; + implied_flex_item->next = next_child = child; + if (implied_flex_item->next != NULL) + implied_flex_item->next->prev = implied_flex_item; + else + flex_container->last = implied_flex_item; + implied_flex_item->parent = flex_container; + + if (box_normalise_block(implied_flex_item, + root, c) == false) + return false; + break; + + case BOX_TABLE: + if (box_normalise_table(child, root, c) == false) + return false; + break; + case BOX_INLINE: + case BOX_INLINE_END: + case BOX_INLINE_FLEX: + case BOX_INLINE_BLOCK: + case BOX_FLOAT_LEFT: + case BOX_FLOAT_RIGHT: + case BOX_BR: + case BOX_TEXT: + /* should have been wrapped in inline + container by convert_xml_to_box() */ + assert(0); + break; + case BOX_TABLE_ROW_GROUP: + case BOX_TABLE_ROW: + case BOX_TABLE_CELL: + /* insert implied table */ + assert(flex_container->style != NULL); + + ctx.ctx = c->select_ctx; + ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); + ctx.base_url = c->base_url; + ctx.universal = c->universal; + + style = nscss_get_blank_style(&ctx, flex_container->style); + if (style == NULL) + return false; + + implied_flex_item = box_create(NULL, style, true, + flex_container->href, + flex_container->target, + NULL, NULL, c->bctx); + if (implied_flex_item == NULL) { + css_computed_style_destroy(style); + return false; + } + implied_flex_item->type = BOX_TABLE; + + if (child->prev == NULL) + flex_container->children = implied_flex_item; + else + child->prev->next = implied_flex_item; + + implied_flex_item->prev = child->prev; + + while (child != NULL && ( + child->type == BOX_TABLE_ROW_GROUP || + child->type == BOX_TABLE_ROW || + child->type == BOX_TABLE_CELL)) { + box_add_child(implied_flex_item, child); + + next_child = child->next; + child->next = NULL; + child = next_child; + } + + implied_flex_item->last->next = NULL; + implied_flex_item->next = next_child = child; + if (implied_flex_item->next != NULL) + implied_flex_item->next->prev = implied_flex_item; + else + flex_container->last = implied_flex_item; + implied_flex_item->parent = flex_container; + + if (box_normalise_table(implied_flex_item, + root, c) == false) + return false; + break; + default: + assert(0); + } + } + + return true; +} + /** * Ensure the box tree is correctly nested by adding and removing nodes. * @@ -104,14 +278,15 @@ static bool box_normalise_inline_container( * The tree is modified to satisfy the following: * \code * parent permitted child nodes - * BLOCK, INLINE_BLOCK BLOCK, INLINE_CONTAINER, TABLE - * INLINE_CONTAINER INLINE, INLINE_BLOCK, FLOAT_LEFT, FLOAT_RIGHT, BR, TEXT + * BLOCK, INLINE_BLOCK BLOCK, INLINE_CONTAINER, TABLE, FLEX + * FLEX, INLINE_FLEX BLOCK, INLINE_CONTAINER, TABLE, FLEX + * INLINE_CONTAINER INLINE, INLINE_BLOCK, FLOAT_LEFT, FLOAT_RIGHT, BR, TEXT, INLINE_FLEX * INLINE, TEXT none * TABLE at least 1 TABLE_ROW_GROUP * TABLE_ROW_GROUP at least 1 TABLE_ROW * TABLE_ROW at least 1 TABLE_CELL - * TABLE_CELL BLOCK, INLINE_CONTAINER, TABLE (same as BLOCK) - * FLOAT_(LEFT|RIGHT) exactly 1 BLOCK or TABLE + * TABLE_CELL BLOCK, INLINE_CONTAINER, TABLE, FLEX (same as BLOCK) + * FLOAT_(LEFT|RIGHT) exactly 1 BLOCK, TABLE or FLEX * \endcode */ @@ -147,6 +322,11 @@ bool box_normalise_block( next_child = child->next; /* child may be destroyed */ switch (child->type) { + case BOX_FLEX: + /* ok */ + if (box_normalise_flex(child, root, c) == false) + return false; + break; case BOX_BLOCK: /* ok */ if (box_normalise_block(child, root, c) == false) @@ -162,6 +342,7 @@ bool box_normalise_block( break; case BOX_INLINE: case BOX_INLINE_END: + case BOX_INLINE_FLEX: case BOX_INLINE_BLOCK: case BOX_FLOAT_LEFT: case BOX_FLOAT_RIGHT: @@ -275,6 +456,7 @@ bool box_normalise_table( return false; } break; + case BOX_FLEX: case BOX_BLOCK: case BOX_INLINE_CONTAINER: case BOX_TABLE: @@ -312,6 +494,7 @@ bool box_normalise_table( row_group->prev = child->prev; while (child != NULL && ( + child->type == BOX_FLEX || child->type == BOX_BLOCK || child->type == BOX_INLINE_CONTAINER || child->type == BOX_TABLE || @@ -342,6 +525,7 @@ bool box_normalise_table( break; case BOX_INLINE: case BOX_INLINE_END: + case BOX_INLINE_FLEX: case BOX_INLINE_BLOCK: case BOX_FLOAT_LEFT: case BOX_FLOAT_RIGHT: @@ -634,6 +818,7 @@ bool box_normalise_table_row_group( c) == false) return false; break; + case BOX_FLEX: case BOX_BLOCK: case BOX_INLINE_CONTAINER: case BOX_TABLE: @@ -667,6 +852,7 @@ bool box_normalise_table_row_group( row->prev = child->prev; while (child != NULL && ( + child->type == BOX_FLEX || child->type == BOX_BLOCK || child->type == BOX_INLINE_CONTAINER || child->type == BOX_TABLE || @@ -696,6 +882,7 @@ bool box_normalise_table_row_group( break; case BOX_INLINE: case BOX_INLINE_END: + case BOX_INLINE_FLEX: case BOX_INLINE_BLOCK: case BOX_FLOAT_LEFT: case BOX_FLOAT_RIGHT: @@ -787,6 +974,7 @@ bool box_normalise_table_row( return false; cell = child; break; + case BOX_FLEX: case BOX_BLOCK: case BOX_INLINE_CONTAINER: case BOX_TABLE: @@ -820,6 +1008,7 @@ bool box_normalise_table_row( cell->prev = child->prev; while (child != NULL && ( + child->type == BOX_FLEX || child->type == BOX_BLOCK || child->type == BOX_INLINE_CONTAINER || child->type == BOX_TABLE || @@ -847,6 +1036,7 @@ bool box_normalise_table_row( break; case BOX_INLINE: case BOX_INLINE_END: + case BOX_INLINE_FLEX: case BOX_INLINE_BLOCK: case BOX_FLOAT_LEFT: case BOX_FLOAT_RIGHT: @@ -994,6 +1184,11 @@ bool box_normalise_inline_container( if (box_normalise_block(child, root, c) == false) return false; break; + case BOX_INLINE_FLEX: + /* ok */ + if (box_normalise_flex(child, root, c) == false) + return false; + break; case BOX_FLOAT_LEFT: case BOX_FLOAT_RIGHT: /* ok */ @@ -1028,6 +1223,7 @@ bool box_normalise_inline_container( box_free(child); } break; + case BOX_FLEX: case BOX_BLOCK: case BOX_INLINE_CONTAINER: case BOX_TABLE: diff --git a/content/handlers/html/layout.c b/content/handlers/html/layout.c index ab8c83a..0beee03 100644 --- a/content/handlers/html/layout.c +++ b/content/handlers/html/layout.c @@ -653,7 +653,8 @@ layout_minmax_line(struct box *first, continue; } - if (b->type == BOX_INLINE_BLOCK) { + if (b->type == BOX_INLINE_BLOCK || + b->type == BOX_INLINE_FLEX) { layout_minmax_block(b, font_func, content); if (min < b->min_width) min = b->min_width; @@ -1011,7 +1012,9 @@ static void layout_minmax_block( bool child_has_height = false; assert(block->type == BOX_BLOCK || + block->type == BOX_FLEX || block->type == BOX_INLINE_BLOCK || + block->type == BOX_INLINE_FLEX || block->type == BOX_TABLE_CELL); /* check if the widths have already been calculated */ @@ -1026,7 +1029,8 @@ static void layout_minmax_block( /* set whether the minimum width is of any interest for this box */ if (((block->parent && lh__box_is_float_box(block->parent)) || - block->type == BOX_INLINE_BLOCK) && + block->type == BOX_INLINE_BLOCK || + block->type == BOX_INLINE_FLEX) && wtype != CSS_WIDTH_SET) { /* box shrinks to fit; need minimum width */ block->flags |= NEED_MIN; @@ -1112,6 +1116,11 @@ static void layout_minmax_block( child_has_height = true; child->flags |= MAKE_HEIGHT; break; + case BOX_FLEX: + layout_minmax_block(child, font_func, content); + child_has_height = true; + child->flags |= MAKE_HEIGHT; + break; default: assert(0); } @@ -2034,6 +2043,101 @@ static void layout_move_children(struct box *box, int x, int y) } } +static inline bool layout_flex__main_is_horizontal(struct box *flex) +{ + const css_computed_style *style = flex->style; + + assert(style != NULL); + + switch (css_computed_flex_direction(style)) { + default: /* Fallthrough. */ + case CSS_FLEX_DIRECTION_ROW: /* Fallthrough. */ + case CSS_FLEX_DIRECTION_ROW_REVERSE: + return true; + case CSS_FLEX_DIRECTION_COLUMN: /* Fallthrough. */ + case CSS_FLEX_DIRECTION_COLUMN_REVERSE: + return false; + } +} + +/** + * Layout a flex container. + * + * \param[in] flex table to layout + * \param[in] available_width width of containing block + * \param[in] content memory pool for any new boxes + * \return true on success, false on memory exhaustion + */ +static bool layout_flex(struct box *flex, int available_width, + html_content *content) +{ + bool main_is_horizontal = layout_flex__main_is_horizontal(flex); + int max_width, min_width, max_height, min_height; + const nscss_len_ctx *len_ctx = &content->len_ctx; + struct box_border *border = flex->border; + int *padding = flex->padding; + int *margin = flex->margin; + int *len_main, *len_cross; + unsigned n_children; + struct flex_item_data { + int main_size; + } *flex_item; + + assert(flex->width != UNKNOWN_WIDTH); + assert(flex->width != AUTO); + + layout_find_dimensions(len_ctx, available_width, -1, flex, flex->style, + &flex->width, &flex->height, &max_width, &min_width, + &max_height, &min_height, margin, padding, border); + + if (flex->width == AUTO) { + int w = available_width; + int fixed = 0; + float frac = 0; + + calculate_mbp_width(len_ctx, flex->style, LEFT, + false, true, true, &fixed, &frac); + calculate_mbp_width(len_ctx, flex->style, RIGHT, + false, true, true, &fixed, &frac); + + w -= frac * available_width + fixed; + flex->width = w > 0 ? w : 0; + } + + if (max_width >= 0 && flex->width > max_width) { + flex->width = max_width; + } + if (min_width > 0 && flex->width < min_width) { + flex->width = min_width; + } + + if (flex->height != AUTO) { + if (max_height >= 0 && flex->height > max_height) { + flex->height = max_height; + } + if (min_height > 0 && flex->height < min_height) { + flex->height = min_height; + } + } + + if (main_is_horizontal) { + len_main = &flex->width; + len_cross = &flex->height; + } else { + len_main = &flex->height; + len_cross = &flex->width; + } + + flex_item = calloc(box_count_children(flex), sizeof(*flex_item)); + if (flex_item == false) { + return false; + } + + + free(flex_item); + return true; +} + /** * Layout a table. @@ -4039,7 +4143,9 @@ layout_block_context(struct box *block, enum css_overflow_e overflow_x = CSS_OVERFLOW_VISIBLE; enum css_overflow_e overflow_y = CSS_OVERFLOW_VISIBLE; - assert(box->type == BOX_BLOCK || box->type == BOX_TABLE || + assert(box->type == BOX_BLOCK || + box->type == BOX_FLEX || + box->type == BOX_TABLE || box->type == BOX_INLINE_CONTAINER); /* Tables are laid out before being positioned, because the @@ -4123,7 +4229,7 @@ layout_block_context(struct box *block, layout_block_add_scrollbar(box, RIGHT); layout_block_add_scrollbar(box, BOTTOM); } - } else if (box->type == BOX_TABLE) { + } else if (box->type == BOX_TABLE || box->type == BOX_FLEX) { if (box->style != NULL) { enum css_width_e wtype; css_fixed width = 0; @@ -4156,11 +4262,21 @@ layout_block_context(struct box *block, x1; } } - if (!layout_table(box, box->parent->width - lm - rm, - content)) - return false; - layout_solve_width(box, box->parent->width, box->width, - lm, rm, -1, -1); + if (box->type == BOX_TABLE) { + if (!layout_table(box, + box->parent->width - lm - rm, + content)) + return false; + layout_solve_width(box, + box->parent->width, box->width, + lm, rm, -1, -1); + } else { + if (!layout_flex(box, + box->parent->width - lm - rm, + content)) { + return false; + } + } } /* Position box: horizontal. */ @@ -4176,6 +4292,7 @@ layout_block_context(struct box *block, /* Vertical margin */ if (((box->type == BOX_BLOCK && (box->flags & HAS_HEIGHT)) || + box->type == BOX_FLEX || box->type == BOX_TABLE || (box->type == BOX_INLINE_CONTAINER && !box_is_first_child(box)) || commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=6f31a5cb88ddcb22286... commit 6f31a5cb88ddcb222867dd1f825848600e49c611 Author: Michael Drake <michael.drake(a)codethink.co.uk> Commit: Michael Drake <michael.drake(a)codethink.co.uk> Layout: Constify box through layout_find_dimensions(). diff --git a/content/handlers/html/layout.c b/content/handlers/html/layout.c index 7d2739f..ab8c83a 100644 --- a/content/handlers/html/layout.c +++ b/content/handlers/html/layout.c @@ -1278,7 +1278,7 @@ static void layout_find_dimensions(const nscss_len_ctx *len_ctx, int available_width, int viewport_height, - struct box *box, + const struct box *box, const css_computed_style *style, int *width, int *height, commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=0f9ef67add866aa8f2f... commit 0f9ef67add866aa8f2f570e18fcf0f86b296b591 Author: Michael Drake <michael.drake(a)codethink.co.uk> Commit: Michael Drake <michael.drake(a)codethink.co.uk> Layout: Constify box through layout_handle_box_sizing(). diff --git a/content/handlers/html/layout.c b/content/handlers/html/layout.c index f7653f9..7d2739f 100644 --- a/content/handlers/html/layout.c +++ b/content/handlers/html/layout.c @@ -1227,7 +1227,7 @@ static void layout_minmax_block( */ static void layout_handle_box_sizing( const nscss_len_ctx *len_ctx, - struct box *box, + const struct box *box, int available_width, bool setwidth, int *dimension) commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=8070db3c8ca1c971c9a... commit 8070db3c8ca1c971c9a20c659af96ec31fa162cd Author: Michael Drake <michael.drake(a)codethink.co.uk> Commit: Michael Drake <michael.drake(a)codethink.co.uk> layout: Add helpers for various box type checks. diff --git a/content/handlers/html/layout.c b/content/handlers/html/layout.c index 28a8465..f7653f9 100644 --- a/content/handlers/html/layout.c +++ b/content/handlers/html/layout.c @@ -119,6 +119,50 @@ static inline bool lh__have_border( return border_style_funcs[side](style) != CSS_BORDER_STYLE_NONE; } +/** Layout helper: Check whether box is a float. */ +static inline bool lh__box_is_float_box(const struct box *b) +{ + return b->type == BOX_FLOAT_LEFT || + b->type == BOX_FLOAT_RIGHT; +} + +/** Layout helper: Check whether box takes part in inline flow. */ +static inline bool lh__box_is_inline_flow(const struct box *b) +{ + return b->type == BOX_INLINE || + b->type == BOX_INLINE_BLOCK || + b->type == BOX_TEXT || + b->type == BOX_INLINE_END; +} + +/** Layout helper: Check whether box is inline level. (Includes BR.) */ +static inline bool lh__box_is_inline_level(const struct box *b) +{ + return lh__box_is_inline_flow(b) || + b->type == BOX_BR; +} + +/** Layout helper: Check whether box is inline level. (Includes BR, floats.) */ +static inline bool lh__box_is_inline_content(const struct box *b) +{ + return lh__box_is_float_box(b) || + lh__box_is_inline_level(b); +} + +/** Layout helper: Check whether box is an object. */ +static inline bool lh__box_is_object(const struct box *b) +{ + return b->object || + (b->flags & (IFRAME | REPLACE_DIM)); +} + +/** Layout helper: Check whether box is replaced. */ +static inline bool lh__box_is_replace(const struct box *b) +{ + return b->gadget || + lh__box_is_object(b); +} + /** Array of per-side access functions for computed style border colors. */ static const css_border_color_func border_color_funcs[4] = { [TOP] = css_computed_border_top_color, @@ -584,11 +628,7 @@ layout_minmax_line(struct box *first, css_fixed value = 0; css_unit unit = CSS_UNIT_PX; - assert(b->type == BOX_INLINE || b->type == BOX_INLINE_BLOCK || - b->type == BOX_FLOAT_LEFT || - b->type == BOX_FLOAT_RIGHT || - b->type == BOX_BR || b->type == BOX_TEXT || - b->type == BOX_INLINE_END); + assert(lh__box_is_inline_content(b)); NSLOG(layout, DEBUG, "%p: min %i, max %i", b, min, max); @@ -597,7 +637,7 @@ layout_minmax_line(struct box *first, break; } - if (b->type == BOX_FLOAT_LEFT || b->type == BOX_FLOAT_RIGHT) { + if (lh__box_is_float_box(b)) { assert(b->children); if (b->children->type == BOX_BLOCK) layout_minmax_block(b->children, font_func, @@ -664,8 +704,7 @@ layout_minmax_line(struct box *first, continue; } - if (!b->object && !(b->flags & IFRAME) && !b->gadget && - !(b->flags & REPLACE_DIM)) { + if (lh__box_is_replace(b) == false) { /* inline non-replaced, 10.3.1 and 10.6.1 */ bool no_wrap_box; if (!b->text) @@ -986,8 +1025,7 @@ static void layout_minmax_block( } /* set whether the minimum width is of any interest for this box */ - if (((block->parent && (block->parent->type == BOX_FLOAT_LEFT || - block->parent->type == BOX_FLOAT_RIGHT)) || + if (((block->parent && lh__box_is_float_box(block->parent)) || block->type == BOX_INLINE_BLOCK) && wtype != CSS_WIDTH_SET) { /* box shrinks to fit; need minimum width */ @@ -3183,20 +3221,14 @@ layout_line(struct box *first, for (x = 0, b = first; x <= x1 - x0 && b != 0; b = b->next) { int min_width, max_width, min_height, max_height; - assert(b->type == BOX_INLINE || b->type == BOX_INLINE_BLOCK || - b->type == BOX_FLOAT_LEFT || - b->type == BOX_FLOAT_RIGHT || - b->type == BOX_BR || b->type == BOX_TEXT || - b->type == BOX_INLINE_END); - + assert(lh__box_is_inline_content(b)); NSLOG(layout, DEBUG, "pass 1: b %p, x %i", b, x); - if (b->type == BOX_BR) break; - if (b->type == BOX_FLOAT_LEFT || b->type == BOX_FLOAT_RIGHT) + if (lh__box_is_float_box(b)) continue; if (b->type == BOX_INLINE_BLOCK && (css_computed_position(b->style) == @@ -3262,8 +3294,7 @@ layout_line(struct box *first, continue; } - if (!b->object && !(b->flags & IFRAME) && !b->gadget && - !(b->flags & REPLACE_DIM)) { + if (lh__box_is_replace(b) == false) { /* inline non-replaced, 10.3.1 and 10.6.1 */ b->height = line_height(&content->len_ctx, b->style ? b->style : @@ -3421,10 +3452,7 @@ layout_line(struct box *first, CSS_POSITION_FIXED)) { b->x = x + space_after; - } else if (b->type == BOX_INLINE || - b->type == BOX_INLINE_BLOCK || - b->type == BOX_TEXT || - b->type == BOX_INLINE_END) { + } else if (lh__box_is_inline_flow(b)) { assert(b->width != UNKNOWN_WIDTH); x_previous = x; @@ -3763,9 +3791,7 @@ layout_line(struct box *first, d->y = *y; continue; } else if ((d->type == BOX_INLINE && - ((d->object || d->gadget) == false) && - !(d->flags & IFRAME) && - !(d->flags & REPLACE_DIM)) || + lh__box_is_replace(d) == false) || d->type == BOX_BR || d->type == BOX_TEXT || d->type == BOX_INLINE_END) { @@ -3886,8 +3912,7 @@ static bool layout_inline_container(struct box *inline_container, int width, whitespace == CSS_WHITE_SPACE_PRE_WRAP); } - if ((!c->object && !(c->flags & REPLACE_DIM) && - !(c->flags & IFRAME) && + if ((lh__box_is_object(c) == false && c->text && (c->length || is_pre)) || c->type == BOX_BR) has_text_children = true; @@ -4066,8 +4091,7 @@ layout_block_context(struct box *block, lm = rm = 0; if (box->type == BOX_BLOCK || box->flags & IFRAME) { - if (!box->object && !(box->flags & IFRAME) && - !(box->flags & REPLACE_DIM) && + if (lh__box_is_object(box) == false && box->style && (overflow_x != CSS_OVERFLOW_VISIBLE || overflow_y != CSS_OVERFLOW_VISIBLE)) { commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=2fd7c49e85a0cc00d08... commit 2fd7c49e85a0cc00d083f7d9b8b8c7a79947dd4b Author: Michael Drake <michael.drake(a)codethink.co.uk> Commit: Michael Drake <michael.drake(a)codethink.co.uk> layout: Add helper for checking if a style has a border on a side. diff --git a/content/handlers/html/layout.c b/content/handlers/html/layout.c index c374297..28a8465 100644 --- a/content/handlers/html/layout.c +++ b/content/handlers/html/layout.c @@ -111,6 +111,14 @@ static const css_border_style_func border_style_funcs[4] = { [LEFT] = css_computed_border_left_style, }; +/** Layout helper: Check for CSS border on given side. */ +static inline bool lh__have_border( + enum box_side side, + const css_computed_style *style) +{ + return border_style_funcs[side](style) != CSS_BORDER_STYLE_NONE; +} + /** Array of per-side access functions for computed style border colors. */ static const css_border_color_func border_color_funcs[4] = { [TOP] = css_computed_border_top_color, @@ -302,8 +310,7 @@ calculate_mbp_width(const nscss_len_ctx *len_ctx, /* border */ if (border) { - if (border_style_funcs[side](style) != - CSS_BORDER_STYLE_NONE) { + if (lh__have_border(side, style)) { border_width_funcs[side](style, &value, &unit); *fixed += FIXTOINT(nscss_len2px(len_ctx, commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=26f3055e7582ec87f43... commit 26f3055e7582ec87f431807907fe3b190ae083b0 Author: Michael Drake <michael.drake(a)codethink.co.uk> Commit: Michael Drake <michael.drake(a)codethink.co.uk> layout: Drop redundant else block. diff --git a/content/handlers/html/layout.c b/content/handlers/html/layout.c index 611c778..c374297 100644 --- a/content/handlers/html/layout.c +++ b/content/handlers/html/layout.c @@ -4593,8 +4593,6 @@ layout_absolute(struct box *box, containing_block->padding[RIGHT]; containing_block->height += containing_block->padding[TOP] + containing_block->padding[BOTTOM]; - } else { - /** \todo inline containers */ } layout_compute_offsets(&content->len_ctx, box, containing_block, commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=93bed2cc67ba149801f... commit 93bed2cc67ba149801f2dfd1919e92aceed0e323 Author: Michael Drake <michael.drake(a)codethink.co.uk> Commit: Michael Drake <michael.drake(a)codethink.co.uk> CSS: Simplify css display to box type conversion. diff --git a/content/handlers/css/dump.c b/content/handlers/css/dump.c index b12e1d9..3d17b36 100644 --- a/content/handlers/css/dump.c +++ b/content/handlers/css/dump.c @@ -823,7 +823,7 @@ void nscss_dump_computed_style(FILE *stream, const css_computed_style *style) } /* display */ - val = ns_computed_display_static(style); + val = css_computed_display_static(style); switch (val) { case CSS_DISPLAY_INLINE: fprintf(stream, "display: inline "); @@ -873,6 +873,12 @@ void nscss_dump_computed_style(FILE *stream, const css_computed_style *style) case CSS_DISPLAY_NONE: fprintf(stream, "display: none "); break; + case CSS_DISPLAY_FLEX: + fprintf(stream, "display: flex "); + break; + case CSS_DISPLAY_INLINE_FLEX: + fprintf(stream, "display: inline-flax "); + break; default: break; } diff --git a/content/handlers/css/utils.h b/content/handlers/css/utils.h index e35a660..05ab738 100644 --- a/content/handlers/css/utils.h +++ b/content/handlers/css/utils.h @@ -105,42 +105,6 @@ static inline css_fixed nscss_pixels_physical_to_css( nscss_screen_dpi); } -/** - * Temporary helper wrappers for for libcss computed style getter, while - * we don't support flexbox related property values. - */ - -static inline uint8_t ns_computed_display( - const css_computed_style *style, bool root) -{ - uint8_t value = css_computed_display(style, root); - - if (value == CSS_DISPLAY_FLEX) { - return CSS_DISPLAY_BLOCK; - - } else if (value == CSS_DISPLAY_INLINE_FLEX) { - return CSS_DISPLAY_INLINE_BLOCK; - } - - return value; -} - - -static inline uint8_t ns_computed_display_static( - const css_computed_style *style) -{ - uint8_t value = css_computed_display_static(style); - - if (value == CSS_DISPLAY_FLEX) { - return CSS_DISPLAY_BLOCK; - - } else if (value == CSS_DISPLAY_INLINE_FLEX) { - return CSS_DISPLAY_INLINE_BLOCK; - } - - return value; -} - static inline uint8_t ns_computed_min_height( const css_computed_style *style, diff --git a/content/handlers/html/box_construct.c b/content/handlers/html/box_construct.c index 6271405..f545785 100644 --- a/content/handlers/html/box_construct.c +++ b/content/handlers/html/box_construct.c @@ -213,23 +213,25 @@ nserror cancel_dom_to_box(void *box_conversion_context) /* mapping from CSS display to box type * this table must be in sync with libcss' css_display enum */ static const box_type box_map[] = { - 0, /*CSS_DISPLAY_INHERIT,*/ - BOX_INLINE, /*CSS_DISPLAY_INLINE,*/ - BOX_BLOCK, /*CSS_DISPLAY_BLOCK,*/ - BOX_BLOCK, /*CSS_DISPLAY_LIST_ITEM,*/ - BOX_INLINE, /*CSS_DISPLAY_RUN_IN,*/ - BOX_INLINE_BLOCK, /*CSS_DISPLAY_INLINE_BLOCK,*/ - BOX_TABLE, /*CSS_DISPLAY_TABLE,*/ - BOX_TABLE, /*CSS_DISPLAY_INLINE_TABLE,*/ - BOX_TABLE_ROW_GROUP, /*CSS_DISPLAY_TABLE_ROW_GROUP,*/ - BOX_TABLE_ROW_GROUP, /*CSS_DISPLAY_TABLE_HEADER_GROUP,*/ - BOX_TABLE_ROW_GROUP, /*CSS_DISPLAY_TABLE_FOOTER_GROUP,*/ - BOX_TABLE_ROW, /*CSS_DISPLAY_TABLE_ROW,*/ - BOX_NONE, /*CSS_DISPLAY_TABLE_COLUMN_GROUP,*/ - BOX_NONE, /*CSS_DISPLAY_TABLE_COLUMN,*/ - BOX_TABLE_CELL, /*CSS_DISPLAY_TABLE_CELL,*/ - BOX_INLINE, /*CSS_DISPLAY_TABLE_CAPTION,*/ - BOX_NONE /*CSS_DISPLAY_NONE*/ + BOX_BLOCK, /* CSS_DISPLAY_INHERIT */ + BOX_INLINE, /* CSS_DISPLAY_INLINE */ + BOX_BLOCK, /* CSS_DISPLAY_BLOCK */ + BOX_BLOCK, /* CSS_DISPLAY_LIST_ITEM */ + BOX_INLINE, /* CSS_DISPLAY_RUN_IN */ + BOX_INLINE_BLOCK, /* CSS_DISPLAY_INLINE_BLOCK */ + BOX_TABLE, /* CSS_DISPLAY_TABLE */ + BOX_TABLE, /* CSS_DISPLAY_INLINE_TABLE */ + BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_ROW_GROUP */ + BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_HEADER_GROUP */ + BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_FOOTER_GROUP */ + BOX_TABLE_ROW, /* CSS_DISPLAY_TABLE_ROW */ + BOX_NONE, /* CSS_DISPLAY_TABLE_COLUMN_GROUP */ + BOX_NONE, /* CSS_DISPLAY_TABLE_COLUMN */ + BOX_TABLE_CELL, /* CSS_DISPLAY_TABLE_CELL */ + BOX_INLINE, /* CSS_DISPLAY_TABLE_CAPTION */ + BOX_NONE, /* CSS_DISPLAY_NONE */ + BOX_BLOCK, /* CSS_DISPLAY_FLEX */ + BOX_INLINE_BLOCK, /* CSS_DISPLAY_INLINE_FLEX */ }; /* Exported function, see box.h */ @@ -637,7 +639,7 @@ static void box_construct_generate(dom_node *n, html_content *content, } /* create box for this element */ - computed_display = ns_computed_display(style, box_is_root(n)); + computed_display = css_computed_display(style, box_is_root(n)); if (computed_display == CSS_DISPLAY_BLOCK || computed_display == CSS_DISPLAY_TABLE) { /* currently only support block level boxes */ @@ -650,7 +652,7 @@ static void box_construct_generate(dom_node *n, html_content *content, } /* set box type from computed display */ - gen->type = box_map[ns_computed_display( + gen->type = box_map[css_computed_display( style, box_is_root(n))]; box_add_child(box, gen); @@ -759,6 +761,7 @@ bool box_construct_element(struct box_construct_ctx *ctx, { dom_string *title0, *s; lwc_string *id = NULL; + enum css_display_e css_display; struct box *box = NULL, *old_box; css_select_results *styles = NULL; struct element_entry *element; @@ -858,16 +861,15 @@ bool box_construct_element(struct box_construct_ctx *ctx, dom_string_unref(s); } + css_display = css_computed_display_static(box->style); + /* Set box type from computed display */ if ((css_computed_position(box->style) == CSS_POSITION_ABSOLUTE || - css_computed_position(box->style) == - CSS_POSITION_FIXED) && - (ns_computed_display_static(box->style) == - CSS_DISPLAY_INLINE || - ns_computed_display_static(box->style) == - CSS_DISPLAY_INLINE_BLOCK || - ns_computed_display_static(box->style) == - CSS_DISPLAY_INLINE_TABLE)) { + css_computed_position(box->style) == CSS_POSITION_FIXED) && + (css_display == CSS_DISPLAY_INLINE || + css_display == CSS_DISPLAY_INLINE_BLOCK || + css_display == CSS_DISPLAY_INLINE_TABLE || + css_display == CSS_DISPLAY_INLINE_FLEX)) { /* Special case for absolute positioning: make absolute inlines * into inline block so that the boxes are constructed in an * inline container as if they were not absolutely positioned. @@ -879,7 +881,7 @@ bool box_construct_element(struct box_construct_ctx *ctx, box->type = BOX_BLOCK; } else { /* Normal mapping */ - box->type = box_map[ns_computed_display(box->style, + box->type = box_map[css_computed_display(box->style, props.node_is_root)]; } @@ -907,7 +909,7 @@ bool box_construct_element(struct box_construct_ctx *ctx, box->styles->styles[CSS_PSEUDO_ELEMENT_BEFORE]); } - if (box->type == BOX_NONE || (ns_computed_display(box->style, + if (box->type == BOX_NONE || (css_computed_display(box->style, props.node_is_root) == CSS_DISPLAY_NONE && props.node_is_root == false)) { css_select_results_destroy(styles); @@ -999,7 +1001,7 @@ bool box_construct_element(struct box_construct_ctx *ctx, box_add_child(props.inline_container, box); } else { - if (ns_computed_display(box->style, props.node_is_root) == + if (css_computed_display(box->style, props.node_is_root) == CSS_DISPLAY_LIST_ITEM) { /* List item: compute marker */ if (box_construct_marker(box, props.title, ctx, @@ -1593,7 +1595,7 @@ bool box_image(BOX_SPECIAL_PARAMS) css_unit wunit = CSS_UNIT_PX; css_unit hunit = CSS_UNIT_PX; - if (box->style && ns_computed_display(box->style, + if (box->style && css_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) return true; @@ -1700,7 +1702,7 @@ bool box_object(BOX_SPECIAL_PARAMS) dom_node *c; dom_exception err; - if (box->style && ns_computed_display(box->style, + if (box->style && css_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) return true; @@ -2357,7 +2359,7 @@ bool box_iframe(BOX_SPECIAL_PARAMS) struct content_html_iframe *iframe; int i; - if (box->style && ns_computed_display(box->style, + if (box->style && css_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) return true; @@ -2601,7 +2603,7 @@ bool box_input(BOX_SPECIAL_PARAMS) gadget->type = GADGET_IMAGE; if (box->style && - ns_computed_display(box->style, + css_computed_display(box->style, box_is_root(n)) != CSS_DISPLAY_NONE && nsoption_bool(foreground_images) == true) { dom_string *s; @@ -2941,7 +2943,7 @@ bool box_embed(BOX_SPECIAL_PARAMS) dom_string *src; dom_exception err; - if (box->style && ns_computed_display(box->style, + if (box->style && css_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) return true; ----------------------------------------------------------------------- -- NetSurf Browser

2 years, 10 months

1
0
0 / 0

netsurf: branch master updated. release/3.9-610-ge8d0ba1

by NetSurf Browser Project

Gitweb links: ...log http://git.netsurf-browser.org/netsurf.git/shortlog/e8d0ba15ad4a91b4644ca... ...commit http://git.netsurf-browser.org/netsurf.git/commit/e8d0ba15ad4a91b4644cac0... ...tree http://git.netsurf-browser.org/netsurf.git/tree/e8d0ba15ad4a91b4644cac009... The branch, master has been updated via e8d0ba15ad4a91b4644cac0095f40bb3246ec509 (commit) from a64261c3bdde79d11c86960181f7b8b5255539be (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=e8d0ba15ad4a91b4644... commit e8d0ba15ad4a91b4644cac0095f40bb3246ec509 Author: Vincent Sanders <vince(a)kyllikki.org> Commit: Vincent Sanders <vince(a)kyllikki.org> split html box processing code reduce the module size of the html box handling code by splitting into smaller sections. No functional code change. diff --git a/content/handlers/html/Makefile b/content/handlers/html/Makefile index 6b4c1e8..1976624 100644 --- a/content/handlers/html/Makefile +++ b/content/handlers/html/Makefile @@ -1,7 +1,23 @@ # HTML content handler sources -S_HTML := box.c box_construct.c box_normalise.c box_textarea.c \ - font.c form.c imagemap.c layout.c search.c table.c \ - html.c html_css.c html_css_fetcher.c html_script.c \ - interaction.c html_redraw.c html_redraw_border.c \ - html_forms.c html_object.c +S_HTML := box_construct.c \ + box_inspect.c \ + box_manipulate.c \ + box_normalise.c \ + box_special.c \ + box_textarea.c \ + font.c \ + form.c \ + imagemap.c \ + layout.c \ + search.c \ + table.c \ + html.c \ + html_css.c \ + html_css_fetcher.c \ + html_script.c \ + interaction.c \ + html_redraw.c \ + html_redraw_border.c \ + html_forms.c \ + html_object.c diff --git a/content/handlers/html/box.c b/content/handlers/html/box.c deleted file mode 100644 index 0ad1061..0000000 --- a/content/handlers/html/box.c +++ /dev/null @@ -1,1141 +0,0 @@ -/* - * Copyright 2005-2007 James Bursa <bursa(a)users.sourceforge.net> - * Copyright 2003 Phil Mellor <monkeyson(a)users.sourceforge.net> - * Copyright 2005 John M Bell <jmb202(a)ecs.soton.ac.uk> - * Copyright 2008 Michael Drake <tlsa(a)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 - * implementation of box tree manipulation. - */ - -#include <assert.h> -#include <stdbool.h> -#include <stdio.h> -#include <string.h> -#include <dom/dom.h> - -#include "utils/nsoption.h" -#include "utils/log.h" -#include "utils/talloc.h" -#include "utils/nsurl.h" -#include "netsurf/misc.h" -#include "netsurf/content.h" -#include "netsurf/mouse.h" -#include "css/utils.h" -#include "css/dump.h" -#include "desktop/scrollbar.h" -#include "desktop/gui_internal.h" -#include "desktop/search.h" - -#include "html/box.h" -#include "html/form_internal.h" -#include "html/html_internal.h" -#include "html/interaction.h" - -#define box_is_float(box) (box->type == BOX_FLOAT_LEFT || \ - box->type == BOX_FLOAT_RIGHT) - -/** - * Destructor for box nodes which own styles - * - * \param b The box being destroyed. - * \return 0 to allow talloc to continue destroying the tree. - */ -static int box_talloc_destructor(struct box *b) -{ - struct html_scrollbar_data *data; - - if ((b->flags & STYLE_OWNED) && b->style != NULL) { - css_computed_style_destroy(b->style); - b->style = NULL; - } - - if (b->styles != NULL) { - css_select_results_destroy(b->styles); - b->styles = NULL; - } - - if (b->href != NULL) - nsurl_unref(b->href); - - if (b->id != NULL) { - lwc_string_unref(b->id); - } - - if (b->node != NULL) { - dom_node_unref(b->node); - } - - if (b->scroll_x != NULL) { - data = scrollbar_get_data(b->scroll_x); - scrollbar_destroy(b->scroll_x); - free(data); - } - - if (b->scroll_y != NULL) { - data = scrollbar_get_data(b->scroll_y); - scrollbar_destroy(b->scroll_y); - free(data); - } - - return 0; -} - - -/* Exported function documented in html/box.h */ -struct box * -box_create(css_select_results *styles, - css_computed_style *style, - bool style_owned, - nsurl *href, - const char *target, - const char *title, - lwc_string *id, - void *context) -{ - unsigned int i; - struct box *box; - - box = talloc(context, struct box); - if (!box) { - return 0; - } - - talloc_set_destructor(box, box_talloc_destructor); - - box->type = BOX_INLINE; - box->flags = 0; - box->flags = style_owned ? (box->flags | STYLE_OWNED) : box->flags; - box->styles = styles; - box->style = style; - box->x = box->y = 0; - box->width = UNKNOWN_WIDTH; - box->height = 0; - box->descendant_x0 = box->descendant_y0 = 0; - box->descendant_x1 = box->descendant_y1 = 0; - for (i = 0; i != 4; i++) - box->margin[i] = box->padding[i] = box->border[i].width = 0; - box->scroll_x = box->scroll_y = NULL; - box->min_width = 0; - box->max_width = UNKNOWN_MAX_WIDTH; - box->byte_offset = 0; - box->text = NULL; - box->length = 0; - box->space = 0; - box->href = (href == NULL) ? NULL : nsurl_ref(href); - box->target = target; - box->title = title; - box->columns = 1; - box->rows = 1; - box->start_column = 0; - box->next = NULL; - box->prev = NULL; - box->children = NULL; - box->last = NULL; - box->parent = NULL; - box->inline_end = NULL; - box->float_children = NULL; - box->float_container = NULL; - box->next_float = NULL; - box->cached_place_below_level = 0; - box->list_marker = NULL; - box->col = NULL; - box->gadget = NULL; - box->usemap = NULL; - box->id = id; - box->background = NULL; - box->object = NULL; - box->object_params = NULL; - box->iframe = NULL; - box->node = NULL; - - return box; -} - - -/* Exported function documented in html/box.h */ -void box_add_child(struct box *parent, struct box *child) -{ - assert(parent); - assert(child); - - if (parent->children != 0) { /* has children already */ - parent->last->next = child; - child->prev = parent->last; - } else { /* this is the first child */ - parent->children = child; - child->prev = 0; - } - - parent->last = child; - child->parent = parent; -} - - -/* Exported function documented in html/box.h */ -void box_insert_sibling(struct box *box, struct box *new_box) -{ - new_box->parent = box->parent; - new_box->prev = box; - new_box->next = box->next; - box->next = new_box; - if (new_box->next) - new_box->next->prev = new_box; - else if (new_box->parent) - new_box->parent->last = new_box; -} - - -/* Exported function documented in html/box.h */ -void box_unlink_and_free(struct box *box) -{ - struct box *parent = box->parent; - struct box *next = box->next; - struct box *prev = box->prev; - - if (parent) { - if (parent->children == box) - parent->children = next; - if (parent->last == box) - parent->last = next ? next : prev; - } - - if (prev) - prev->next = next; - if (next) - next->prev = prev; - - box_free(box); -} - - -/* Exported function documented in html/box.h */ -void box_free(struct box *box) -{ - struct box *child, *next; - - /* free children first */ - for (child = box->children; child; child = next) { - next = child->next; - box_free(child); - } - - /* last this box */ - box_free_box(box); -} - - -/* Exported function documented in html/box.h */ -void box_free_box(struct box *box) -{ - if (!(box->flags & CLONE)) { - if (box->gadget) - form_free_control(box->gadget); - if (box->scroll_x != NULL) - scrollbar_destroy(box->scroll_x); - if (box->scroll_y != NULL) - scrollbar_destroy(box->scroll_y); - if (box->styles != NULL) - css_select_results_destroy(box->styles); - } - - talloc_free(box); -} - - -/* Exported function documented in html/box.h */ -void box_coords(struct box *box, int *x, int *y) -{ - *x = box->x; - *y = box->y; - while (box->parent) { - if (box_is_float(box)) { - assert(box->float_container); - box = box->float_container; - } else { - box = box->parent; - } - *x += box->x - scrollbar_get_offset(box->scroll_x); - *y += box->y - scrollbar_get_offset(box->scroll_y); - } -} - - -/* Exported function documented in html/box.h */ -void box_bounds(struct box *box, struct rect *r) -{ - int width, height; - - box_coords(box, &r->x0, &r->y0); - - width = box->padding[LEFT] + box->width + box->padding[RIGHT]; - height = box->padding[TOP] + box->height + box->padding[BOTTOM]; - - r->x1 = r->x0 + width; - r->y1 = r->y0 + height; -} - - -/** - * Determine if a point lies within a box. - * - * \param[in] len_ctx CSS length conversion context to use. - * \param[in] box Box to consider - * \param[in] x Coordinate relative to box - * \param[in] y Coordinate relative to box - * \param[out] physically If function returning true, physically is set true - * iff point is within the box's physical dimensions and - * false if the point is not within the box's physical - * dimensions but is in the area defined by the box's - * descendants. If function returns false, physically - * is undefined. - * \return true if the point is within the box or a descendant box - * - * This is a helper function for box_at_point(). - */ -static bool box_contains_point( - const nscss_len_ctx *len_ctx, - const struct box *box, - int x, - int y, - bool *physically) -{ - css_computed_clip_rect css_rect; - - if (box->style != NULL && - css_computed_position(box->style) == - CSS_POSITION_ABSOLUTE && - css_computed_clip(box->style, &css_rect) == - CSS_CLIP_RECT) { - /* We have an absolutly positioned box with a clip rect */ - struct rect r = { - .x0 = box->border[LEFT].width, - .y0 = box->border[TOP].width, - .x1 = box->padding[LEFT] + box->width + - box->border[RIGHT].width + - box->padding[RIGHT], - .y1 = box->padding[TOP] + box->height + - box->border[BOTTOM].width + - box->padding[BOTTOM] - }; - if (x >= r.x0 && x < r.x1 && y >= r.y0 && y < r.y1) - *physically = true; - else - *physically = false; - - /* Adjust rect to css clip region */ - if (css_rect.left_auto == false) { - r.x0 += FIXTOINT(nscss_len2px(len_ctx, - css_rect.left, css_rect.lunit, - box->style)); - } - if (css_rect.top_auto == false) { - r.y0 += FIXTOINT(nscss_len2px(len_ctx, - css_rect.top, css_rect.tunit, - box->style)); - } - if (css_rect.right_auto == false) { - r.x1 = box->border[LEFT].width + - FIXTOINT(nscss_len2px(len_ctx, - css_rect.right, - css_rect.runit, - box->style)); - } - if (css_rect.bottom_auto == false) { - r.y1 = box->border[TOP].width + - FIXTOINT(nscss_len2px(len_ctx, - css_rect.bottom, - css_rect.bunit, - box->style)); - } - - /* Test if point is in clipped box */ - if (x >= r.x0 && x < r.x1 && y >= r.y0 && y < r.y1) { - /* inside clip area */ - return true; - } - - /* Not inside clip area */ - return false; - } - if (x >= -box->border[LEFT].width && - x < box->padding[LEFT] + box->width + - box->padding[RIGHT] + box->border[RIGHT].width && - y >= -box->border[TOP].width && - y < box->padding[TOP] + box->height + - box->padding[BOTTOM] + box->border[BOTTOM].width) { - *physically = true; - return true; - } - if (box->list_marker && box->list_marker->x - box->x <= x + - box->list_marker->border[LEFT].width && - x < box->list_marker->x - box->x + - box->list_marker->padding[LEFT] + - box->list_marker->width + - box->list_marker->border[RIGHT].width + - box->list_marker->padding[RIGHT] && - box->list_marker->y - box->y <= y + - box->list_marker->border[TOP].width && - y < box->list_marker->y - box->y + - box->list_marker->padding[TOP] + - box->list_marker->height + - box->list_marker->border[BOTTOM].width + - box->list_marker->padding[BOTTOM]) { - *physically = true; - return true; - } - if ((box->style && css_computed_overflow_x(box->style) == - CSS_OVERFLOW_VISIBLE) || !box->style) { - if (box->descendant_x0 <= x && - x < box->descendant_x1) { - *physically = false; - return true; - } - } - if ((box->style && css_computed_overflow_y(box->style) == - CSS_OVERFLOW_VISIBLE) || !box->style) { - if (box->descendant_y0 <= y && - y < box->descendant_y1) { - *physically = false; - return true; - } - } - return false; -} - - -/** - * Direction to move in a box-tree walk - */ -enum box_walk_dir { - BOX_WALK_CHILDREN, - BOX_WALK_PARENT, - BOX_WALK_NEXT_SIBLING, - BOX_WALK_FLOAT_CHILDREN, - BOX_WALK_NEXT_FLOAT_SIBLING, - BOX_WALK_FLOAT_CONTAINER -}; - - -/** - * Move from box to next box in given direction, adjusting for box coord change - * - * \param b box to move from from - * \param dir direction to move in - * \param x box's global x-coord, updated to position of next box - * \param y box's global y-coord, updated to position of next box - * - * If no box can be found in given direction, NULL is returned. - */ -static inline struct box * -box_move_xy(struct box *b, enum box_walk_dir dir, int *x, int *y) -{ - struct box *rb = NULL; - - switch (dir) { - case BOX_WALK_CHILDREN: - b = b->children; - if (b == NULL) - break; - *x += b->x; - *y += b->y; - if (!box_is_float(b)) { - rb = b; - break; - } - /* fall through */ - - case BOX_WALK_NEXT_SIBLING: - do { - *x -= b->x; - *y -= b->y; - b = b->next; - if (b == NULL) - break; - *x += b->x; - *y += b->y; - } while (box_is_float(b)); - rb = b; - break; - - case BOX_WALK_PARENT: - *x -= b->x; - *y -= b->y; - rb = b->parent; - break; - - case BOX_WALK_FLOAT_CHILDREN: - b = b->float_children; - if (b == NULL) - break; - *x += b->x; - *y += b->y; - rb = b; - break; - - case BOX_WALK_NEXT_FLOAT_SIBLING: - *x -= b->x; - *y -= b->y; - b = b->next_float; - if (b == NULL) - break; - *x += b->x; - *y += b->y; - rb = b; - break; - - case BOX_WALK_FLOAT_CONTAINER: - *x -= b->x; - *y -= b->y; - rb = b->float_container; - break; - - default: - assert(0 && "Bad box walk type."); - } - - return rb; -} - - -/** - * Itterator for walking to next box in interaction order - * - * \param b box to find next box from - * \param x box's global x-coord, updated to position of next box - * \param y box's global y-coord, updated to position of next box - * \param skip_children whether to skip box's children - * - * This walks to a boxes float children before its children. When walking - * children, floating boxes are skipped. - */ -static inline struct box *box_next_xy(struct box *b, int *x, int *y, - bool skip_children) -{ - struct box *n; - int tx, ty; - - assert(b != NULL); - - if (skip_children) { - /* Caller is not interested in any kind of children */ - goto skip_children; - } - - tx = *x; ty = *y; - n = box_move_xy(b, BOX_WALK_FLOAT_CHILDREN, &tx, &ty); - if (n) { - /* Next node is float child */ - *x = tx; - *y = ty; - return n; - } -done_float_children: - - tx = *x; ty = *y; - n = box_move_xy(b, BOX_WALK_CHILDREN, &tx, &ty); - if (n) { - /* Next node is child */ - *x = tx; - *y = ty; - return n; - } - -skip_children: - tx = *x; ty = *y; - n = box_move_xy(b, BOX_WALK_NEXT_FLOAT_SIBLING, &tx, &ty); - if (n) { - /* Go to next float sibling */ - *x = tx; - *y = ty; - return n; - } - - if (box_is_float(b)) { - /* Done floats, but the float container may have children, - * or siblings, or ansestors with siblings. Change to - * float container and move past handling its float children. - */ - b = box_move_xy(b, BOX_WALK_FLOAT_CONTAINER, x, y); - goto done_float_children; - } - - /* Go to next sibling, or nearest ancestor with next sibling. */ - while (b) { - while (!b->next && b->parent) { - b = box_move_xy(b, BOX_WALK_PARENT, x, y); - if (box_is_float(b)) { - /* Go on to next float, if there is one */ - goto skip_children; - } - } - if (!b->next) { - /* No more boxes */ - return NULL; - } - - tx = *x; ty = *y; - n = box_move_xy(b, BOX_WALK_NEXT_SIBLING, &tx, &ty); - if (n) { - /* Go to non-float (ancestor) sibling */ - *x = tx; - *y = ty; - return n; - - } else if (b->parent) { - b = box_move_xy(b, BOX_WALK_PARENT, x, y); - if (box_is_float(b)) { - /* Go on to next float, if there is one */ - goto skip_children; - } - - } else { - /* No more boxes */ - return NULL; - } - } - - assert(b != NULL); - return NULL; -} - - -/* Exported function documented in html/box.h */ -struct box * -box_at_point(const nscss_len_ctx *len_ctx, - struct box *box, - const int x, const int y, - int *box_x, int *box_y) -{ - bool skip_children; - bool physically; - - assert(box); - - skip_children = false; - while ((box = box_next_xy(box, box_x, box_y, skip_children))) { - if (box_contains_point(len_ctx, box, x - *box_x, y - *box_y, - &physically)) { - *box_x -= scrollbar_get_offset(box->scroll_x); - *box_y -= scrollbar_get_offset(box->scroll_y); - - if (physically) - return box; - - skip_children = false; - } else { - skip_children = true; - } - } - - return NULL; -} - - -/** - * Check whether box is nearer mouse coordinates than current nearest box - * - * \param box box to test - * \param bx position of box, in global document coordinates - * \param by position of box, in global document coordinates - * \param x mouse point, in global document coordinates - * \param y mouse point, in global document coordinates - * \param dir direction in which to search (-1 = above-left, - * +1 = below-right) - * \param nearest nearest text box found, or NULL if none - * updated if box is nearer than existing nearest - * \param tx position of text_box, in global document coordinates - * updated if box is nearer than existing nearest - * \param ty position of text_box, in global document coordinates - * updated if box is nearer than existing nearest - * \param nr_xd distance to nearest text box found - * updated if box is nearer than existing nearest - * \param nr_yd distance to nearest text box found - * updated if box is nearer than existing nearest - * \return true if mouse point is inside box - */ -static bool -box_nearer_text_box(struct box *box, - int bx, int by, - int x, int y, - int dir, - struct box **nearest, - int *tx, int *ty, - int *nr_xd, int *nr_yd) -{ - int w = box->padding[LEFT] + box->width + box->padding[RIGHT]; - int h = box->padding[TOP] + box->height + box->padding[BOTTOM]; - int y1 = by + h; - int x1 = bx + w; - int yd = INT_MAX; - int xd = INT_MAX; - - if (x >= bx && x1 > x && y >= by && y1 > y) { - *nearest = box; - *tx = bx; - *ty = by; - return true; - } - - if (box->parent->list_marker != box) { - if (dir < 0) { - /* consider only those children (partly) above-left */ - if (by <= y && bx < x) { - yd = y <= y1 ? 0 : y - y1; - xd = x <= x1 ? 0 : x - x1; - } - } else { - /* consider only those children (partly) below-right */ - if (y1 > y && x1 > x) { - yd = y > by ? 0 : by - y; - xd = x > bx ? 0 : bx - x; - } - } - - /* give y displacement precedence over x */ - if (yd < *nr_yd || (yd == *nr_yd && xd <= *nr_xd)) { - *nr_yd = yd; - *nr_xd = xd; - *nearest = box; - *tx = bx; - *ty = by; - } - } - return false; -} - - -/** - * Pick the text box child of 'box' that is closest to and above-left - * (dir -ve) or below-right (dir +ve) of the point 'x,y' - * - * \param box parent box - * \param bx position of box, in global document coordinates - * \param by position of box, in global document coordinates - * \param fx position of float parent, in global document coordinates - * \param fy position of float parent, in global document coordinates - * \param x mouse point, in global document coordinates - * \param y mouse point, in global document coordinates - * \param dir direction in which to search (-1 = above-left, - * +1 = below-right) - * \param nearest nearest text box found, or NULL if none - * updated if a descendant of box is nearer than old nearest - * \param tx position of nearest, in global document coordinates - * updated if a descendant of box is nearer than old nearest - * \param ty position of nearest, in global document coordinates - * updated if a descendant of box is nearer than old nearest - * \param nr_xd distance to nearest text box found - * updated if a descendant of box is nearer than old nearest - * \param nr_yd distance to nearest text box found - * updated if a descendant of box is nearer than old nearest - * \return true if mouse point is inside text_box - */ -static bool box_nearest_text_box(struct box *box, int bx, int by, - int fx, int fy, int x, int y, int dir, struct box **nearest, - int *tx, int *ty, int *nr_xd, int *nr_yd) -{ - struct box *child = box->children; - int c_bx, c_by; - int c_fx, c_fy; - bool in_box = false; - - if (*nearest == NULL) { - *nr_xd = INT_MAX / 2; /* displacement of 'nearest so far' */ - *nr_yd = INT_MAX / 2; - } - if (box->type == BOX_INLINE_CONTAINER) { - int bw = box->padding[LEFT] + box->width + box->padding[RIGHT]; - int bh = box->padding[TOP] + box->height + box->padding[BOTTOM]; - int b_y1 = by + bh; - int b_x1 = bx + bw; - if (x >= bx && b_x1 > x && y >= by && b_y1 > y) { - in_box = true; - } - } - - while (child) { - if (child->type == BOX_FLOAT_LEFT || - child->type == BOX_FLOAT_RIGHT) { - c_bx = fx + child->x - - scrollbar_get_offset(child->scroll_x); - c_by = fy + child->y - - scrollbar_get_offset(child->scroll_y); - } else { - c_bx = bx + child->x - - scrollbar_get_offset(child->scroll_x); - c_by = by + child->y - - scrollbar_get_offset(child->scroll_y); - } - if (child->float_children) { - c_fx = c_bx; - c_fy = c_by; - } else { - c_fx = fx; - c_fy = fy; - } - if (in_box && child->text && !child->object) { - if (box_nearer_text_box(child, - c_bx, c_by, x, y, dir, nearest, - tx, ty, nr_xd, nr_yd)) - return true; - } else { - if (child->list_marker) { - if (box_nearer_text_box( - child->list_marker, - c_bx + child->list_marker->x, - c_by + child->list_marker->y, - x, y, dir, nearest, - tx, ty, nr_xd, nr_yd)) - return true; - } - if (box_nearest_text_box(child, c_bx, c_by, - c_fx, c_fy, x, y, dir, nearest, tx, ty, - nr_xd, nr_yd)) - return true; - } - child = child->next; - } - - return false; -} - - -/* Exported function documented in html/box.h */ -struct box * -box_pick_text_box(struct html_content *html, - int x, int y, - int dir, - int *dx, int *dy) -{ - struct box *text_box = NULL; - struct box *box; - int nr_xd, nr_yd; - int bx, by; - int fx, fy; - int tx, ty; - - if (html == NULL) - return NULL; - - box = html->layout; - bx = box->margin[LEFT]; - by = box->margin[TOP]; - fx = bx; - fy = by; - - if (!box_nearest_text_box(box, bx, by, fx, fy, x, y, - dir, &text_box, &tx, &ty, &nr_xd, &nr_yd)) { - if (text_box && text_box->text && !text_box->object) { - int w = (text_box->padding[LEFT] + - text_box->width + - text_box->padding[RIGHT]); - int h = (text_box->padding[TOP] + - text_box->height + - text_box->padding[BOTTOM]); - int x1, y1; - - y1 = ty + h; - x1 = tx + w; - - /* ensure point lies within the text box */ - if (x < tx) x = tx; - if (y < ty) y = ty; - if (y > y1) y = y1; - if (x > x1) x = x1; - } - } - - /* return coordinates relative to box */ - *dx = x - tx; - *dy = y - ty; - - return text_box; -} - - -/* Exported function documented in html/box.h */ -struct box *box_find_by_id(struct box *box, lwc_string *id) -{ - struct box *a, *b; - bool m; - - if (box->id != NULL && - lwc_string_isequal(id, box->id, &m) == lwc_error_ok && - m == true) - return box; - - for (a = box->children; a; a = a->next) { - if ((b = box_find_by_id(a, id)) != NULL) - return b; - } - - return NULL; -} - - -/* Exported function documented in html/box.h */ -bool box_visible(struct box *box) -{ - /* visibility: hidden */ - if (box->style && css_computed_visibility(box->style) == - CSS_VISIBILITY_HIDDEN) - return false; - - return true; -} - - -/* Exported function documented in html/box.h */ -void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style) -{ - unsigned int i; - struct box *c, *prev; - - for (i = 0; i != depth; i++) - fprintf(stream, " "); - - fprintf(stream, "%p ", box); - fprintf(stream, "x%i y%i w%i h%i ", box->x, box->y, - box->width, box->height); - if (box->max_width != UNKNOWN_MAX_WIDTH) - fprintf(stream, "min%i max%i ", box->min_width, box->max_width); - fprintf(stream, "(%i %i %i %i) ", - box->descendant_x0, box->descendant_y0, - box->descendant_x1, box->descendant_y1); - - fprintf(stream, "m(%i %i %i %i) ", - box->margin[TOP], box->margin[LEFT], - box->margin[BOTTOM], box->margin[RIGHT]); - - switch (box->type) { - case BOX_BLOCK: fprintf(stream, "BLOCK "); break; - case BOX_INLINE_CONTAINER: fprintf(stream, "INLINE_CONTAINER "); break; - case BOX_INLINE: fprintf(stream, "INLINE "); break; - case BOX_INLINE_END: fprintf(stream, "INLINE_END "); break; - case BOX_INLINE_BLOCK: fprintf(stream, "INLINE_BLOCK "); break; - case BOX_TABLE: fprintf(stream, "TABLE [columns %i] ", - box->columns); break; - case BOX_TABLE_ROW: fprintf(stream, "TABLE_ROW "); break; - case BOX_TABLE_CELL: fprintf(stream, "TABLE_CELL [columns %i, " - "start %i, rows %i] ", box->columns, - box->start_column, box->rows); break; - case BOX_TABLE_ROW_GROUP: fprintf(stream, "TABLE_ROW_GROUP "); break; - case BOX_FLOAT_LEFT: fprintf(stream, "FLOAT_LEFT "); break; - case BOX_FLOAT_RIGHT: fprintf(stream, "FLOAT_RIGHT "); break; - case BOX_BR: fprintf(stream, "BR "); break; - case BOX_TEXT: fprintf(stream, "TEXT "); break; - default: fprintf(stream, "Unknown box type "); - } - - if (box->text) - fprintf(stream, "%li '%.*s' ", (unsigned long) box->byte_offset, - (int) box->length, box->text); - if (box->space) - fprintf(stream, "space "); - if (box->object) { - fprintf(stream, "(object '%s') ", - nsurl_access(hlcache_handle_get_url(box->object))); - } - if (box->iframe) { - fprintf(stream, "(iframe) "); - } - if (box->gadget) - fprintf(stream, "(gadget) "); - if (style && box->style) - nscss_dump_computed_style(stream, box->style); - if (box->href) - fprintf(stream, " -> '%s'", nsurl_access(box->href)); - if (box->target) - fprintf(stream, " |%s|", box->target); - if (box->title) - fprintf(stream, " [%s]", box->title); - if (box->id) - fprintf(stream, " ID:%s", lwc_string_data(box->id)); - if (box->type == BOX_INLINE || box->type == BOX_INLINE_END) - fprintf(stream, " inline_end %p", box->inline_end); - if (box->float_children) - fprintf(stream, " float_children %p", box->float_children); - if (box->next_float) - fprintf(stream, " next_float %p", box->next_float); - if (box->float_container) - fprintf(stream, " float_container %p", box->float_container); - if (box->col) { - fprintf(stream, " (columns"); - for (i = 0; i != box->columns; i++) - fprintf(stream, " (%s %s %i %i %i)", - ((const char *[]) {"UNKNOWN", "FIXED", - "AUTO", "PERCENT", "RELATIVE"}) - [box->col[i].type], - ((const char *[]) {"normal", - "positioned"}) - [box->col[i].positioned], - box->col[i].width, - box->col[i].min, box->col[i].max); - fprintf(stream, ")"); - } - if (box->node != NULL) { - dom_string *name; - if (dom_node_get_node_name(box->node, &name) == DOM_NO_ERR) { - fprintf(stream, " <%s>", dom_string_data(name)); - dom_string_unref(name); - } - } - fprintf(stream, "\n"); - - if (box->list_marker) { - for (i = 0; i != depth; i++) - fprintf(stream, " "); - fprintf(stream, "list_marker:\n"); - box_dump(stream, box->list_marker, depth + 1, style); - } - - for (c = box->children; c && c->next; c = c->next) - ; - if (box->last != c) - fprintf(stream, "warning: box->last %p (should be %p) " - "(box %p)\n", box->last, c, box); - for (prev = 0, c = box->children; c; prev = c, c = c->next) { - if (c->parent != box) - fprintf(stream, "warning: box->parent %p (should be " - "%p) (box on next line)\n", - c->parent, box); - if (c->prev != prev) - fprintf(stream, "warning: box->prev %p (should be " - "%p) (box on next line)\n", - c->prev, prev); - box_dump(stream, c, depth + 1, style); - } -} - - -/* exported interface documented in html/box.h */ -nserror -box_handle_scrollbars(struct content *c, - struct box *box, - bool bottom, - bool right) -{ - struct html_scrollbar_data *data; - int visible_width, visible_height; - int full_width, full_height; - nserror res; - - if (!bottom && box->scroll_x != NULL) { - data = scrollbar_get_data(box->scroll_x); - scrollbar_destroy(box->scroll_x); - free(data); - box->scroll_x = NULL; - } - - if (!right && box->scroll_y != NULL) { - data = scrollbar_get_data(box->scroll_y); - scrollbar_destroy(box->scroll_y); - free(data); - box->scroll_y = NULL; - } - - if (!bottom && !right) { - return NSERROR_OK; - } - - visible_width = box->width + box->padding[RIGHT] + box->padding[LEFT]; - visible_height = box->height + box->padding[TOP] + box->padding[BOTTOM]; - - full_width = ((box->descendant_x1 - box->border[RIGHT].width) > - visible_width) ? - box->descendant_x1 + box->padding[RIGHT] : - visible_width; - full_height = ((box->descendant_y1 - box->border[BOTTOM].width) > - visible_height) ? - box->descendant_y1 + box->padding[BOTTOM] : - visible_height; - - if (right) { - if (box->scroll_y == NULL) { - data = malloc(sizeof(struct html_scrollbar_data)); - if (data == NULL) { - return NSERROR_NOMEM; - } - data->c = c; - data->box = box; - res = scrollbar_create(false, - visible_height, - full_height, - visible_height, - data, - html_overflow_scroll_callback, - &(box->scroll_y)); - if (res != NSERROR_OK) { - return res; - } - } else { - scrollbar_set_extents(box->scroll_y, - visible_height, - visible_height, - full_height); - } - } - if (bottom) { - if (box->scroll_x == NULL) { - data = malloc(sizeof(struct html_scrollbar_data)); - if (data == NULL) { - return NSERROR_OK; - } - data->c = c; - data->box = box; - res = scrollbar_create(true, - visible_width - (right ? SCROLLBAR_WIDTH : 0), - full_width, - visible_width, - data, - html_overflow_scroll_callback, - &box->scroll_x); - if (res != NSERROR_OK) { - return res; - } - } else { - scrollbar_set_extents(box->scroll_x, - visible_width - - (right ? SCROLLBAR_WIDTH : 0), - visible_width, full_width); - } - } - - if (right && bottom) { - scrollbar_make_pair(box->scroll_x, box->scroll_y); - } - - return NSERROR_OK; -} - - -/* exported interface documented in html/box.h */ -bool box_vscrollbar_present(const struct box * const box) -{ - return box->padding[TOP] + box->height + box->padding[BOTTOM] + - box->border[BOTTOM].width < box->descendant_y1; -} - - -/* exported interface documented in html/box.h */ -bool box_hscrollbar_present(const struct box * const box) -{ - return box->padding[LEFT] + box->width + box->padding[RIGHT] + - box->border[RIGHT].width < box->descendant_x1; -} diff --git a/content/handlers/html/box.h b/content/handlers/html/box.h index 1781d13..b4da031 100644 --- a/content/handlers/html/box.h +++ b/content/handlers/html/box.h @@ -1,6 +1,7 @@ /* * Copyright 2005 James Bursa <bursa(a)users.sourceforge.net> * Copyright 2003 Phil Mellor <monkeyson(a)users.sourceforge.net> + * Copyright 2020 Vincent Sanders <vince(a)netsurf-browser.org> * * This file is part of NetSurf, http://www.netsurf-browser.org/ * @@ -19,69 +20,8 @@ /** * \file - * Box tree construction and manipulation interface. + * Box interface. * - * This stage of rendering converts a tree of dom_nodes (produced by libdom) - * to a tree of struct box. The box tree represents the structure of the - * document as given by the CSS display and float properties. - * - * For example, consider the following HTML: - * \code - * <h1>Example Heading</h1> - * <p>Example paragraph <em>with emphasised text</em> etc.</p> \endcode - * - * This would produce approximately the following box tree with default CSS - * rules: - * \code - * BOX_BLOCK (corresponds to h1) - * BOX_INLINE_CONTAINER - * BOX_INLINE "Example Heading" - * BOX_BLOCK (p) - * BOX_INLINE_CONTAINER - * BOX_INLINE "Example paragraph " - * BOX_INLINE "with emphasised text" (em) - * BOX_INLINE "etc." \endcode - * - * Note that the em has been collapsed into the INLINE_CONTAINER. - * - * If these CSS rules were applied: - * \code - * h1 { display: table-cell } - * p { display: table-cell } - * em { float: left; width: 5em } \endcode - * - * then the box tree would instead look like this: - * \code - * BOX_TABLE - * BOX_TABLE_ROW_GROUP - * BOX_TABLE_ROW - * BOX_TABLE_CELL (h1) - * BOX_INLINE_CONTAINER - * BOX_INLINE "Example Heading" - * BOX_TABLE_CELL (p) - * BOX_INLINE_CONTAINER - * BOX_INLINE "Example paragraph " - * BOX_FLOAT_LEFT (em) - * BOX_BLOCK - * BOX_INLINE_CONTAINER - * BOX_INLINE "with emphasised text" - * BOX_INLINE "etc." \endcode - * - * Here implied boxes have been added and a float is present. - * - * A box tree is "normalized" if the following is satisfied: - * \code - * parent permitted child nodes - * BLOCK, INLINE_BLOCK BLOCK, INLINE_CONTAINER, TABLE - * INLINE_CONTAINER INLINE, INLINE_BLOCK, FLOAT_LEFT, FLOAT_RIGHT, BR, TEXT, - * INLINE_END - * INLINE none - * TABLE at least 1 TABLE_ROW_GROUP - * TABLE_ROW_GROUP at least 1 TABLE_ROW - * TABLE_ROW at least 1 TABLE_CELL - * TABLE_CELL BLOCK, INLINE_CONTAINER, TABLE (same as BLOCK) - * FLOAT_(LEFT|RIGHT) exactly 1 BLOCK or TABLE - * \endcode */ #ifndef NETSURF_HTML_BOX_H @@ -89,7 +29,6 @@ #include <limits.h> #include <stdbool.h> -#include <stdio.h> #include <libcss/libcss.h> #include "content/handlers/css/utils.h" @@ -517,197 +456,4 @@ extern const char *TARGET_TOP; extern const char *TARGET_BLANK; -/** - * Create a box tree node. - * - * \param styles selection results for the box, or NULL - * \param style computed style for the box (not copied), or 0 - * \param style_owned whether style is owned by this box - * \param href href for the box (copied), or 0 - * \param target target for the box (not copied), or 0 - * \param title title for the box (not copied), or 0 - * \param id id for the box (not copied), or 0 - * \param context context for allocations - * \return allocated and initialised box, or 0 on memory exhaustion - * - * styles is always owned by the box, if it is set. - * style is only owned by the box in the case of implied boxes. - */ -struct box * box_create(css_select_results *styles, css_computed_style *style, bool style_owned, struct nsurl *href, const char *target, const char *title, lwc_string *id, void *context); - - -/** - * Add a child to a box tree node. - * - * \param parent box giving birth - * \param child box to link as last child of parent - */ -void box_add_child(struct box *parent, struct box *child); - - -/** - * Insert a new box as a sibling to a box in a tree. - * - * \param box box already in tree - * \param new_box box to link into tree as next sibling - */ -void box_insert_sibling(struct box *box, struct box *new_box); - - -/** - * Unlink a box from the box tree and then free it recursively. - * - * \param box box to unlink and free recursively. - */ -void box_unlink_and_free(struct box *box); - - -/** - * Free a box tree recursively. - * - * \param box box to free recursively - * - * The box and all its children is freed. - */ -void box_free(struct box *box); - - -/** - * Free the data in a single box structure. - * - * \param box box to free - */ -void box_free_box(struct box *box); - - -/** - * Find the absolute coordinates of a box. - * - * \param box the box to calculate coordinates of - * \param x updated to x coordinate - * \param y updated to y coordinate - */ -void box_coords(struct box *box, int *x, int *y); - - -/** - * Find the bounds of a box. - * - * \param box the box to calculate bounds of - * \param r receives bounds - */ -void box_bounds(struct box *box, struct rect *r); - - -/** - * Find the boxes at a point. - * - * \param len_ctx CSS length conversion context for document. - * \param box box to search children of - * \param x point to find, in global document coordinates - * \param y point to find, in global document coordinates - * \param box_x position of box, in global document coordinates, updated - * to position of returned box, if any - * \param box_y position of box, in global document coordinates, updated - * to position of returned box, if any - * \return box at given point, or 0 if none found - * - * To find all the boxes in the hierarchy at a certain point, use code like - * this: - * \code - * struct box *box = top_of_document_to_search; - * int box_x = 0, box_y = 0; - * - * while ((box = box_at_point(len_ctx, box, x, y, &box_x, &box_y))) { - * // process box - * } - * \endcode - */ -struct box *box_at_point(const nscss_len_ctx *len_ctx, struct box *box, const int x, const int y, int *box_x, int *box_y); - - -/** - * Peform pick text on browser window contents to locate the box under - * the mouse pointer, or nearest in the given direction if the pointer is - * not over a text box. - * - * \param html an HTML content - * \param x coordinate of mouse - * \param y coordinate of mouse - * \param dir direction to search (-1 = above-left, +1 = below-right) - * \param dx receives x ordinate of mouse relative to text box - * \param dy receives y ordinate of mouse relative to text box - */ -struct box *box_pick_text_box(struct html_content *html, int x, int y, int dir, int *dx, int *dy); - - -/** - * Find a box based upon its id attribute. - * - * \param box box tree to search - * \param id id to look for - * \return the box or 0 if not found - */ -struct box *box_find_by_id(struct box *box, lwc_string *id); - - -/** - * Determine if a box is visible when the tree is rendered. - * - * \param box box to check - * \return true iff the box is rendered - */ -bool box_visible(struct box *box); - - -/** - * Print a box tree to a file. - */ -void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style); - - -/** - * Applies the given scroll setup to a box. This includes scroll - * creation/deletion as well as scroll dimension updates. - * - * \param c content in which the box is located - * \param box the box to handle the scrolls for - * \param bottom whether the horizontal scrollbar should be present - * \param right whether the vertical scrollbar should be present - * \return true on success false otherwise - */ -nserror box_handle_scrollbars(struct content *c, struct box *box, - bool bottom, bool right); - - -/** - * Determine if a box has a vertical scrollbar. - * - * \param box scrolling box - * \return the box has a vertical scrollbar - */ -bool box_vscrollbar_present(const struct box *box); - - -/** - * Determine if a box has a horizontal scrollbar. - * - * \param box scrolling box - * \return the box has a horizontal scrollbar - */ -bool box_hscrollbar_present(const struct box *box); - - -/** - * Check if layout box is a first child. - * - * \param[in] b Box to check. - * \return true iff box is first child. - */ -static inline bool box_is_first_child(struct box *b) -{ - return (b->parent == NULL || b == b->parent->children); -} - - #endif diff --git a/content/handlers/html/box_construct.c b/content/handlers/html/box_construct.c index a833302..1637c0f 100644 --- a/content/handlers/html/box_construct.c +++ b/content/handlers/html/box_construct.c @@ -25,1886 +25,128 @@ * Implementation of conversion from DOM tree to box tree. */ -#include <assert.h> -#include <stdio.h> -#include <stdbool.h> -#include <stdlib.h> -#include <string.h> -#include <strings.h> - -#include "utils/config.h" -#include "utils/nsoption.h" -#include "utils/corestrings.h" -#include "utils/log.h" -#include "utils/messages.h" -#include "utils/talloc.h" -#include "utils/string.h" -#include "utils/ascii.h" -#include "netsurf/css.h" -#include "netsurf/misc.h" -#include "netsurf/plot_style.h" -#include "content/content_protected.h" -#include "css/hints.h" -#include "css/select.h" -#include "css/utils.h" -#include "desktop/gui_internal.h" - -#include "html/html.h" -#include "html/box.h" -#include "html/box_construct.h" -#include "html/box_normalise.h" -#include "html/box_textarea.h" -#include "html/form_internal.h" -#include "html/html_internal.h" - -/** - * Context for box tree construction - */ -struct box_construct_ctx { - html_content *content; /**< Content we're constructing for */ - - dom_node *n; /**< Current node to process */ - - struct box *root_box; /**< Root box in the tree */ - - box_construct_complete_cb cb; /**< Callback to invoke on completion */ - - int *bctx; /**< talloc context */ -}; - -/** - * Transient properties for construction of current node - */ -struct box_construct_props { - /** Style from which to inherit, or NULL if none */ - const css_computed_style *parent_style; - /** Current link target, or NULL if none */ - nsurl *href; - /** Current frame target, or NULL if none */ - const char *target; - /** Current title attribute, or NULL if none */ - const char *title; - /** Identity of the current block-level container */ - struct box *containing_block; - /** Current container for inlines, or NULL if none - * \note If non-NULL, will be the last child of containing_block */ - struct box *inline_container; - /** Whether the current node is the root of the DOM tree */ - bool node_is_root; -}; - -static const content_type image_types = CONTENT_IMAGE; - -/* the strings are not important, since we just compare the pointers */ -const char *TARGET_SELF = "_self"; -const char *TARGET_PARENT = "_parent"; -const char *TARGET_TOP = "_top"; -const char *TARGET_BLANK = "_blank"; - -/** - * mapping from CSS display to box type this table must be in sync - * with libcss' css_display enum - */ -static const box_type box_map[] = { - 0, /* CSS_DISPLAY_INHERIT, */ - BOX_INLINE, /* CSS_DISPLAY_INLINE, */ - BOX_BLOCK, /* CSS_DISPLAY_BLOCK, */ - BOX_BLOCK, /* CSS_DISPLAY_LIST_ITEM, */ - BOX_INLINE, /* CSS_DISPLAY_RUN_IN, */ - BOX_INLINE_BLOCK, /* CSS_DISPLAY_INLINE_BLOCK, */ - BOX_TABLE, /* CSS_DISPLAY_TABLE, */ - BOX_TABLE, /* CSS_DISPLAY_INLINE_TABLE, */ - BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_ROW_GROUP, */ - BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_HEADER_GROUP, */ - BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_FOOTER_GROUP, */ - BOX_TABLE_ROW, /* CSS_DISPLAY_TABLE_ROW, */ - BOX_NONE, /* CSS_DISPLAY_TABLE_COLUMN_GROUP, */ - BOX_NONE, /* CSS_DISPLAY_TABLE_COLUMN, */ - BOX_TABLE_CELL, /* CSS_DISPLAY_TABLE_CELL, */ - BOX_INLINE, /* CSS_DISPLAY_TABLE_CAPTION, */ - BOX_NONE /* CSS_DISPLAY_NONE */ -}; - - -/** - * determine if a box is the root node - * - * \param n node to check - * \return true if node is root else false. - */ -static inline bool box_is_root(dom_node *n) -{ - dom_node *parent; - dom_node_type type; - dom_exception err; - - err = dom_node_get_parent_node(n, &parent); - if (err != DOM_NO_ERR) - return false; - - if (parent != NULL) { - err = dom_node_get_node_type(parent, &type); - - dom_node_unref(parent); - - if (err != DOM_NO_ERR) - return false; - - if (type != DOM_DOCUMENT_NODE) - return false; - } - - return true; -} - - -/** - * Destructor for object_params, for <object> elements - * - * \param o The object params being destroyed. - * \return 0 to allow talloc to continue destroying the tree. - */ -static int box_object_talloc_destructor(struct object_params *o) -{ - if (o->codebase != NULL) - nsurl_unref(o->codebase); - if (o->classid != NULL) - nsurl_unref(o->classid); - if (o->data != NULL) - nsurl_unref(o->data); - - return 0; -} - - -/** - * Parse a multi-length-list, as defined by HTML 4.01. - * - * \param ds dom string to parse - * \param count updated to number of entries - * \return array of struct box_multi_length, or 0 on memory exhaustion - */ -static struct frame_dimension * -box_parse_multi_lengths(const dom_string *ds, unsigned int *count) -{ - char *end; - unsigned int i, n; - struct frame_dimension *length; - const char *s; - - s = dom_string_data(ds); - - for (i = 0, n = 1; s[i]; i++) - if (s[i] == ',') - n++; - - length = calloc(n, sizeof(struct frame_dimension)); - if (!length) - return NULL; - - for (i = 0; i != n; i++) { - while (ascii_is_space(*s)) { - s++; - } - length[i].value = strtof(s, &end); - if (length[i].value <= 0) { - length[i].value = 1; - } - s = end; - switch (*s) { - case '%': - length[i].unit = FRAME_DIMENSION_PERCENT; - break; - case '*': - length[i].unit = FRAME_DIMENSION_RELATIVE; - break; - default: - length[i].unit = FRAME_DIMENSION_PIXELS; - break; - } - while (*s && *s != ',') { - s++; - } - if (*s == ',') { - s++; - } - } - - *count = n; - return length; -} - - -/** - * Destructor for content_html_frames, for frame elements - * - * \param f The frame params being destroyed. - * \return 0 to allow talloc to continue destroying the tree. - */ -static int box_frames_talloc_destructor(struct content_html_frames *f) -{ - if (f->url != NULL) { - nsurl_unref(f->url); - f->url = NULL; - } - - return 0; -} - - -/** - * create a frameset box tree - */ -static bool -box_create_frameset(struct content_html_frames *f, - dom_node *n, - html_content *content) -{ - unsigned int row, col, index, i; - unsigned int rows = 1, cols = 1; - dom_string *s; - dom_exception err; - nsurl *url; - struct frame_dimension *row_height = 0, *col_width = 0; - dom_node *c, *next; - struct content_html_frames *frame; - bool default_border = true; - colour default_border_colour = 0x000000; - - /* parse rows and columns */ - err = dom_element_get_attribute(n, corestring_dom_rows, &s); - if (err == DOM_NO_ERR && s != NULL) { - row_height = box_parse_multi_lengths(s, &rows); - dom_string_unref(s); - if (row_height == NULL) - return false; - } else { - row_height = calloc(1, sizeof(struct frame_dimension)); - if (row_height == NULL) - return false; - row_height->value = 100; - row_height->unit = FRAME_DIMENSION_PERCENT; - } - - err = dom_element_get_attribute(n, corestring_dom_cols, &s); - if (err == DOM_NO_ERR && s != NULL) { - col_width = box_parse_multi_lengths(s, &cols); - dom_string_unref(s); - if (col_width == NULL) { - free(row_height); - return false; - } - } else { - col_width = calloc(1, sizeof(struct frame_dimension)); - if (col_width == NULL) { - free(row_height); - return false; - } - col_width->value = 100; - col_width->unit = FRAME_DIMENSION_PERCENT; - } - - /* common extension: border="0|1" to control all children */ - err = dom_element_get_attribute(n, corestring_dom_border, &s); - if (err == DOM_NO_ERR && s != NULL) { - if ((dom_string_data(s)[0] == '0') && - (dom_string_data(s)[1] == '\0')) - default_border = false; - dom_string_unref(s); - } - - /* common extension: frameborder="yes|no" to control all children */ - err = dom_element_get_attribute(n, corestring_dom_frameborder, &s); - if (err == DOM_NO_ERR && s != NULL) { - if (dom_string_caseless_lwc_isequal(s, - corestring_lwc_no) == 0) - default_border = false; - dom_string_unref(s); - } - - /* common extension: bordercolor="#RRGGBB|<named colour>" to control - *all children */ - err = dom_element_get_attribute(n, corestring_dom_bordercolor, &s); - if (err == DOM_NO_ERR && s != NULL) { - css_color color; - - if (nscss_parse_colour(dom_string_data(s), &color)) - default_border_colour = nscss_color_to_ns(color); - - dom_string_unref(s); - } - - /* update frameset and create default children */ - f->cols = cols; - f->rows = rows; - f->scrolling = BW_SCROLLING_NO; - f->children = talloc_array(content->bctx, struct content_html_frames, - (rows * cols)); - - talloc_set_destructor(f->children, box_frames_talloc_destructor); - - for (row = 0; row < rows; row++) { - for (col = 0; col < cols; col++) { - index = (row * cols) + col; - frame = &f->children[index]; - frame->cols = 0; - frame->rows = 0; - frame->width = col_width[col]; - frame->height = row_height[row]; - frame->margin_width = 0; - frame->margin_height = 0; - frame->name = NULL; - frame->url = NULL; - frame->no_resize = false; - frame->scrolling = BW_SCROLLING_AUTO; - frame->border = default_border; - frame->border_colour = default_border_colour; - frame->children = NULL; - } - } - free(col_width); - free(row_height); - - /* create the frameset windows */ - err = dom_node_get_first_child(n, &c); - if (err != DOM_NO_ERR) - return false; - - for (row = 0; c != NULL && row < rows; row++) { - for (col = 0; c != NULL && col < cols; col++) { - while (c != NULL) { - dom_node_type type; - dom_string *name; - - err = dom_node_get_node_type(c, &type); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } - - err = dom_node_get_node_name(c, &name); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } - - if (type != DOM_ELEMENT_NODE || - (!dom_string_caseless_lwc_isequal( - name, - corestring_lwc_frame) && - !dom_string_caseless_lwc_isequal( - name, - corestring_lwc_frameset - ))) { - err = dom_node_get_next_sibling(c, - &next); - if (err != DOM_NO_ERR) { - dom_string_unref(name); - dom_node_unref(c); - return false; - } - - dom_string_unref(name); - dom_node_unref(c); - c = next; - } else { - /* Got a FRAME or FRAMESET element */ - dom_string_unref(name); - break; - } - } - - if (c == NULL) - break; - - /* get current frame */ - index = (row * cols) + col; - frame = &f->children[index]; - - /* nest framesets */ - err = dom_node_get_node_name(c, &s); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } - - if (dom_string_caseless_lwc_isequal(s, - corestring_lwc_frameset)) { - dom_string_unref(s); - frame->border = 0; - if (box_create_frameset(frame, c, - content) == false) { - dom_node_unref(c); - return false; - } - - err = dom_node_get_next_sibling(c, &next); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } - - dom_node_unref(c); - c = next; - continue; - } - - dom_string_unref(s); - - /* get frame URL (not required) */ - url = NULL; - err = dom_element_get_attribute(c, corestring_dom_src, &s); - if (err == DOM_NO_ERR && s != NULL) { - box_extract_link(content, s, content->base_url, - &url); - dom_string_unref(s); - } - - /* copy url */ - if (url != NULL) { - /* no self-references */ - if (nsurl_compare(content->base_url, url, - NSURL_COMPLETE) == false) - frame->url = url; - url = NULL; - } - - /* fill in specified values */ - err = dom_element_get_attribute(c, corestring_dom_name, &s); - if (err == DOM_NO_ERR && s != NULL) { - frame->name = talloc_strdup(content->bctx, - dom_string_data(s)); - dom_string_unref(s); - } - - if (dom_element_has_attribute(c, corestring_dom_noresize, - &frame->no_resize) != DOM_NO_ERR) { - /* If we can't read the attribute for some reason, - * assume we didn't have it. - */ - frame->no_resize = false; - } - - err = dom_element_get_attribute(c, corestring_dom_frameborder, - &s); - if (err == DOM_NO_ERR && s != NULL) { - i = atoi(dom_string_data(s)); - frame->border = (i != 0); - dom_string_unref(s); - } - - err = dom_element_get_attribute(c, corestring_dom_scrolling, &s); - if (err == DOM_NO_ERR && s != NULL) { - if (dom_string_caseless_lwc_isequal(s, - corestring_lwc_yes)) - frame->scrolling = BW_SCROLLING_YES; - else if (dom_string_caseless_lwc_isequal(s, - corestring_lwc_no)) - frame->scrolling = BW_SCROLLING_NO; - dom_string_unref(s); - } - - err = dom_element_get_attribute(c, corestring_dom_marginwidth, - &s); - if (err == DOM_NO_ERR && s != NULL) { - frame->margin_width = atoi(dom_string_data(s)); - dom_string_unref(s); - } - - err = dom_element_get_attribute(c, corestring_dom_marginheight, - &s); - if (err == DOM_NO_ERR && s != NULL) { - frame->margin_height = atoi(dom_string_data(s)); - dom_string_unref(s); - } - - err = dom_element_get_attribute(c, corestring_dom_bordercolor, - &s); - if (err == DOM_NO_ERR && s != NULL) { - css_color color; - - if (nscss_parse_colour(dom_string_data(s), - &color)) - frame->border_colour = - nscss_color_to_ns(color); - - dom_string_unref(s); - } - - /* advance */ - err = dom_node_get_next_sibling(c, &next); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } - - dom_node_unref(c); - c = next; - } - } - - /* If the last child wasn't a frame, we still need to unref it */ - if (c != NULL) { - dom_node_unref(c); - } - - return true; -} - - -/** - * Destructor for content_html_iframe, for <iframe> elements - * - * \param f The iframe params being destroyed. - * \return 0 to allow talloc to continue destroying the tree. - */ -static int box_iframes_talloc_destructor(struct content_html_iframe *f) -{ - if (f->url != NULL) { - nsurl_unref(f->url); - f->url = NULL; - } - - return 0; -} - - -/** - * Get the value of a dom node element's attribute. - * - * \param n dom element node - * \param attribute name of attribute - * \param context talloc context for result buffer - * \param value updated to value, if the attribute is present - * \return true on success, false if attribute present but memory exhausted - * - * \note returning true does not imply that the attribute was found. If the - * attribute was not found, *value will be unchanged. - */ -static bool -box_get_attribute(dom_node *n, - const char *attribute, - void *context, - char **value) -{ - char *result; - dom_string *attr, *attr_name; - dom_exception err; - - err = dom_string_create_interned((const uint8_t *) attribute, - strlen(attribute), &attr_name); - if (err != DOM_NO_ERR) - return false; - - err = dom_element_get_attribute(n, attr_name, &attr); - if (err != DOM_NO_ERR) { - dom_string_unref(attr_name); - return false; - } - - dom_string_unref(attr_name); - - if (attr != NULL) { - result = talloc_strdup(context, dom_string_data(attr)); - - dom_string_unref(attr); - - if (result == NULL) - return false; - - *value = result; - } - - return true; -} - - -/** - * Helper function for adding textarea widget to box. - * - * This is a load of hacks to ensure boxes replaced with textareas - * can be handled by the layout code. - */ -static bool -box_input_text(html_content *html, struct box *box, struct dom_node *node) -{ - struct box *inline_container, *inline_box; - - box->type = BOX_INLINE_BLOCK; - - inline_container = box_create(NULL, 0, false, 0, 0, 0, 0, html->bctx); - if (!inline_container) - return false; - inline_container->type = BOX_INLINE_CONTAINER; - inline_box = box_create(NULL, box->style, false, 0, 0, box->title, 0, - html->bctx); - if (!inline_box) - return false; - inline_box->type = BOX_TEXT; - inline_box->text = talloc_strdup(html->bctx, ""); - - box_add_child(inline_container, inline_box); - box_add_child(box, inline_container); - - return box_textarea_create_textarea(html, box, node); -} - - -/** - * Add an option to a form select control (helper function for box_select()). - * - * \param control select containing the <option> - * \param n xml element node for <option> - * \return true on success, false on memory exhaustion - */ -static bool box_select_add_option(struct form_control *control, dom_node *n) -{ - char *value = NULL; - char *text = NULL; - char *text_nowrap = NULL; - bool selected; - dom_string *content, *s; - dom_exception err; - - err = dom_node_get_text_content(n, &content); - if (err != DOM_NO_ERR) - return false; - - if (content != NULL) { - text = squash_whitespace(dom_string_data(content)); - dom_string_unref(content); - } else { - text = strdup(""); - } - - if (text == NULL) - goto no_memory; - - err = dom_element_get_attribute(n, corestring_dom_value, &s); - if (err == DOM_NO_ERR && s != NULL) { - value = strdup(dom_string_data(s)); - dom_string_unref(s); - } else { - value = strdup(text); - } - - if (value == NULL) - goto no_memory; - - if (dom_element_has_attribute(n, corestring_dom_selected, &selected) != DOM_NO_ERR) { - /* Assume not selected if we can't read the attribute presence */ - selected = false; - } - - /* replace spaces/TABs with hard spaces to prevent line wrapping */ - text_nowrap = cnv_space2nbsp(text); - if (text_nowrap == NULL) - goto no_memory; - - if (form_add_option(control, value, text_nowrap, selected, n) == false) - goto no_memory; - - free(text); - - return true; - -no_memory: - free(value); - free(text); - free(text_nowrap); - return false; -} - - -/** - * \name Special case element handlers - * - * These functions are called by box_construct_element() when an element is - * being converted, according to the entries in element_table. - * - * The parameters are the xmlNode, the content for the document, and a partly - * filled in box structure for the element. - * - * Return true on success, false on memory exhaustion. Set *convert_children - * to false if children of this element in the XML tree should be skipped (for - * example, if they have been processed in some special way already). - * - * Elements ordered as in the HTML 4.01 specification. Section numbers in - * brackets [] refer to the spec. - * - * \{ - */ - -/** - * special element handler for Anchor [12.2]. - */ -static bool -box_a(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - bool ok; - nsurl *url; - dom_string *s; - dom_exception err; - - err = dom_element_get_attribute(n, corestring_dom_href, &s); - if (err == DOM_NO_ERR && s != NULL) { - ok = box_extract_link(content, s, content->base_url, &url); - dom_string_unref(s); - if (!ok) - return false; - if (url) { - if (box->href != NULL) - nsurl_unref(box->href); - box->href = url; - } - } - - /* name and id share the same namespace */ - err = dom_element_get_attribute(n, corestring_dom_name, &s); - if (err == DOM_NO_ERR && s != NULL) { - lwc_string *lwc_name; - - err = dom_string_intern(s, &lwc_name); - - dom_string_unref(s); - - if (err == DOM_NO_ERR) { - /* name replaces existing id - * TODO: really? */ - if (box->id != NULL) - lwc_string_unref(box->id); - - box->id = lwc_name; - } - } - - /* target frame [16.3] */ - err = dom_element_get_attribute(n, corestring_dom_target, &s); - if (err == DOM_NO_ERR && s != NULL) { - if (dom_string_caseless_lwc_isequal(s, - corestring_lwc__blank)) - box->target = TARGET_BLANK; - else if (dom_string_caseless_lwc_isequal(s, - corestring_lwc__top)) - box->target = TARGET_TOP; - else if (dom_string_caseless_lwc_isequal(s, - corestring_lwc__parent)) - box->target = TARGET_PARENT; - else if (dom_string_caseless_lwc_isequal(s, - corestring_lwc__self)) - /* the default may have been overridden by a - * <base target=...>, so this is different to 0 */ - box->target = TARGET_SELF; - else { - /* 6.16 says that frame names must begin with [a-zA-Z] - * This doesn't match reality, so just take anything */ - box->target = talloc_strdup(content->bctx, - dom_string_data(s)); - if (!box->target) { - dom_string_unref(s); - return false; - } - } - dom_string_unref(s); - } - - return true; -} - - -/** - * Document body special element handler [7.5.1]. - */ -static bool -box_body(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - css_color color; - - css_computed_background_color(box->style, &color); - if (nscss_color_is_transparent(color)) { - content->background_colour = NS_TRANSPARENT; - } else { - content->background_colour = nscss_color_to_ns(color); - } - - return true; -} - - -/** - * special element handler for forced line break [9.3.2]. - */ -static bool -box_br(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - box->type = BOX_BR; - return true; -} - - -/** - * special element handler for Push button [17.5]. - */ -static bool -box_button(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - struct form_control *gadget; - - gadget = html_forms_get_control_for_node(content->forms, n); - if (!gadget) - return false; - - gadget->html = content; - box->gadget = gadget; - box->flags |= IS_REPLACED; - gadget->box = box; - - box->type = BOX_INLINE_BLOCK; - - /* Just render the contents */ - - return true; -} - - -/** - * Canvas element - */ -static bool -box_canvas(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - /* If scripting is not enabled display the contents of canvas */ - if (!content->enable_scripting) { - return true; - } - *convert_children = false; - - return true; -} - - -/** - * Embedded object (not in any HTML specification: - * see http://wp.netscape.com/assist/net_sites/new_html3_prop.html ) - */ -static bool -box_embed(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - struct object_params *params; - struct object_param *param; - dom_namednodemap *attrs; - unsigned long idx; - uint32_t num_attrs; - dom_string *src; - dom_exception err; - - if (box->style && - ns_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) - return true; - - params = talloc(content->bctx, struct object_params); - if (params == NULL) - return false; - - talloc_set_destructor(params, box_object_talloc_destructor); - - params->data = NULL; - params->type = NULL; - params->codetype = NULL; - params->codebase = NULL; - params->classid = NULL; - params->params = NULL; - - /* src is a URL */ - err = dom_element_get_attribute(n, corestring_dom_src, &src); - if (err != DOM_NO_ERR || src == NULL) - return true; - if (box_extract_link(content, src, content->base_url, - &params->data) == false) { - dom_string_unref(src); - return false; - } - - dom_string_unref(src); - - if (params->data == NULL) - return true; - - /* Don't include ourself */ - if (nsurl_compare(content->base_url, params->data, NSURL_COMPLETE)) - return true; - - /* add attributes as parameters to linked list */ - err = dom_node_get_attributes(n, &attrs); - if (err != DOM_NO_ERR) - return false; - - err = dom_namednodemap_get_length(attrs, &num_attrs); - if (err != DOM_NO_ERR) { - dom_namednodemap_unref(attrs); - return false; - } - - for (idx = 0; idx < num_attrs; idx++) { - dom_attr *attr; - dom_string *name, *value; - - err = dom_namednodemap_item(attrs, idx, (void *) &attr); - if (err != DOM_NO_ERR) { - dom_namednodemap_unref(attrs); - return false; - } - - err = dom_attr_get_name(attr, &name); - if (err != DOM_NO_ERR) { - dom_node_unref(attr); - dom_namednodemap_unref(attrs); - return false; - } - - if (dom_string_caseless_lwc_isequal(name, corestring_lwc_src)) { - dom_node_unref(attr); - dom_string_unref(name); - continue; - } - - err = dom_attr_get_value(attr, &value); - if (err != DOM_NO_ERR) { - dom_node_unref(attr); - dom_string_unref(name); - dom_namednodemap_unref(attrs); - return false; - } - - param = talloc(content->bctx, struct object_param); - if (param == NULL) { - dom_node_unref(attr); - dom_string_unref(value); - dom_string_unref(name); - dom_namednodemap_unref(attrs); - return false; - } - - param->name = talloc_strdup(content->bctx, dom_string_data(name)); - param->value = talloc_strdup(content->bctx, dom_string_data(value)); - param->type = NULL; - param->valuetype = talloc_strdup(content->bctx, "data"); - param->next = NULL; - - dom_string_unref(value); - dom_string_unref(name); - dom_node_unref(attr); - - if (param->name == NULL || param->value == NULL || - param->valuetype == NULL) { - dom_namednodemap_unref(attrs); - return false; - } - - param->next = params->params; - params->params = param; - } - - dom_namednodemap_unref(attrs); - - box->object_params = params; - - /* start fetch */ - box->flags |= IS_REPLACED; - return html_fetch_object(content, params->data, box, CONTENT_ANY, - content->base.available_width, 1000, false); -} - - -/** - * Window subdivision [16.2.1]. - */ -static bool -box_frameset(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - bool ok; - - if (content->frameset) { - NSLOG(netsurf, INFO, "Error: multiple framesets in document."); - /* Don't convert children */ - if (convert_children) - *convert_children = false; - /* And ignore this spurious frameset */ - box->type = BOX_NONE; - return true; - } - - content->frameset = talloc_zero(content->bctx, - struct content_html_frames); - if (!content->frameset) { - return false; - } - - ok = box_create_frameset(content->frameset, n, content); - if (ok) { - box->type = BOX_NONE; - } - - if (convert_children) { - *convert_children = false; - } - return ok; -} - - -/** - * Inline subwindow [16.5]. - */ -static bool -box_iframe(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - nsurl *url; - dom_string *s; - dom_exception err; - struct content_html_iframe *iframe; - int i; - - if (box->style && - ns_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) - return true; - - if (box->style && - css_computed_visibility(box->style) == CSS_VISIBILITY_HIDDEN) { - /* Don't create iframe discriptors for invisible iframes - * TODO: handle hidden iframes at browser_window generation - * time instead? */ - return true; - } - - /* get frame URL */ - err = dom_element_get_attribute(n, corestring_dom_src, &s); - if (err != DOM_NO_ERR || s == NULL) - return true; - if (box_extract_link(content, s, content->base_url, &url) == false) { - dom_string_unref(s); - return false; - } - dom_string_unref(s); - if (url == NULL) - return true; - - /* don't include ourself */ - if (nsurl_compare(content->base_url, url, NSURL_COMPLETE)) { - nsurl_unref(url); - return true; - } - - /* create a new iframe */ - iframe = talloc(content->bctx, struct content_html_iframe); - if (iframe == NULL) { - nsurl_unref(url); - return false; - } - - talloc_set_destructor(iframe, box_iframes_talloc_destructor); - - iframe->box = box; - iframe->margin_width = 0; - iframe->margin_height = 0; - iframe->name = NULL; - iframe->url = url; - iframe->scrolling = BW_SCROLLING_AUTO; - iframe->border = true; - - /* Add this iframe to the linked list of iframes */ - iframe->next = content->iframe; - content->iframe = iframe; - - /* fill in specified values */ - err = dom_element_get_attribute(n, corestring_dom_name, &s); - if (err == DOM_NO_ERR && s != NULL) { - iframe->name = talloc_strdup(content->bctx, dom_string_data(s)); - dom_string_unref(s); - } - - err = dom_element_get_attribute(n, corestring_dom_frameborder, &s); - if (err == DOM_NO_ERR && s != NULL) { - i = atoi(dom_string_data(s)); - iframe->border = (i != 0); - dom_string_unref(s); - } - - err = dom_element_get_attribute(n, corestring_dom_bordercolor, &s); - if (err == DOM_NO_ERR && s != NULL) { - css_color color; - - if (nscss_parse_colour(dom_string_data(s), &color)) - iframe->border_colour = nscss_color_to_ns(color); - - dom_string_unref(s); - } - - err = dom_element_get_attribute(n, corestring_dom_scrolling, &s); - if (err == DOM_NO_ERR && s != NULL) { - if (dom_string_caseless_lwc_isequal(s, - corestring_lwc_yes)) - iframe->scrolling = BW_SCROLLING_YES; - else if (dom_string_caseless_lwc_isequal(s, - corestring_lwc_no)) - iframe->scrolling = BW_SCROLLING_NO; - dom_string_unref(s); - } - - err = dom_element_get_attribute(n, corestring_dom_marginwidth, &s); - if (err == DOM_NO_ERR && s != NULL) { - iframe->margin_width = atoi(dom_string_data(s)); - dom_string_unref(s); - } - - err = dom_element_get_attribute(n, corestring_dom_marginheight, &s); - if (err == DOM_NO_ERR && s != NULL) { - iframe->margin_height = atoi(dom_string_data(s)); - dom_string_unref(s); - } - - /* box */ - assert(box->style); - box->flags |= IFRAME; - box->flags |= IS_REPLACED; - - /* Showing iframe, so don't show alternate content */ - if (convert_children) - *convert_children = false; - return true; -} - - -/** - * Embedded image [13.2]. - */ -static bool -box_image(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - bool ok; - dom_string *s; - dom_exception err; - nsurl *url; - enum css_width_e wtype; - enum css_height_e htype; - css_fixed value = 0; - css_unit wunit = CSS_UNIT_PX; - css_unit hunit = CSS_UNIT_PX; - - if (box->style && - ns_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) - return true; - - /* handle alt text */ - err = dom_element_get_attribute(n, corestring_dom_alt, &s); - if (err == DOM_NO_ERR && s != NULL) { - char *alt = squash_whitespace(dom_string_data(s)); - dom_string_unref(s); - if (alt == NULL) - return false; - box->text = talloc_strdup(content->bctx, alt); - free(alt); - if (box->text == NULL) - return false; - box->length = strlen(box->text); - } - - if (nsoption_bool(foreground_images) == false) { - return true; - } - - /* imagemap associated with this image */ - if (!box_get_attribute(n, "usemap", content->bctx, &box->usemap)) - return false; - if (box->usemap && box->usemap[0] == '#') - box->usemap++; - - /* get image URL */ - err = dom_element_get_attribute(n, corestring_dom_src, &s); - if (err != DOM_NO_ERR || s == NULL) - return true; - - if (box_extract_link(content, s, content->base_url, &url) == false) { - dom_string_unref(s); - return false; - } - - dom_string_unref(s); - - if (url == NULL) - return true; - - /* start fetch */ - box->flags |= IS_REPLACED; - ok = html_fetch_object(content, url, box, image_types, - content->base.available_width, 1000, false); - nsurl_unref(url); - - wtype = css_computed_width(box->style, &value, &wunit); - htype = css_computed_height(box->style, &value, &hunit); - - if (wtype == CSS_WIDTH_SET && - wunit != CSS_UNIT_PCT && - htype == CSS_HEIGHT_SET && - hunit != CSS_UNIT_PCT) { - /* We know the dimensions the image will be shown at - * before it's fetched. */ - box->flags |= REPLACE_DIM; - } - - return ok; -} - - -/** - * Form control [17.4]. - */ -static bool -box_input(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - struct form_control *gadget; - dom_string *type = NULL; - dom_exception err; - nsurl *url; - nserror error; - - gadget = html_forms_get_control_for_node(content->forms, n); - if (gadget == NULL) { - return false; - } - - box->gadget = gadget; - box->flags |= IS_REPLACED; - gadget->box = box; - gadget->html = content; - - /* get entry type */ - err = dom_element_get_attribute(n, corestring_dom_type, &type); - if ((err != DOM_NO_ERR) || (type == NULL)) { - /* no type so "text" is assumed */ - if (box_input_text(content, box, n) == false) { - return false; - } - *convert_children = false; - return true; - } - - if (dom_string_caseless_lwc_isequal(type, corestring_lwc_password)) { - if (box_input_text(content, box, n) == false) - goto no_memory; - - } else if (dom_string_caseless_lwc_isequal(type, corestring_lwc_file)) { - box->type = BOX_INLINE_BLOCK; - - } else if (dom_string_caseless_lwc_isequal(type, - corestring_lwc_hidden)) { - /* no box for hidden inputs */ - box->type = BOX_NONE; - - } else if ((dom_string_caseless_lwc_isequal(type, - corestring_lwc_checkbox) || - dom_string_caseless_lwc_isequal(type, - corestring_lwc_radio))) { - - } else if (dom_string_caseless_lwc_isequal(type, - corestring_lwc_submit) || - dom_string_caseless_lwc_isequal(type, - corestring_lwc_reset) || - dom_string_caseless_lwc_isequal(type, - corestring_lwc_button)) { - struct box *inline_container, *inline_box; - - if (box_button(n, content, box, 0) == false) - goto no_memory; - - inline_container = box_create(NULL, 0, false, 0, 0, 0, 0, - content->bctx); - if (inline_container == NULL) - goto no_memory; - - inline_container->type = BOX_INLINE_CONTAINER; - - inline_box = box_create(NULL, box->style, false, 0, 0, - box->title, 0, content->bctx); - if (inline_box == NULL) - goto no_memory; - - inline_box->type = BOX_TEXT; - - if (box->gadget->value != NULL) - inline_box->text = talloc_strdup(content->bctx, - box->gadget->value); - else if (box->gadget->type == GADGET_SUBMIT) - inline_box->text = talloc_strdup(content->bctx, - messages_get("Form_Submit")); - else if (box->gadget->type == GADGET_RESET) - inline_box->text = talloc_strdup(content->bctx, - messages_get("Form_Reset")); - else - inline_box->text = talloc_strdup(content->bctx, - "Button"); - - if (inline_box->text == NULL) - goto no_memory; - - inline_box->length = strlen(inline_box->text); - - box_add_child(inline_container, inline_box); - - box_add_child(box, inline_container); - - } else if (dom_string_caseless_lwc_isequal(type, - corestring_lwc_image)) { - gadget->type = GADGET_IMAGE; - - if (box->style && - ns_computed_display(box->style, - box_is_root(n)) != CSS_DISPLAY_NONE && - nsoption_bool(foreground_images) == true) { - dom_string *s; - - err = dom_element_get_attribute(n, corestring_dom_src, &s); - if (err == DOM_NO_ERR && s != NULL) { - error = nsurl_join(content->base_url, - dom_string_data(s), &url); - dom_string_unref(s); - if (error != NSERROR_OK) - goto no_memory; - - /* if url is equivalent to the parent's url, - * we've got infinite inclusion. stop it here - */ - if (nsurl_compare(url, content->base_url, - NSURL_COMPLETE) == false) { - if (!html_fetch_object(content, url, - box, image_types, - content->base. - available_width, - 1000, false)) { - nsurl_unref(url); - goto no_memory; - } - } - nsurl_unref(url); - } - } - } else { - /* unhandled type the default is "text" */ - if (box_input_text(content, box, n) == false) - goto no_memory; - } - - dom_string_unref(type); - - *convert_children = false; - - return true; - -no_memory: - dom_string_unref(type); - - return false; -} - - -/** - * Noscript element - */ -static bool -box_noscript(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - /* If scripting is enabled, do not display the contents of noscript */ - if (content->enable_scripting) { - *convert_children = false; - } - - return true; -} - - -/** - * Generic embedded object [13.3]. - */ -static bool -box_object(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - struct object_params *params; - struct object_param *param; - dom_string *codebase, *classid, *data; - dom_node *c; - dom_exception err; - - if (box->style && - ns_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) - return true; - - if (box_get_attribute(n, "usemap", content->bctx, &box->usemap) == - false) - return false; - if (box->usemap && box->usemap[0] == '#') - box->usemap++; - - params = talloc(content->bctx, struct object_params); - if (params == NULL) - return false; - - talloc_set_destructor(params, box_object_talloc_destructor); - - params->data = NULL; - params->type = NULL; - params->codetype = NULL; - params->codebase = NULL; - params->classid = NULL; - params->params = NULL; - - /* codebase, classid, and data are URLs - * (codebase is the base for the other two) */ - err = dom_element_get_attribute(n, corestring_dom_codebase, &codebase); - if (err == DOM_NO_ERR && codebase != NULL) { - if (box_extract_link(content, codebase, content->base_url, - &params->codebase) == false) { - dom_string_unref(codebase); - return false; - } - dom_string_unref(codebase); - } - if (params->codebase == NULL) - params->codebase = nsurl_ref(content->base_url); - - err = dom_element_get_attribute(n, corestring_dom_classid, &classid); - if (err == DOM_NO_ERR && classid != NULL) { - if (box_extract_link(content, classid, - params->codebase, &params->classid) == false) { - dom_string_unref(classid); - return false; - } - dom_string_unref(classid); - } - - err = dom_element_get_attribute(n, corestring_dom_data, &data); - if (err == DOM_NO_ERR && data != NULL) { - if (box_extract_link(content, data, - params->codebase, &params->data) == false) { - dom_string_unref(data); - return false; - } - dom_string_unref(data); - } - - if (params->classid == NULL && params->data == NULL) - /* nothing to embed; ignore */ - return true; - - /* Don't include ourself */ - if (params->classid != NULL && nsurl_compare(content->base_url, - params->classid, NSURL_COMPLETE)) - return true; - - if (params->data != NULL && nsurl_compare(content->base_url, - params->data, NSURL_COMPLETE)) - return true; - - /* codetype and type are MIME types */ - if (box_get_attribute(n, "codetype", params, - &params->codetype) == false) - return false; - if (box_get_attribute(n, "type", params, &params->type) == false) - return false; - - /* classid && !data => classid is used (consult codetype) - * (classid || !classid) && data => data is used (consult type) - * !classid && !data => invalid; ignored */ - - if (params->classid != NULL && params->data == NULL && - params->codetype != NULL) { - lwc_string *icodetype; - lwc_error lerror; - - lerror = lwc_intern_string(params->codetype, - strlen(params->codetype), &icodetype); - if (lerror != lwc_error_ok) - return false; - - if (content_factory_type_from_mime_type(icodetype) == - CONTENT_NONE) { - /* can't handle this MIME type */ - lwc_string_unref(icodetype); - return true; - } - - lwc_string_unref(icodetype); - } - - if (params->data != NULL && params->type != NULL) { - lwc_string *itype; - lwc_error lerror; - - lerror = lwc_intern_string(params->type, strlen(params->type), - &itype); - if (lerror != lwc_error_ok) - return false; - - if (content_factory_type_from_mime_type(itype) == - CONTENT_NONE) { - /* can't handle this MIME type */ - lwc_string_unref(itype); - return true; - } - - lwc_string_unref(itype); - } - - /* add parameters to linked list */ - err = dom_node_get_first_child(n, &c); - if (err != DOM_NO_ERR) - return false; - - while (c != NULL) { - dom_node *next; - dom_node_type type; +#include <dom/dom.h> - err = dom_node_get_node_type(c, &type); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } - - if (type == DOM_ELEMENT_NODE) { - dom_string *name; - - err = dom_node_get_node_name(c, &name); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } - - if (!dom_string_caseless_lwc_isequal(name, - corestring_lwc_param)) { - /* The first non-param child is the start of - * the alt html. Therefore, we should break - * out of this loop. */ - dom_string_unref(name); - dom_node_unref(c); - break; - } - dom_string_unref(name); - - param = talloc(params, struct object_param); - if (param == NULL) { - dom_node_unref(c); - return false; - } - param->name = NULL; - param->value = NULL; - param->type = NULL; - param->valuetype = NULL; - param->next = NULL; - - if (box_get_attribute(c, "name", param, - &param->name) == false) { - dom_node_unref(c); - return false; - } - - if (box_get_attribute(c, "value", param, - &param->value) == false) { - dom_node_unref(c); - return false; - } - - if (box_get_attribute(c, "type", param, - &param->type) == false) { - dom_node_unref(c); - return false; - } +#include "utils/errors.h" +#include "utils/nsoption.h" +#include "utils/corestrings.h" +#include "utils/talloc.h" +#include "utils/string.h" +#include "utils/ascii.h" +#include "netsurf/misc.h" +#include "css/select.h" +#include "desktop/gui_internal.h" - if (box_get_attribute(c, "valuetype", param, - &param->valuetype) == false) { - dom_node_unref(c); - return false; - } +#include "html/html_internal.h" +#include "html/box.h" +#include "html/box_manipulate.h" +#include "html/box_construct.h" +#include "html/box_special.h" +#include "html/box_normalise.h" +#include "html/form_internal.h" - if (param->valuetype == NULL) { - param->valuetype = talloc_strdup(param, "data"); - if (param->valuetype == NULL) { - dom_node_unref(c); - return false; - } - } +/** + * Context for box tree construction + */ +struct box_construct_ctx { + html_content *content; /**< Content we're constructing for */ - param->next = params->params; - params->params = param; - } + dom_node *n; /**< Current node to process */ - err = dom_node_get_next_sibling(c, &next); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } + struct box *root_box; /**< Root box in the tree */ - dom_node_unref(c); - c = next; - } + box_construct_complete_cb cb; /**< Callback to invoke on completion */ - box->object_params = params; + int *bctx; /**< talloc context */ +}; - /* start fetch (MIME type is ok or not specified) */ - box->flags |= IS_REPLACED; - if (!html_fetch_object(content, - params->data ? params->data : params->classid, - box, CONTENT_ANY, content->base.available_width, 1000, - false)) - return false; +/** + * Transient properties for construction of current node + */ +struct box_construct_props { + /** Style from which to inherit, or NULL if none */ + const css_computed_style *parent_style; + /** Current link target, or NULL if none */ + nsurl *href; + /** Current frame target, or NULL if none */ + const char *target; + /** Current title attribute, or NULL if none */ + const char *title; + /** Identity of the current block-level container */ + struct box *containing_block; + /** Current container for inlines, or NULL if none + * \note If non-NULL, will be the last child of containing_block */ + struct box *inline_container; + /** Whether the current node is the root of the DOM tree */ + bool node_is_root; +}; - *convert_children = false; - return true; -} +static const content_type image_types = CONTENT_IMAGE; +/* the strings are not important, since we just compare the pointers */ +const char *TARGET_SELF = "_self"; +const char *TARGET_PARENT = "_parent"; +const char *TARGET_TOP = "_top"; +const char *TARGET_BLANK = "_blank"; /** - * Preformatted text [9.3.4]. + * mapping from CSS display to box type this table must be in sync + * with libcss' css_display enum */ -static bool -box_pre(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - box->flags |= PRE_STRIP; - return true; -} +static const box_type box_map[] = { + 0, /* CSS_DISPLAY_INHERIT, */ + BOX_INLINE, /* CSS_DISPLAY_INLINE, */ + BOX_BLOCK, /* CSS_DISPLAY_BLOCK, */ + BOX_BLOCK, /* CSS_DISPLAY_LIST_ITEM, */ + BOX_INLINE, /* CSS_DISPLAY_RUN_IN, */ + BOX_INLINE_BLOCK, /* CSS_DISPLAY_INLINE_BLOCK, */ + BOX_TABLE, /* CSS_DISPLAY_TABLE, */ + BOX_TABLE, /* CSS_DISPLAY_INLINE_TABLE, */ + BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_ROW_GROUP, */ + BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_HEADER_GROUP, */ + BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_FOOTER_GROUP, */ + BOX_TABLE_ROW, /* CSS_DISPLAY_TABLE_ROW, */ + BOX_NONE, /* CSS_DISPLAY_TABLE_COLUMN_GROUP, */ + BOX_NONE, /* CSS_DISPLAY_TABLE_COLUMN, */ + BOX_TABLE_CELL, /* CSS_DISPLAY_TABLE_CELL, */ + BOX_INLINE, /* CSS_DISPLAY_TABLE_CAPTION, */ + BOX_NONE /* CSS_DISPLAY_NONE */ +}; /** - * Option selector [17.6]. + * determine if a box is the root node + * + * \param n node to check + * \return true if node is root else false. */ -static bool -box_select(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) +static inline bool box_is_root(dom_node *n) { - struct box *inline_container; - struct box *inline_box; - struct form_control *gadget; - dom_node *c, *c2; - dom_node *next, *next2; + dom_node *parent; + dom_node_type type; dom_exception err; - gadget = html_forms_get_control_for_node(content->forms, n); - if (gadget == NULL) + err = dom_node_get_parent_node(n, &parent); + if (err != DOM_NO_ERR) return false; - gadget->html = content; - err = dom_node_get_first_child(n, &c); - if (err != DOM_NO_ERR) { - form_free_control(gadget); - return false; - } + if (parent != NULL) { + err = dom_node_get_node_type(parent, &type); - while (c != NULL) { - dom_string *name; + dom_node_unref(parent); - err = dom_node_get_node_name(c, &name); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - form_free_control(gadget); + if (err != DOM_NO_ERR) return false; - } - - if (dom_string_caseless_lwc_isequal(name, - corestring_lwc_option)) { - dom_string_unref(name); - - if (box_select_add_option(gadget, c) == false) { - dom_node_unref(c); - form_free_control(gadget); - return false; - } - } else if (dom_string_caseless_lwc_isequal(name, - corestring_lwc_optgroup)) { - dom_string_unref(name); - - err = dom_node_get_first_child(c, &c2); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - form_free_control(gadget); - return false; - } - - while (c2 != NULL) { - dom_string *c2_name; - - err = dom_node_get_node_name(c2, &c2_name); - if (err != DOM_NO_ERR) { - dom_node_unref(c2); - dom_node_unref(c); - form_free_control(gadget); - return false; - } - - if (dom_string_caseless_lwc_isequal(c2_name, - corestring_lwc_option)) { - dom_string_unref(c2_name); - - if (box_select_add_option(gadget, - c2) == false) { - dom_node_unref(c2); - dom_node_unref(c); - form_free_control(gadget); - return false; - } - } else { - dom_string_unref(c2_name); - } - - err = dom_node_get_next_sibling(c2, &next2); - if (err != DOM_NO_ERR) { - dom_node_unref(c2); - dom_node_unref(c); - form_free_control(gadget); - return false; - } - - dom_node_unref(c2); - c2 = next2; - } - } else { - dom_string_unref(name); - } - err = dom_node_get_next_sibling(c, &next); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - form_free_control(gadget); + if (type != DOM_DOCUMENT_NODE) return false; - } - - dom_node_unref(c); - c = next; - } - - if (gadget->data.select.num_items == 0) { - /* no options: ignore entire select */ - form_free_control(gadget); - return true; - } - - box->type = BOX_INLINE_BLOCK; - box->gadget = gadget; - box->flags |= IS_REPLACED; - gadget->box = box; - - inline_container = box_create(NULL, 0, false, 0, 0, 0, 0, content->bctx); - if (inline_container == NULL) - goto no_memory; - inline_container->type = BOX_INLINE_CONTAINER; - inline_box = box_create(NULL, box->style, false, 0, 0, box->title, 0, - content->bctx); - if (inline_box == NULL) - goto no_memory; - inline_box->type = BOX_TEXT; - box_add_child(inline_container, inline_box); - box_add_child(box, inline_container); - - if (gadget->data.select.multiple == false && - gadget->data.select.num_selected == 0) { - gadget->data.select.current = gadget->data.select.items; - gadget->data.select.current->initial_selected = - gadget->data.select.current->selected = true; - gadget->data.select.num_selected = 1; - dom_html_option_element_set_selected( - gadget->data.select.current->node, true); } - if (gadget->data.select.num_selected == 0) - inline_box->text = talloc_strdup(content->bctx, - messages_get("Form_None")); - else if (gadget->data.select.num_selected == 1) - inline_box->text = talloc_strdup(content->bctx, - gadget->data.select.current->text); - else - inline_box->text = talloc_strdup(content->bctx, - messages_get("Form_Many")); - if (inline_box->text == NULL) - goto no_memory; - - inline_box->length = strlen(inline_box->text); - - *convert_children = false; - return true; - -no_memory: - return false; -} - - -/** - * Multi-line text field [17.7]. - */ -static bool box_textarea(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - /* Get the form_control for the DOM node */ - box->gadget = html_forms_get_control_for_node(content->forms, n); - if (box->gadget == NULL) - return false; - - box->flags |= IS_REPLACED; - box->gadget->html = content; - box->gadget->box = box; - - if (!box_input_text(content, box, n)) - return false; - - *convert_children = false; return true; } /** - * \} - */ - - -/** * Extract transient construction properties * * \param n Current DOM node to convert @@ -2245,93 +487,6 @@ box_construct_marker(struct box *box, /** - * call an elements special handler - */ -static bool -convert_special_elements(dom_node *node, - html_content *content, - struct box *box, - bool *convert_children) -{ - dom_exception exc; - dom_html_element_type tag_type; - bool res; - - exc = dom_html_element_get_tag_type(node, &tag_type); - if (exc != DOM_NO_ERR) { - tag_type = DOM_HTML_ELEMENT_TYPE__UNKNOWN; - } - - switch (tag_type) { - case DOM_HTML_ELEMENT_TYPE_A: - res = box_a(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_BODY: - res = box_body(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_BR: - res = box_br(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_BUTTON: - res = box_button(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_CANVAS: - res = box_canvas(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_EMBED: - res = box_embed(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_FRAMESET: - res = box_frameset(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_IFRAME: - res = box_iframe(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_IMG: - res = box_image(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_INPUT: - res = box_input(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_NOSCRIPT: - res = box_noscript(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_OBJECT: - res = box_object(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_PRE: - res = box_pre(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_SELECT: - res = box_select(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_TEXTAREA: - res = box_textarea(node, content, box, convert_children); - break; - - default: - res = true; - } - - return res; -} - - -/** * Construct the box tree for an XML element. * * \param ctx Tree construction context diff --git a/content/handlers/html/box_construct.h b/content/handlers/html/box_construct.h index e93f515..f4bd119 100644 --- a/content/handlers/html/box_construct.h +++ b/content/handlers/html/box_construct.h @@ -19,6 +19,54 @@ /** * \file * HTML Box tree construction interface. + * + * This stage of rendering converts a tree of dom_nodes (produced by libdom) + * to a tree of struct box. The box tree represents the structure of the + * document as given by the CSS display and float properties. + * + * For example, consider the following HTML: + * \code + * <h1>Example Heading</h1> + * <p>Example paragraph <em>with emphasised text</em> etc.</p> \endcode + * + * This would produce approximately the following box tree with default CSS + * rules: + * \code + * BOX_BLOCK (corresponds to h1) + * BOX_INLINE_CONTAINER + * BOX_INLINE "Example Heading" + * BOX_BLOCK (p) + * BOX_INLINE_CONTAINER + * BOX_INLINE "Example paragraph " + * BOX_INLINE "with emphasised text" (em) + * BOX_INLINE "etc." \endcode + * + * Note that the em has been collapsed into the INLINE_CONTAINER. + * + * If these CSS rules were applied: + * \code + * h1 { display: table-cell } + * p { display: table-cell } + * em { float: left; width: 5em } \endcode + * + * then the box tree would instead look like this: + * \code + * BOX_TABLE + * BOX_TABLE_ROW_GROUP + * BOX_TABLE_ROW + * BOX_TABLE_CELL (h1) + * BOX_INLINE_CONTAINER + * BOX_INLINE "Example Heading" + * BOX_TABLE_CELL (p) + * BOX_INLINE_CONTAINER + * BOX_INLINE "Example paragraph " + * BOX_FLOAT_LEFT (em) + * BOX_BLOCK + * BOX_INLINE_CONTAINER + * BOX_INLINE "with emphasised text" + * BOX_INLINE "etc." \endcode + * + * Here implied boxes have been added and a float is present. */ #ifndef NETSURF_HTML_BOX_CONSTRUCT_H diff --git a/content/handlers/html/box_inspect.c b/content/handlers/html/box_inspect.c new file mode 100644 index 0000000..268ed3d --- /dev/null +++ b/content/handlers/html/box_inspect.c @@ -0,0 +1,885 @@ +/* + * Copyright 2008 Michael Drake <tlsa(a)netsurf-browser.org> + * Copyright 2020 Vincent Sanders <vince(a)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 + * implementation of box tree inspection. + */ + +#include <stdio.h> +#include <dom/dom.h> + +#include "utils/nsurl.h" +#include "utils/errors.h" +#include "netsurf/types.h" +#include "netsurf/content.h" +#include "netsurf/mouse.h" +#include "css/utils.h" +#include "css/dump.h" +#include "desktop/scrollbar.h" + +#include "html/box.h" +#include "html/box_inspect.h" +#include "html/html_internal.h" + +/** + * Direction to move in a box-tree walk + */ +enum box_walk_dir { + BOX_WALK_CHILDREN, + BOX_WALK_PARENT, + BOX_WALK_NEXT_SIBLING, + BOX_WALK_FLOAT_CHILDREN, + BOX_WALK_NEXT_FLOAT_SIBLING, + BOX_WALK_FLOAT_CONTAINER +}; + +#define box_is_float(box) (box->type == BOX_FLOAT_LEFT || \ + box->type == BOX_FLOAT_RIGHT) + +/** + * Determine if a point lies within a box. + * + * \param[in] len_ctx CSS length conversion context to use. + * \param[in] box Box to consider + * \param[in] x Coordinate relative to box + * \param[in] y Coordinate relative to box + * \param[out] physically If function returning true, physically is set true + * iff point is within the box's physical dimensions and + * false if the point is not within the box's physical + * dimensions but is in the area defined by the box's + * descendants. If function returns false, physically + * is undefined. + * \return true if the point is within the box or a descendant box + * + * This is a helper function for box_at_point(). + */ +static bool +box_contains_point(const nscss_len_ctx *len_ctx, + const struct box *box, + int x, + int y, + bool *physically) +{ + css_computed_clip_rect css_rect; + + if (box->style != NULL && + css_computed_position(box->style) == CSS_POSITION_ABSOLUTE && + css_computed_clip(box->style, &css_rect) == CSS_CLIP_RECT) { + /* We have an absolutly positioned box with a clip rect */ + struct rect r = { + .x0 = box->border[LEFT].width, + .y0 = box->border[TOP].width, + .x1 = box->padding[LEFT] + box->width + + box->border[RIGHT].width + + box->padding[RIGHT], + .y1 = box->padding[TOP] + box->height + + box->border[BOTTOM].width + + box->padding[BOTTOM] + }; + if (x >= r.x0 && x < r.x1 && y >= r.y0 && y < r.y1) { + *physically = true; + } else { + *physically = false; + } + + /* Adjust rect to css clip region */ + if (css_rect.left_auto == false) { + r.x0 += FIXTOINT(nscss_len2px(len_ctx, + css_rect.left, + css_rect.lunit, + box->style)); + } + if (css_rect.top_auto == false) { + r.y0 += FIXTOINT(nscss_len2px(len_ctx, + css_rect.top, + css_rect.tunit, + box->style)); + } + if (css_rect.right_auto == false) { + r.x1 = box->border[LEFT].width + + FIXTOINT(nscss_len2px(len_ctx, + css_rect.right, + css_rect.runit, + box->style)); + } + if (css_rect.bottom_auto == false) { + r.y1 = box->border[TOP].width + + FIXTOINT(nscss_len2px(len_ctx, + css_rect.bottom, + css_rect.bunit, + box->style)); + } + + /* Test if point is in clipped box */ + if (x >= r.x0 && x < r.x1 && y >= r.y0 && y < r.y1) { + /* inside clip area */ + return true; + } + + /* Not inside clip area */ + return false; + } + if (x >= -box->border[LEFT].width && + x < box->padding[LEFT] + box->width + + box->padding[RIGHT] + box->border[RIGHT].width && + y >= -box->border[TOP].width && + y < box->padding[TOP] + box->height + + box->padding[BOTTOM] + box->border[BOTTOM].width) { + *physically = true; + return true; + } + if (box->list_marker && box->list_marker->x - box->x <= x + + box->list_marker->border[LEFT].width && + x < box->list_marker->x - box->x + + box->list_marker->padding[LEFT] + + box->list_marker->width + + box->list_marker->border[RIGHT].width + + box->list_marker->padding[RIGHT] && + box->list_marker->y - box->y <= y + + box->list_marker->border[TOP].width && + y < box->list_marker->y - box->y + + box->list_marker->padding[TOP] + + box->list_marker->height + + box->list_marker->border[BOTTOM].width + + box->list_marker->padding[BOTTOM]) { + *physically = true; + return true; + } + if ((box->style && css_computed_overflow_x(box->style) == + CSS_OVERFLOW_VISIBLE) || !box->style) { + if (box->descendant_x0 <= x && + x < box->descendant_x1) { + *physically = false; + return true; + } + } + if ((box->style && css_computed_overflow_y(box->style) == + CSS_OVERFLOW_VISIBLE) || !box->style) { + if (box->descendant_y0 <= y && + y < box->descendant_y1) { + *physically = false; + return true; + } + } + return false; +} + + +/** + * Move from box to next box in given direction, adjusting for box coord change + * + * \param b box to move from from + * \param dir direction to move in + * \param x box's global x-coord, updated to position of next box + * \param y box's global y-coord, updated to position of next box + * + * If no box can be found in given direction, NULL is returned. + */ +static inline struct box * +box_move_xy(struct box *b, enum box_walk_dir dir, int *x, int *y) +{ + struct box *rb = NULL; + + switch (dir) { + case BOX_WALK_CHILDREN: + b = b->children; + if (b == NULL) + break; + *x += b->x; + *y += b->y; + if (!box_is_float(b)) { + rb = b; + break; + } + /* fall through */ + + case BOX_WALK_NEXT_SIBLING: + do { + *x -= b->x; + *y -= b->y; + b = b->next; + if (b == NULL) + break; + *x += b->x; + *y += b->y; + } while (box_is_float(b)); + rb = b; + break; + + case BOX_WALK_PARENT: + *x -= b->x; + *y -= b->y; + rb = b->parent; + break; + + case BOX_WALK_FLOAT_CHILDREN: + b = b->float_children; + if (b == NULL) + break; + *x += b->x; + *y += b->y; + rb = b; + break; + + case BOX_WALK_NEXT_FLOAT_SIBLING: + *x -= b->x; + *y -= b->y; + b = b->next_float; + if (b == NULL) + break; + *x += b->x; + *y += b->y; + rb = b; + break; + + case BOX_WALK_FLOAT_CONTAINER: + *x -= b->x; + *y -= b->y; + rb = b->float_container; + break; + + default: + assert(0 && "Bad box walk type."); + } + + return rb; +} + + +/** + * Itterator for walking to next box in interaction order + * + * \param b box to find next box from + * \param x box's global x-coord, updated to position of next box + * \param y box's global y-coord, updated to position of next box + * \param skip_children whether to skip box's children + * + * This walks to a boxes float children before its children. When walking + * children, floating boxes are skipped. + */ +static inline struct box * +box_next_xy(struct box *b, int *x, int *y, bool skip_children) +{ + struct box *n; + int tx, ty; + + assert(b != NULL); + + if (skip_children) { + /* Caller is not interested in any kind of children */ + goto skip_children; + } + + tx = *x; ty = *y; + n = box_move_xy(b, BOX_WALK_FLOAT_CHILDREN, &tx, &ty); + if (n) { + /* Next node is float child */ + *x = tx; + *y = ty; + return n; + } + done_float_children: + + tx = *x; ty = *y; + n = box_move_xy(b, BOX_WALK_CHILDREN, &tx, &ty); + if (n) { + /* Next node is child */ + *x = tx; + *y = ty; + return n; + } + + skip_children: + tx = *x; ty = *y; + n = box_move_xy(b, BOX_WALK_NEXT_FLOAT_SIBLING, &tx, &ty); + if (n) { + /* Go to next float sibling */ + *x = tx; + *y = ty; + return n; + } + + if (box_is_float(b)) { + /* Done floats, but the float container may have children, + * or siblings, or ansestors with siblings. Change to + * float container and move past handling its float children. + */ + b = box_move_xy(b, BOX_WALK_FLOAT_CONTAINER, x, y); + goto done_float_children; + } + + /* Go to next sibling, or nearest ancestor with next sibling. */ + while (b) { + while (!b->next && b->parent) { + b = box_move_xy(b, BOX_WALK_PARENT, x, y); + if (box_is_float(b)) { + /* Go on to next float, if there is one */ + goto skip_children; + } + } + if (!b->next) { + /* No more boxes */ + return NULL; + } + + tx = *x; ty = *y; + n = box_move_xy(b, BOX_WALK_NEXT_SIBLING, &tx, &ty); + if (n) { + /* Go to non-float (ancestor) sibling */ + *x = tx; + *y = ty; + return n; + + } else if (b->parent) { + b = box_move_xy(b, BOX_WALK_PARENT, x, y); + if (box_is_float(b)) { + /* Go on to next float, if there is one */ + goto skip_children; + } + + } else { + /* No more boxes */ + return NULL; + } + } + + assert(b != NULL); + return NULL; +} + + +/** + * Check whether box is nearer mouse coordinates than current nearest box + * + * \param box box to test + * \param bx position of box, in global document coordinates + * \param by position of box, in global document coordinates + * \param x mouse point, in global document coordinates + * \param y mouse point, in global document coordinates + * \param dir direction in which to search (-1 = above-left, + * +1 = below-right) + * \param nearest nearest text box found, or NULL if none + * updated if box is nearer than existing nearest + * \param tx position of text_box, in global document coordinates + * updated if box is nearer than existing nearest + * \param ty position of text_box, in global document coordinates + * updated if box is nearer than existing nearest + * \param nr_xd distance to nearest text box found + * updated if box is nearer than existing nearest + * \param nr_yd distance to nearest text box found + * updated if box is nearer than existing nearest + * \return true if mouse point is inside box + */ +static bool +box_nearer_text_box(struct box *box, + int bx, int by, + int x, int y, + int dir, + struct box **nearest, + int *tx, int *ty, + int *nr_xd, int *nr_yd) +{ + int w = box->padding[LEFT] + box->width + box->padding[RIGHT]; + int h = box->padding[TOP] + box->height + box->padding[BOTTOM]; + int y1 = by + h; + int x1 = bx + w; + int yd = INT_MAX; + int xd = INT_MAX; + + if (x >= bx && x1 > x && y >= by && y1 > y) { + *nearest = box; + *tx = bx; + *ty = by; + return true; + } + + if (box->parent->list_marker != box) { + if (dir < 0) { + /* consider only those children (partly) above-left */ + if (by <= y && bx < x) { + yd = y <= y1 ? 0 : y - y1; + xd = x <= x1 ? 0 : x - x1; + } + } else { + /* consider only those children (partly) below-right */ + if (y1 > y && x1 > x) { + yd = y > by ? 0 : by - y; + xd = x > bx ? 0 : bx - x; + } + } + + /* give y displacement precedence over x */ + if (yd < *nr_yd || (yd == *nr_yd && xd <= *nr_xd)) { + *nr_yd = yd; + *nr_xd = xd; + *nearest = box; + *tx = bx; + *ty = by; + } + } + return false; +} + + +/** + * Pick the text box child of 'box' that is closest to and above-left + * (dir -ve) or below-right (dir +ve) of the point 'x,y' + * + * \param box parent box + * \param bx position of box, in global document coordinates + * \param by position of box, in global document coordinates + * \param fx position of float parent, in global document coordinates + * \param fy position of float parent, in global document coordinates + * \param x mouse point, in global document coordinates + * \param y mouse point, in global document coordinates + * \param dir direction in which to search (-1 = above-left, + * +1 = below-right) + * \param nearest nearest text box found, or NULL if none + * updated if a descendant of box is nearer than old nearest + * \param tx position of nearest, in global document coordinates + * updated if a descendant of box is nearer than old nearest + * \param ty position of nearest, in global document coordinates + * updated if a descendant of box is nearer than old nearest + * \param nr_xd distance to nearest text box found + * updated if a descendant of box is nearer than old nearest + * \param nr_yd distance to nearest text box found + * updated if a descendant of box is nearer than old nearest + * \return true if mouse point is inside text_box + */ +static bool +box_nearest_text_box(struct box *box, + int bx, int by, + int fx, int fy, + int x, int y, + int dir, + struct box **nearest, + int *tx, int *ty, + int *nr_xd, int *nr_yd) +{ + struct box *child = box->children; + int c_bx, c_by; + int c_fx, c_fy; + bool in_box = false; + + if (*nearest == NULL) { + *nr_xd = INT_MAX / 2; /* displacement of 'nearest so far' */ + *nr_yd = INT_MAX / 2; + } + if (box->type == BOX_INLINE_CONTAINER) { + int bw = box->padding[LEFT] + box->width + box->padding[RIGHT]; + int bh = box->padding[TOP] + box->height + box->padding[BOTTOM]; + int b_y1 = by + bh; + int b_x1 = bx + bw; + if (x >= bx && b_x1 > x && y >= by && b_y1 > y) { + in_box = true; + } + } + + while (child) { + if (child->type == BOX_FLOAT_LEFT || + child->type == BOX_FLOAT_RIGHT) { + c_bx = fx + child->x - + scrollbar_get_offset(child->scroll_x); + c_by = fy + child->y - + scrollbar_get_offset(child->scroll_y); + } else { + c_bx = bx + child->x - + scrollbar_get_offset(child->scroll_x); + c_by = by + child->y - + scrollbar_get_offset(child->scroll_y); + } + if (child->float_children) { + c_fx = c_bx; + c_fy = c_by; + } else { + c_fx = fx; + c_fy = fy; + } + if (in_box && child->text && !child->object) { + if (box_nearer_text_box(child, + c_bx, c_by, x, y, dir, nearest, + tx, ty, nr_xd, nr_yd)) + return true; + } else { + if (child->list_marker) { + if (box_nearer_text_box( + child->list_marker, + c_bx + child->list_marker->x, + c_by + child->list_marker->y, + x, y, dir, nearest, + tx, ty, nr_xd, nr_yd)) + return true; + } + if (box_nearest_text_box(child, c_bx, c_by, + c_fx, c_fy, + x, y, dir, nearest, tx, ty, + nr_xd, nr_yd)) + return true; + } + child = child->next; + } + + return false; +} + + +/* Exported function documented in html/box.h */ +void box_coords(struct box *box, int *x, int *y) +{ + *x = box->x; + *y = box->y; + while (box->parent) { + if (box_is_float(box)) { + assert(box->float_container); + box = box->float_container; + } else { + box = box->parent; + } + *x += box->x - scrollbar_get_offset(box->scroll_x); + *y += box->y - scrollbar_get_offset(box->scroll_y); + } +} + + +/* Exported function documented in html/box.h */ +void box_bounds(struct box *box, struct rect *r) +{ + int width, height; + + box_coords(box, &r->x0, &r->y0); + + width = box->padding[LEFT] + box->width + box->padding[RIGHT]; + height = box->padding[TOP] + box->height + box->padding[BOTTOM]; + + r->x1 = r->x0 + width; + r->y1 = r->y0 + height; +} + + +/* Exported function documented in html/box.h */ +struct box * +box_at_point(const nscss_len_ctx *len_ctx, + struct box *box, + const int x, const int y, + int *box_x, int *box_y) +{ + bool skip_children; + bool physically; + + assert(box); + + skip_children = false; + while ((box = box_next_xy(box, box_x, box_y, skip_children))) { + if (box_contains_point(len_ctx, box, x - *box_x, y - *box_y, + &physically)) { + *box_x -= scrollbar_get_offset(box->scroll_x); + *box_y -= scrollbar_get_offset(box->scroll_y); + + if (physically) + return box; + + skip_children = false; + } else { + skip_children = true; + } + } + + return NULL; +} + + +/* Exported function documented in html/box.h */ +struct box *box_find_by_id(struct box *box, lwc_string *id) +{ + struct box *a, *b; + bool m; + + if (box->id != NULL && + lwc_string_isequal(id, box->id, &m) == lwc_error_ok && + m == true) { + return box; + } + + for (a = box->children; a; a = a->next) { + if ((b = box_find_by_id(a, id)) != NULL) { + return b; + } + } + + return NULL; +} + + +/* Exported function documented in html/box.h */ +bool box_visible(struct box *box) +{ + /* visibility: hidden */ + if (box->style && + css_computed_visibility(box->style) == CSS_VISIBILITY_HIDDEN) { + return false; + } + + return true; +} + + +/* Exported function documented in html/box.h */ +void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style) +{ + unsigned int i; + struct box *c, *prev; + + for (i = 0; i != depth; i++) { + fprintf(stream, " "); + } + + fprintf(stream, "%p ", box); + fprintf(stream, "x%i y%i w%i h%i ", + box->x, box->y, box->width, box->height); + if (box->max_width != UNKNOWN_MAX_WIDTH) { + fprintf(stream, "min%i max%i ", box->min_width, box->max_width); + } + fprintf(stream, "(%i %i %i %i) ", + box->descendant_x0, box->descendant_y0, + box->descendant_x1, box->descendant_y1); + + fprintf(stream, "m(%i %i %i %i) ", + box->margin[TOP], box->margin[LEFT], + box->margin[BOTTOM], box->margin[RIGHT]); + + switch (box->type) { + case BOX_BLOCK: + fprintf(stream, "BLOCK "); + break; + + case BOX_INLINE_CONTAINER: + fprintf(stream, "INLINE_CONTAINER "); + break; + + case BOX_INLINE: + fprintf(stream, "INLINE "); + break; + + case BOX_INLINE_END: + fprintf(stream, "INLINE_END "); + break; + + case BOX_INLINE_BLOCK: + fprintf(stream, "INLINE_BLOCK "); + break; + + case BOX_TABLE: + fprintf(stream, "TABLE [columns %i] ", box->columns); + break; + + case BOX_TABLE_ROW: + fprintf(stream, "TABLE_ROW "); + break; + + case BOX_TABLE_CELL: + fprintf(stream, "TABLE_CELL [columns %i, start %i, rows %i] ", + box->columns, + box->start_column, + box->rows); + break; + + case BOX_TABLE_ROW_GROUP: + fprintf(stream, "TABLE_ROW_GROUP "); + break; + + case BOX_FLOAT_LEFT: + fprintf(stream, "FLOAT_LEFT "); + break; + + case BOX_FLOAT_RIGHT: + fprintf(stream, "FLOAT_RIGHT "); + break; + + case BOX_BR: + fprintf(stream, "BR "); + break; + + case BOX_TEXT: + fprintf(stream, "TEXT "); + break; + + default: + fprintf(stream, "Unknown box type "); + } + + if (box->text) + fprintf(stream, "%li '%.*s' ", (unsigned long) box->byte_offset, + (int) box->length, box->text); + if (box->space) + fprintf(stream, "space "); + if (box->object) { + fprintf(stream, "(object '%s') ", + nsurl_access(hlcache_handle_get_url(box->object))); + } + if (box->iframe) { + fprintf(stream, "(iframe) "); + } + if (box->gadget) + fprintf(stream, "(gadget) "); + if (style && box->style) + nscss_dump_computed_style(stream, box->style); + if (box->href) + fprintf(stream, " -> '%s'", nsurl_access(box->href)); + if (box->target) + fprintf(stream, " |%s|", box->target); + if (box->title) + fprintf(stream, " [%s]", box->title); + if (box->id) + fprintf(stream, " ID:%s", lwc_string_data(box->id)); + if (box->type == BOX_INLINE || box->type == BOX_INLINE_END) + fprintf(stream, " inline_end %p", box->inline_end); + if (box->float_children) + fprintf(stream, " float_children %p", box->float_children); + if (box->next_float) + fprintf(stream, " next_float %p", box->next_float); + if (box->float_container) + fprintf(stream, " float_container %p", box->float_container); + if (box->col) { + fprintf(stream, " (columns"); + for (i = 0; i != box->columns; i++) { + fprintf(stream, " (%s %s %i %i %i)", + ((const char *[]) { + "UNKNOWN", + "FIXED", + "AUTO", + "PERCENT", + "RELATIVE" + }) + [box->col[i].type], + ((const char *[]) { + "normal", + "positioned"}) + [box->col[i].positioned], + box->col[i].width, + box->col[i].min, box->col[i].max); + } + fprintf(stream, ")"); + } + if (box->node != NULL) { + dom_string *name; + if (dom_node_get_node_name(box->node, &name) == DOM_NO_ERR) { + fprintf(stream, " <%s>", dom_string_data(name)); + dom_string_unref(name); + } + } + fprintf(stream, "\n"); + + if (box->list_marker) { + for (i = 0; i != depth; i++) + fprintf(stream, " "); + fprintf(stream, "list_marker:\n"); + box_dump(stream, box->list_marker, depth + 1, style); + } + + for (c = box->children; c && c->next; c = c->next) + ; + if (box->last != c) + fprintf(stream, "warning: box->last %p (should be %p) " + "(box %p)\n", box->last, c, box); + for (prev = 0, c = box->children; c; prev = c, c = c->next) { + if (c->parent != box) + fprintf(stream, "warning: box->parent %p (should be " + "%p) (box on next line)\n", + c->parent, box); + if (c->prev != prev) + fprintf(stream, "warning: box->prev %p (should be " + "%p) (box on next line)\n", + c->prev, prev); + box_dump(stream, c, depth + 1, style); + } +} + + +/* exported interface documented in html/box.h */ +bool box_vscrollbar_present(const struct box * const box) +{ + return box->padding[TOP] + + box->height + + box->padding[BOTTOM] + + box->border[BOTTOM].width < box->descendant_y1; +} + + +/* exported interface documented in html/box.h */ +bool box_hscrollbar_present(const struct box * const box) +{ + return box->padding[LEFT] + + box->width + + box->padding[RIGHT] + + box->border[RIGHT].width < box->descendant_x1; +} + + +/* Exported function documented in html/box.h */ +struct box * +box_pick_text_box(struct html_content *html, + int x, int y, + int dir, + int *dx, int *dy) +{ + struct box *text_box = NULL; + struct box *box; + int nr_xd, nr_yd; + int bx, by; + int fx, fy; + int tx, ty; + + if (html == NULL) + return NULL; + + box = html->layout; + bx = box->margin[LEFT]; + by = box->margin[TOP]; + fx = bx; + fy = by; + + if (!box_nearest_text_box(box, bx, by, fx, fy, x, y, + dir, &text_box, &tx, &ty, &nr_xd, &nr_yd)) { + if (text_box && text_box->text && !text_box->object) { + int w = (text_box->padding[LEFT] + + text_box->width + + text_box->padding[RIGHT]); + int h = (text_box->padding[TOP] + + text_box->height + + text_box->padding[BOTTOM]); + int x1, y1; + + y1 = ty + h; + x1 = tx + w; + + /* ensure point lies within the text box */ + if (x < tx) x = tx; + if (y < ty) y = ty; + if (y > y1) y = y1; + if (x > x1) x = x1; + } + } + + /* return coordinates relative to box */ + *dx = x - tx; + *dy = y - ty; + + return text_box; +} diff --git a/content/handlers/html/box_inspect.h b/content/handlers/html/box_inspect.h new file mode 100644 index 0000000..d50b848 --- /dev/null +++ b/content/handlers/html/box_inspect.h @@ -0,0 +1,143 @@ +/* + * Copyright 2020 Vincent Sanders <vince(a)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 + * HTML Box tree inspection interface. + */ + +#ifndef NETSURF_HTML_BOX_INSPECT_H +#define NETSURF_HTML_BOX_INSPECT_H + +/** + * Find the absolute coordinates of a box. + * + * \param box the box to calculate coordinates of + * \param x updated to x coordinate + * \param y updated to y coordinate + */ +void box_coords(struct box *box, int *x, int *y); + + +/** + * Find the bounds of a box. + * + * \param box the box to calculate bounds of + * \param r receives bounds + */ +void box_bounds(struct box *box, struct rect *r); + + +/** + * Find the boxes at a point. + * + * \param len_ctx CSS length conversion context for document. + * \param box box to search children of + * \param x point to find, in global document coordinates + * \param y point to find, in global document coordinates + * \param box_x position of box, in global document coordinates, updated + * to position of returned box, if any + * \param box_y position of box, in global document coordinates, updated + * to position of returned box, if any + * \return box at given point, or 0 if none found + * + * To find all the boxes in the hierarchy at a certain point, use code like + * this: + * \code + * struct box *box = top_of_document_to_search; + * int box_x = 0, box_y = 0; + * + * while ((box = box_at_point(len_ctx, box, x, y, &box_x, &box_y))) { + * // process box + * } + * \endcode + */ +struct box *box_at_point(const nscss_len_ctx *len_ctx, struct box *box, const int x, const int y, int *box_x, int *box_y); + + +/** + * Find a box based upon its id attribute. + * + * \param box box tree to search + * \param id id to look for + * \return the box or 0 if not found + */ +struct box *box_find_by_id(struct box *box, lwc_string *id); + + +/** + * Determine if a box is visible when the tree is rendered. + * + * \param box box to check + * \return true iff the box is rendered + */ +bool box_visible(struct box *box); + + +/** + * Print a box tree to a file. + */ +void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style); + + +/** + * Determine if a box has a vertical scrollbar. + * + * \param box scrolling box + * \return the box has a vertical scrollbar + */ +bool box_vscrollbar_present(const struct box *box); + + +/** + * Determine if a box has a horizontal scrollbar. + * + * \param box scrolling box + * \return the box has a horizontal scrollbar + */ +bool box_hscrollbar_present(const struct box *box); + + +/** + * Peform pick text on browser window contents to locate the box under + * the mouse pointer, or nearest in the given direction if the pointer is + * not over a text box. + * + * \param html an HTML content + * \param x coordinate of mouse + * \param y coordinate of mouse + * \param dir direction to search (-1 = above-left, +1 = below-right) + * \param dx receives x ordinate of mouse relative to text box + * \param dy receives y ordinate of mouse relative to text box + */ +struct box *box_pick_text_box(struct html_content *html, int x, int y, int dir, int *dx, int *dy); + + +/** + * Check if layout box is a first child. + * + * \param[in] b Box to check. + * \return true iff box is first child. + */ +static inline bool box_is_first_child(struct box *b) +{ + return (b->parent == NULL || b == b->parent->children); +} + + +#endif diff --git a/content/handlers/html/box_manipulate.c b/content/handlers/html/box_manipulate.c new file mode 100644 index 0000000..0bc1c9f --- /dev/null +++ b/content/handlers/html/box_manipulate.c @@ -0,0 +1,350 @@ +/* + * Copyright 2005-2007 James Bursa <bursa(a)users.sourceforge.net> + * Copyright 2003 Phil Mellor <monkeyson(a)users.sourceforge.net> + * Copyright 2005 John M Bell <jmb202(a)ecs.soton.ac.uk> + * Copyright 2008 Michael Drake <tlsa(a)netsurf-browser.org> + * Copyright 2020 Vincent Sanders <vince(a)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 + * implementation of box tree manipulation. + */ + + +#include "utils/errors.h" +#include "utils/talloc.h" +#include "netsurf/types.h" +#include "netsurf/mouse.h" +#include "desktop/scrollbar.h" + +#include "html/box.h" +#include "html/box_manipulate.h" +#include "html/form_internal.h" +#include "html/html_internal.h" +#include "html/interaction.h" + + +/** + * Destructor for box nodes which own styles + * + * \param b The box being destroyed. + * \return 0 to allow talloc to continue destroying the tree. + */ +static int box_talloc_destructor(struct box *b) +{ + struct html_scrollbar_data *data; + + if ((b->flags & STYLE_OWNED) && b->style != NULL) { + css_computed_style_destroy(b->style); + b->style = NULL; + } + + if (b->styles != NULL) { + css_select_results_destroy(b->styles); + b->styles = NULL; + } + + if (b->href != NULL) + nsurl_unref(b->href); + + if (b->id != NULL) { + lwc_string_unref(b->id); + } + + if (b->node != NULL) { + dom_node_unref(b->node); + } + + if (b->scroll_x != NULL) { + data = scrollbar_get_data(b->scroll_x); + scrollbar_destroy(b->scroll_x); + free(data); + } + + if (b->scroll_y != NULL) { + data = scrollbar_get_data(b->scroll_y); + scrollbar_destroy(b->scroll_y); + free(data); + } + + return 0; +} + + +/* Exported function documented in html/box.h */ +struct box * +box_create(css_select_results *styles, + css_computed_style *style, + bool style_owned, + nsurl *href, + const char *target, + const char *title, + lwc_string *id, + void *context) +{ + unsigned int i; + struct box *box; + + box = talloc(context, struct box); + if (!box) { + return 0; + } + + talloc_set_destructor(box, box_talloc_destructor); + + box->type = BOX_INLINE; + box->flags = 0; + box->flags = style_owned ? (box->flags | STYLE_OWNED) : box->flags; + box->styles = styles; + box->style = style; + box->x = box->y = 0; + box->width = UNKNOWN_WIDTH; + box->height = 0; + box->descendant_x0 = box->descendant_y0 = 0; + box->descendant_x1 = box->descendant_y1 = 0; + for (i = 0; i != 4; i++) + box->margin[i] = box->padding[i] = box->border[i].width = 0; + box->scroll_x = box->scroll_y = NULL; + box->min_width = 0; + box->max_width = UNKNOWN_MAX_WIDTH; + box->byte_offset = 0; + box->text = NULL; + box->length = 0; + box->space = 0; + box->href = (href == NULL) ? NULL : nsurl_ref(href); + box->target = target; + box->title = title; + box->columns = 1; + box->rows = 1; + box->start_column = 0; + box->next = NULL; + box->prev = NULL; + box->children = NULL; + box->last = NULL; + box->parent = NULL; + box->inline_end = NULL; + box->float_children = NULL; + box->float_container = NULL; + box->next_float = NULL; + box->cached_place_below_level = 0; + box->list_marker = NULL; + box->col = NULL; + box->gadget = NULL; + box->usemap = NULL; + box->id = id; + box->background = NULL; + box->object = NULL; + box->object_params = NULL; + box->iframe = NULL; + box->node = NULL; + + return box; +} + + +/* Exported function documented in html/box.h */ +void box_add_child(struct box *parent, struct box *child) +{ + assert(parent); + assert(child); + + if (parent->children != 0) { /* has children already */ + parent->last->next = child; + child->prev = parent->last; + } else { /* this is the first child */ + parent->children = child; + child->prev = 0; + } + + parent->last = child; + child->parent = parent; +} + + +/* Exported function documented in html/box.h */ +void box_insert_sibling(struct box *box, struct box *new_box) +{ + new_box->parent = box->parent; + new_box->prev = box; + new_box->next = box->next; + box->next = new_box; + if (new_box->next) + new_box->next->prev = new_box; + else if (new_box->parent) + new_box->parent->last = new_box; +} + + +/* Exported function documented in html/box.h */ +void box_unlink_and_free(struct box *box) +{ + struct box *parent = box->parent; + struct box *next = box->next; + struct box *prev = box->prev; + + if (parent) { + if (parent->children == box) + parent->children = next; + if (parent->last == box) + parent->last = next ? next : prev; + } + + if (prev) + prev->next = next; + if (next) + next->prev = prev; + + box_free(box); +} + + +/* Exported function documented in html/box.h */ +void box_free(struct box *box) +{ + struct box *child, *next; + + /* free children first */ + for (child = box->children; child; child = next) { + next = child->next; + box_free(child); + } + + /* last this box */ + box_free_box(box); +} + + +/* Exported function documented in html/box.h */ +void box_free_box(struct box *box) +{ + if (!(box->flags & CLONE)) { + if (box->gadget) + form_free_control(box->gadget); + if (box->scroll_x != NULL) + scrollbar_destroy(box->scroll_x); + if (box->scroll_y != NULL) + scrollbar_destroy(box->scroll_y); + if (box->styles != NULL) + css_select_results_destroy(box->styles); + } + + talloc_free(box); +} + + +/* exported interface documented in html/box.h */ +nserror +box_handle_scrollbars(struct content *c, + struct box *box, + bool bottom, + bool right) +{ + struct html_scrollbar_data *data; + int visible_width, visible_height; + int full_width, full_height; + nserror res; + + if (!bottom && box->scroll_x != NULL) { + data = scrollbar_get_data(box->scroll_x); + scrollbar_destroy(box->scroll_x); + free(data); + box->scroll_x = NULL; + } + + if (!right && box->scroll_y != NULL) { + data = scrollbar_get_data(box->scroll_y); + scrollbar_destroy(box->scroll_y); + free(data); + box->scroll_y = NULL; + } + + if (!bottom && !right) { + return NSERROR_OK; + } + + visible_width = box->width + box->padding[RIGHT] + box->padding[LEFT]; + visible_height = box->height + box->padding[TOP] + box->padding[BOTTOM]; + + full_width = ((box->descendant_x1 - box->border[RIGHT].width) > + visible_width) ? + box->descendant_x1 + box->padding[RIGHT] : + visible_width; + full_height = ((box->descendant_y1 - box->border[BOTTOM].width) > + visible_height) ? + box->descendant_y1 + box->padding[BOTTOM] : + visible_height; + + if (right) { + if (box->scroll_y == NULL) { + data = malloc(sizeof(struct html_scrollbar_data)); + if (data == NULL) { + return NSERROR_NOMEM; + } + data->c = c; + data->box = box; + res = scrollbar_create(false, + visible_height, + full_height, + visible_height, + data, + html_overflow_scroll_callback, + &(box->scroll_y)); + if (res != NSERROR_OK) { + return res; + } + } else { + scrollbar_set_extents(box->scroll_y, + visible_height, + visible_height, + full_height); + } + } + if (bottom) { + if (box->scroll_x == NULL) { + data = malloc(sizeof(struct html_scrollbar_data)); + if (data == NULL) { + return NSERROR_OK; + } + data->c = c; + data->box = box; + res = scrollbar_create(true, + visible_width - (right ? SCROLLBAR_WIDTH : 0), + full_width, + visible_width, + data, + html_overflow_scroll_callback, + &box->scroll_x); + if (res != NSERROR_OK) { + return res; + } + } else { + scrollbar_set_extents(box->scroll_x, + visible_width - + (right ? SCROLLBAR_WIDTH : 0), + visible_width, full_width); + } + } + + if (right && bottom) { + scrollbar_make_pair(box->scroll_x, box->scroll_y); + } + + return NSERROR_OK; +} + + diff --git a/content/handlers/html/box_manipulate.h b/content/handlers/html/box_manipulate.h new file mode 100644 index 0000000..43a66a7 --- /dev/null +++ b/content/handlers/html/box_manipulate.h @@ -0,0 +1,106 @@ +/* + * Copyright 2005 James Bursa <bursa(a)users.sourceforge.net> + * Copyright 2003 Phil Mellor <monkeyson(a)users.sourceforge.net> + * + * 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 + * Box tree manipulation interface. + */ + +#ifndef NETSURF_HTML_BOX_MANIPULATE_H +#define NETSURF_HTML_BOX_MANIPULATE_H + + +/** + * Create a box tree node. + * + * \param styles selection results for the box, or NULL + * \param style computed style for the box (not copied), or 0 + * \param style_owned whether style is owned by this box + * \param href href for the box (copied), or 0 + * \param target target for the box (not copied), or 0 + * \param title title for the box (not copied), or 0 + * \param id id for the box (not copied), or 0 + * \param context context for allocations + * \return allocated and initialised box, or 0 on memory exhaustion + * + * styles is always owned by the box, if it is set. + * style is only owned by the box in the case of implied boxes. + */ +struct box * box_create(css_select_results *styles, css_computed_style *style, bool style_owned, struct nsurl *href, const char *target, const char *title, lwc_string *id, void *context); + + +/** + * Add a child to a box tree node. + * + * \param parent box giving birth + * \param child box to link as last child of parent + */ +void box_add_child(struct box *parent, struct box *child); + + +/** + * Insert a new box as a sibling to a box in a tree. + * + * \param box box already in tree + * \param new_box box to link into tree as next sibling + */ +void box_insert_sibling(struct box *box, struct box *new_box); + + +/** + * Unlink a box from the box tree and then free it recursively. + * + * \param box box to unlink and free recursively. + */ +void box_unlink_and_free(struct box *box); + + +/** + * Free a box tree recursively. + * + * \param box box to free recursively + * + * The box and all its children is freed. + */ +void box_free(struct box *box); + + +/** + * Free the data in a single box structure. + * + * \param box box to free + */ +void box_free_box(struct box *box); + + +/** + * Applies the given scroll setup to a box. This includes scroll + * creation/deletion as well as scroll dimension updates. + * + * \param c content in which the box is located + * \param box the box to handle the scrolls for + * \param bottom whether the horizontal scrollbar should be present + * \param right whether the vertical scrollbar should be present + * \return true on success false otherwise + */ +nserror box_handle_scrollbars(struct content *c, struct box *box, + bool bottom, bool right); + + +#endif diff --git a/content/handlers/html/box_normalise.c b/content/handlers/html/box_normalise.c index 03fe731..fbdb6cd 100644 --- a/content/handlers/html/box_normalise.c +++ b/content/handlers/html/box_normalise.c @@ -33,6 +33,7 @@ #include "css/select.h" #include "html/box.h" +#include "html/box_manipulate.h" #include "html/box_normalise.h" #include "html/html_internal.h" #include "html/table.h" diff --git a/content/handlers/html/box_normalise.h b/content/handlers/html/box_normalise.h index 60f2591..591feab 100644 --- a/content/handlers/html/box_normalise.h +++ b/content/handlers/html/box_normalise.h @@ -19,6 +19,21 @@ /** * \file * HTML Box tree normalise interface. + * + * A box tree is "normalized" if the following is satisfied: + * \code + * parent permitted child nodes + * BLOCK, INLINE_BLOCK BLOCK, INLINE_CONTAINER, TABLE + * INLINE_CONTAINER INLINE, INLINE_BLOCK, FLOAT_LEFT, FLOAT_RIGHT, BR, TEXT, + * INLINE_END + * INLINE none + * TABLE at least 1 TABLE_ROW_GROUP + * TABLE_ROW_GROUP at least 1 TABLE_ROW + * TABLE_ROW at least 1 TABLE_CELL + * TABLE_CELL BLOCK, INLINE_CONTAINER, TABLE (same as BLOCK) + * FLOAT_(LEFT|RIGHT) exactly 1 BLOCK or TABLE + * \endcode + * */ #ifndef NETSURF_HTML_BOX_NORMALISE_H diff --git a/content/handlers/html/box_special.c b/content/handlers/html/box_special.c new file mode 100644 index 0000000..38031ce --- /dev/null +++ b/content/handlers/html/box_special.c @@ -0,0 +1,1916 @@ +/* + * Copyright 2005 James Bursa <bursa(a)users.sourceforge.net> + * Copyright 2003 Phil Mellor <monkeyson(a)users.sourceforge.net> + * Copyright 2005 John M Bell <jmb202(a)ecs.soton.ac.uk> + * Copyright 2006 Richard Wilson <info(a)tinct.net> + * Copyright 2008 Michael Drake <tlsa(a)netsurf-browser.org> + * Copyright 2020 Vincent Sanders <vince(a)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 + * Implementation of special element handling conversion. + */ + +#include <stdbool.h> +#include <dom/dom.h> + +#include "utils/nsoption.h" +#include "utils/corestrings.h" +#include "utils/log.h" +#include "utils/messages.h" +#include "utils/talloc.h" +#include "utils/string.h" +#include "utils/ascii.h" +#include "netsurf/plot_style.h" +#include "css/hints.h" +#include "desktop/frame_types.h" + +#include "html/html.h" +#include "html/html_internal.h" +#include "html/box.h" +#include "html/box_manipulate.h" +#include "html/box_construct.h" +#include "html/box_special.h" +#include "html/box_textarea.h" +#include "html/form_internal.h" + + +static const content_type image_types = CONTENT_IMAGE; + + +/** + * determine if a box is the root node + * + * \param n node to check + * \return true if node is root else false. + */ +static inline bool box_is_root(dom_node *n) +{ + dom_node *parent; + dom_node_type type; + dom_exception err; + + err = dom_node_get_parent_node(n, &parent); + if (err != DOM_NO_ERR) + return false; + + if (parent != NULL) { + err = dom_node_get_node_type(parent, &type); + + dom_node_unref(parent); + + if (err != DOM_NO_ERR) + return false; + + if (type != DOM_DOCUMENT_NODE) + return false; + } + + return true; +} + + +/** + * Destructor for object_params, for <object> elements + * + * \param o The object params being destroyed. + * \return 0 to allow talloc to continue destroying the tree. + */ +static int box_object_talloc_destructor(struct object_params *o) +{ + if (o->codebase != NULL) + nsurl_unref(o->codebase); + if (o->classid != NULL) + nsurl_unref(o->classid); + if (o->data != NULL) + nsurl_unref(o->data); + + return 0; +} + + +/** + * Parse a multi-length-list, as defined by HTML 4.01. + * + * \param ds dom string to parse + * \param count updated to number of entries + * \return array of struct box_multi_length, or 0 on memory exhaustion + */ +static struct frame_dimension * +box_parse_multi_lengths(const dom_string *ds, unsigned int *count) +{ + char *end; + unsigned int i, n; + struct frame_dimension *length; + const char *s; + + s = dom_string_data(ds); + + for (i = 0, n = 1; s[i]; i++) + if (s[i] == ',') + n++; + + length = calloc(n, sizeof(struct frame_dimension)); + if (!length) + return NULL; + + for (i = 0; i != n; i++) { + while (ascii_is_space(*s)) { + s++; + } + length[i].value = strtof(s, &end); + if (length[i].value <= 0) { + length[i].value = 1; + } + s = end; + switch (*s) { + case '%': + length[i].unit = FRAME_DIMENSION_PERCENT; + break; + case '*': + length[i].unit = FRAME_DIMENSION_RELATIVE; + break; + default: + length[i].unit = FRAME_DIMENSION_PIXELS; + break; + } + while (*s && *s != ',') { + s++; + } + if (*s == ',') { + s++; + } + } + + *count = n; + return length; +} + + +/** + * Destructor for content_html_frames, for frame elements + * + * \param f The frame params being destroyed. + * \return 0 to allow talloc to continue destroying the tree. + */ +static int box_frames_talloc_destructor(struct content_html_frames *f) +{ + if (f->url != NULL) { + nsurl_unref(f->url); + f->url = NULL; + } + + return 0; +} + + +/** + * create a frameset box tree + */ +static bool +box_create_frameset(struct content_html_frames *f, + dom_node *n, + html_content *content) +{ + unsigned int row, col, index, i; + unsigned int rows = 1, cols = 1; + dom_string *s; + dom_exception err; + nsurl *url; + struct frame_dimension *row_height = 0, *col_width = 0; + dom_node *c, *next; + struct content_html_frames *frame; + bool default_border = true; + colour default_border_colour = 0x000000; + + /* parse rows and columns */ + err = dom_element_get_attribute(n, corestring_dom_rows, &s); + if (err == DOM_NO_ERR && s != NULL) { + row_height = box_parse_multi_lengths(s, &rows); + dom_string_unref(s); + if (row_height == NULL) + return false; + } else { + row_height = calloc(1, sizeof(struct frame_dimension)); + if (row_height == NULL) + return false; + row_height->value = 100; + row_height->unit = FRAME_DIMENSION_PERCENT; + } + + err = dom_element_get_attribute(n, corestring_dom_cols, &s); + if (err == DOM_NO_ERR && s != NULL) { + col_width = box_parse_multi_lengths(s, &cols); + dom_string_unref(s); + if (col_width == NULL) { + free(row_height); + return false; + } + } else { + col_width = calloc(1, sizeof(struct frame_dimension)); + if (col_width == NULL) { + free(row_height); + return false; + } + col_width->value = 100; + col_width->unit = FRAME_DIMENSION_PERCENT; + } + + /* common extension: border="0|1" to control all children */ + err = dom_element_get_attribute(n, corestring_dom_border, &s); + if (err == DOM_NO_ERR && s != NULL) { + if ((dom_string_data(s)[0] == '0') && + (dom_string_data(s)[1] == '\0')) + default_border = false; + dom_string_unref(s); + } + + /* common extension: frameborder="yes|no" to control all children */ + err = dom_element_get_attribute(n, corestring_dom_frameborder, &s); + if (err == DOM_NO_ERR && s != NULL) { + if (dom_string_caseless_lwc_isequal(s, + corestring_lwc_no) == 0) + default_border = false; + dom_string_unref(s); + } + + /* common extension: bordercolor="#RRGGBB|<named colour>" to control + *all children */ + err = dom_element_get_attribute(n, corestring_dom_bordercolor, &s); + if (err == DOM_NO_ERR && s != NULL) { + css_color color; + + if (nscss_parse_colour(dom_string_data(s), &color)) + default_border_colour = nscss_color_to_ns(color); + + dom_string_unref(s); + } + + /* update frameset and create default children */ + f->cols = cols; + f->rows = rows; + f->scrolling = BW_SCROLLING_NO; + f->children = talloc_array(content->bctx, struct content_html_frames, + (rows * cols)); + + talloc_set_destructor(f->children, box_frames_talloc_destructor); + + for (row = 0; row < rows; row++) { + for (col = 0; col < cols; col++) { + index = (row * cols) + col; + frame = &f->children[index]; + frame->cols = 0; + frame->rows = 0; + frame->width = col_width[col]; + frame->height = row_height[row]; + frame->margin_width = 0; + frame->margin_height = 0; + frame->name = NULL; + frame->url = NULL; + frame->no_resize = false; + frame->scrolling = BW_SCROLLING_AUTO; + frame->border = default_border; + frame->border_colour = default_border_colour; + frame->children = NULL; + } + } + free(col_width); + free(row_height); + + /* create the frameset windows */ + err = dom_node_get_first_child(n, &c); + if (err != DOM_NO_ERR) + return false; + + for (row = 0; c != NULL && row < rows; row++) { + for (col = 0; c != NULL && col < cols; col++) { + while (c != NULL) { + dom_node_type type; + dom_string *name; + + err = dom_node_get_node_type(c, &type); + if (err != DOM_NO_ERR) { + dom_node_unref(c); + return false; + } + + err = dom_node_get_node_name(c, &name); + if (err != DOM_NO_ERR) { + dom_node_unref(c); + return false; + } + + if (type != DOM_ELEMENT_NODE || + (!dom_string_caseless_lwc_isequal( + name, + corestring_lwc_frame) && + !dom_string_caseless_lwc_isequal( + name, + corestring_lwc_frameset + ))) { + err = dom_node_get_next_sibling(c, + &next); + if (err != DOM_NO_ERR) { + dom_string_unref(name); + dom_node_unref(c); + return false; + } + + dom_string_unref(name); + dom_node_unref(c); + c = next; + } else { + /* Got a FRAME or FRAMESET element */ + dom_string_unref(name); + break; + } + } + + if (c == NULL) + break; + + /* get current frame */ + index = (row * cols) + col; + frame = &f->children[index]; + + /* nest framesets */ + err = dom_node_get_node_name(c, &s); + if (err != DOM_NO_ERR) { + dom_node_unref(c); + return false; + } + + if (dom_string_caseless_lwc_isequal(s, + corestring_lwc_frameset)) { + dom_string_unref(s); + frame->border = 0; + if (box_create_frameset(frame, c, + content) == false) { + dom_node_unref(c); + return false; + } + + err = dom_node_get_next_sibling(c, &next); + if (err != DOM_NO_ERR) { + dom_node_unref(c); + return false; + } + + dom_node_unref(c); + c = next; + continue; + } + + dom_string_unref(s); + + /* get frame URL (not required) */ + url = NULL; + err = dom_element_get_attribute(c, corestring_dom_src, &s); + if (err == DOM_NO_ERR && s != NULL) { + box_extract_link(content, s, content->base_url, + &url); + dom_string_unref(s); + } + + /* copy url */ + if (url != NULL) { + /* no self-references */ + if (nsurl_compare(content->base_url, url, + NSURL_COMPLETE) == false) + frame->url = url; + url = NULL; + } + + /* fill in specified values */ + err = dom_element_get_attribute(c, corestring_dom_name, &s); + if (err == DOM_NO_ERR && s != NULL) { + frame->name = talloc_strdup(content->bctx, + dom_string_data(s)); + dom_string_unref(s); + } + + if (dom_element_has_attribute(c, corestring_dom_noresize, + &frame->no_resize) != DOM_NO_ERR) { + /* If we can't read the attribute for some reason, + * assume we didn't have it. + */ + frame->no_resize = false; + } + + err = dom_element_get_attribute(c, corestring_dom_frameborder, + &s); + if (err == DOM_NO_ERR && s != NULL) { + i = atoi(dom_string_data(s)); + frame->border = (i != 0); + dom_string_unref(s); + } + + err = dom_element_get_attribute(c, corestring_dom_scrolling, &s); + if (err == DOM_NO_ERR && s != NULL) { + if (dom_string_caseless_lwc_isequal(s, + corestring_lwc_yes)) + frame->scrolling = BW_SCROLLING_YES; + else if (dom_string_caseless_lwc_isequal(s, + corestring_lwc_no)) + frame->scrolling = BW_SCROLLING_NO; + dom_string_unref(s); + } + + err = dom_element_get_attribute(c, corestring_dom_marginwidth, + &s); + if (err == DOM_NO_ERR && s != NULL) { + frame->margin_width = atoi(dom_string_data(s)); + dom_string_unref(s); + } + + err = dom_element_get_attribute(c, corestring_dom_marginheight, + &s); + if (err == DOM_NO_ERR && s != NULL) { + frame->margin_height = atoi(dom_string_data(s)); + dom_string_unref(s); + } + + err = dom_element_get_attribute(c, corestring_dom_bordercolor, + &s); + if (err == DOM_NO_ERR && s != NULL) { + css_color color; + + if (nscss_parse_colour(dom_string_data(s), + &color)) + frame->border_colour = + nscss_color_to_ns(color); + + dom_string_unref(s); + } + + /* advance */ + err = dom_node_get_next_sibling(c, &next); + if (err != DOM_NO_ERR) { + dom_node_unref(c); + return false; + } + + dom_node_unref(c); + c = next; + } + } + + /* If the last child wasn't a frame, we still need to unref it */ + if (c != NULL) { + dom_node_unref(c); + } + + return true; +} + + +/** + * Destructor for content_html_iframe, for <iframe> elements + * + * \param f The iframe params being destroyed. + * \return 0 to allow talloc to continue destroying the tree. + */ +static int box_iframes_talloc_destructor(struct content_html_iframe *f) +{ + if (f->url != NULL) { + nsurl_unref(f->url); + f->url = NULL; + } + + return 0; +} + + +/** + * Get the value of a dom node element's attribute. + * + * \param n dom element node + * \param attribute name of attribute + * \param context talloc context for result buffer + * \param value updated to value, if the attribute is present + * \return true on success, false if attribute present but memory exhausted + * + * \note returning true does not imply that the attribute was found. If the + * attribute was not found, *value will be unchanged. + */ +static bool +box_get_attribute(dom_node *n, + const char *attribute, + void *context, + char **value) +{ + char *result; + dom_string *attr, *attr_name; + dom_exception err; + + err = dom_string_create_interned((const uint8_t *) attribute, + strlen(attribute), &attr_name); + if (err != DOM_NO_ERR) + return false; + + err = dom_element_get_attribute(n, attr_name, &attr); + if (err != DOM_NO_ERR) { + dom_string_unref(attr_name); + return false; + } + + dom_string_unref(attr_name); + + if (attr != NULL) { + result = talloc_strdup(context, dom_string_data(attr)); + + dom_string_unref(attr); + + if (result == NULL) + return false; + + *value = result; + } + + return true; +} + + +/** + * Helper function for adding textarea widget to box. + * + * This is a load of hacks to ensure boxes replaced with textareas + * can be handled by the layout code. + */ +static bool +box_input_text(html_content *html, struct box *box, struct dom_node *node) +{ + struct box *inline_container, *inline_box; + + box->type = BOX_INLINE_BLOCK; + + inline_container = box_create(NULL, 0, false, 0, 0, 0, 0, html->bctx); + if (!inline_container) + return false; + inline_container->type = BOX_INLINE_CONTAINER; + inline_box = box_create(NULL, box->style, false, 0, 0, box->title, 0, + html->bctx); + if (!inline_box) + return false; + inline_box->type = BOX_TEXT; + inline_box->text = talloc_strdup(html->bctx, ""); + + box_add_child(inline_container, inline_box); + box_add_child(box, inline_container); + + return box_textarea_create_textarea(html, box, node); +} + + +/** + * Add an option to a form select control (helper function for box_select()). + * + * \param control select containing the <option> + * \param n xml element node for <option> + * \return true on success, false on memory exhaustion + */ +static bool box_select_add_option(struct form_control *control, dom_node *n) +{ + char *value = NULL; + char *text = NULL; + char *text_nowrap = NULL; + bool selected; + dom_string *content, *s; + dom_exception err; + + err = dom_node_get_text_content(n, &content); + if (err != DOM_NO_ERR) + return false; + + if (content != NULL) { + text = squash_whitespace(dom_string_data(content)); + dom_string_unref(content); + } else { + text = strdup(""); + } + + if (text == NULL) + goto no_memory; + + err = dom_element_get_attribute(n, corestring_dom_value, &s); + if (err == DOM_NO_ERR && s != NULL) { + value = strdup(dom_string_data(s)); + dom_string_unref(s); + } else { + value = strdup(text); + } + + if (value == NULL) + goto no_memory; + + if (dom_element_has_attribute(n, corestring_dom_selected, &selected) != DOM_NO_ERR) { + /* Assume not selected if we can't read the attribute presence */ + selected = false; + } + + /* replace spaces/TABs with hard spaces to prevent line wrapping */ + text_nowrap = cnv_space2nbsp(text); + if (text_nowrap == NULL) + goto no_memory; + + if (form_add_option(control, value, text_nowrap, selected, n) == false) + goto no_memory; + + free(text); + + return true; + +no_memory: + free(value); + free(text); + free(text_nowrap); + return false; +} + + +/** + * \name Special case element handlers + * + * These functions are called by box_construct_element() when an element is + * being converted, according to the entries in element_table. + * + * The parameters are the xmlNode, the content for the document, and a partly + * filled in box structure for the element. + * + * Return true on success, false on memory exhaustion. Set *convert_children + * to false if children of this element in the XML tree should be skipped (for + * example, if they have been processed in some special way already). + * + * Elements ordered as in the HTML 4.01 specification. Section numbers in + * brackets [] refer to the spec. + * + * \{ + */ + +/** + * special element handler for Anchor [12.2]. + */ +static bool +box_a(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + bool ok; + nsurl *url; + dom_string *s; + dom_exception err; + + err = dom_element_get_attribute(n, corestring_dom_href, &s); + if (err == DOM_NO_ERR && s != NULL) { + ok = box_extract_link(content, s, content->base_url, &url); + dom_string_unref(s); + if (!ok) + return false; + if (url) { + if (box->href != NULL) + nsurl_unref(box->href); + box->href = url; + } + } + + /* name and id share the same namespace */ + err = dom_element_get_attribute(n, corestring_dom_name, &s); + if (err == DOM_NO_ERR && s != NULL) { + lwc_string *lwc_name; + + err = dom_string_intern(s, &lwc_name); + + dom_string_unref(s); + + if (err == DOM_NO_ERR) { + /* name replaces existing id + * TODO: really? */ + if (box->id != NULL) + lwc_string_unref(box->id); + + box->id = lwc_name; + } + } + + /* target frame [16.3] */ + err = dom_element_get_attribute(n, corestring_dom_target, &s); + if (err == DOM_NO_ERR && s != NULL) { + if (dom_string_caseless_lwc_isequal(s, + corestring_lwc__blank)) + box->target = TARGET_BLANK; + else if (dom_string_caseless_lwc_isequal(s, + corestring_lwc__top)) + box->target = TARGET_TOP; + else if (dom_string_caseless_lwc_isequal(s, + corestring_lwc__parent)) + box->target = TARGET_PARENT; + else if (dom_string_caseless_lwc_isequal(s, + corestring_lwc__self)) + /* the default may have been overridden by a + * <base target=...>, so this is different to 0 */ + box->target = TARGET_SELF; + else { + /* 6.16 says that frame names must begin with [a-zA-Z] + * This doesn't match reality, so just take anything */ + box->target = talloc_strdup(content->bctx, + dom_string_data(s)); + if (!box->target) { + dom_string_unref(s); + return false; + } + } + dom_string_unref(s); + } + + return true; +} + + +/** + * Document body special element handler [7.5.1]. + */ +static bool +box_body(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + css_color color; + + css_computed_background_color(box->style, &color); + if (nscss_color_is_transparent(color)) { + content->background_colour = NS_TRANSPARENT; + } else { + content->background_colour = nscss_color_to_ns(color); + } + + return true; +} + + +/** + * special element handler for forced line break [9.3.2]. + */ +static bool +box_br(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + box->type = BOX_BR; + return true; +} + + +/** + * special element handler for Push button [17.5]. + */ +static bool +box_button(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + struct form_control *gadget; + + gadget = html_forms_get_control_for_node(content->forms, n); + if (!gadget) + return false; + + gadget->html = content; + box->gadget = gadget; + box->flags |= IS_REPLACED; + gadget->box = box; + + box->type = BOX_INLINE_BLOCK; + + /* Just render the contents */ + + return true; +} + + +/** + * Canvas element + */ +static bool +box_canvas(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + /* If scripting is not enabled display the contents of canvas */ + if (!content->enable_scripting) { + return true; + } + *convert_children = false; + + return true; +} + + +/** + * Embedded object (not in any HTML specification: + * see http://wp.netscape.com/assist/net_sites/new_html3_prop.html ) + */ +static bool +box_embed(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + struct object_params *params; + struct object_param *param; + dom_namednodemap *attrs; + unsigned long idx; + uint32_t num_attrs; + dom_string *src; + dom_exception err; + + if (box->style && + ns_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) + return true; + + params = talloc(content->bctx, struct object_params); + if (params == NULL) + return false; + + talloc_set_destructor(params, box_object_talloc_destructor); + + params->data = NULL; + params->type = NULL; + params->codetype = NULL; + params->codebase = NULL; + params->classid = NULL; + params->params = NULL; + + /* src is a URL */ + err = dom_element_get_attribute(n, corestring_dom_src, &src); + if (err != DOM_NO_ERR || src == NULL) + return true; + if (box_extract_link(content, src, content->base_url, + &params->data) == false) { + dom_string_unref(src); + return false; + } + + dom_string_unref(src); + + if (params->data == NULL) + return true; + + /* Don't include ourself */ + if (nsurl_compare(content->base_url, params->data, NSURL_COMPLETE)) + return true; + + /* add attributes as parameters to linked list */ + err = dom_node_get_attributes(n, &attrs); + if (err != DOM_NO_ERR) + return false; + + err = dom_namednodemap_get_length(attrs, &num_attrs); + if (err != DOM_NO_ERR) { + dom_namednodemap_unref(attrs); + return false; + } + + for (idx = 0; idx < num_attrs; idx++) { + dom_attr *attr; + dom_string *name, *value; + + err = dom_namednodemap_item(attrs, idx, (void *) &attr); + if (err != DOM_NO_ERR) { + dom_namednodemap_unref(attrs); + return false; + } + + err = dom_attr_get_name(attr, &name); + if (err != DOM_NO_ERR) { + dom_node_unref(attr); + dom_namednodemap_unref(attrs); + return false; + } + + if (dom_string_caseless_lwc_isequal(name, corestring_lwc_src)) { + dom_node_unref(attr); + dom_string_unref(name); + continue; + } + + err = dom_attr_get_value(attr, &value); + if (err != DOM_NO_ERR) { + dom_node_unref(attr); + dom_string_unref(name); + dom_namednodemap_unref(attrs); + return false; + } + + param = talloc(content->bctx, struct object_param); + if (param == NULL) { + dom_node_unref(attr); + dom_string_unref(value); + dom_string_unref(name); + dom_namednodemap_unref(attrs); + return false; + } + + param->name = talloc_strdup(content->bctx, dom_string_data(name)); + param->value = talloc_strdup(content->bctx, dom_string_data(value)); + param->type = NULL; + param->valuetype = talloc_strdup(content->bctx, "data"); + param->next = NULL; + + dom_string_unref(value); + dom_string_unref(name); + dom_node_unref(attr); + + if (param->name == NULL || param->value == NULL || + param->valuetype == NULL) { + dom_namednodemap_unref(attrs); + return false; + } + + param->next = params->params; + params->params = param; + } + + dom_namednodemap_unref(attrs); + + box->object_params = params; + + /* start fetch */ + box->flags |= IS_REPLACED; + return html_fetch_object(content, params->data, box, CONTENT_ANY, + content->base.available_width, 1000, false); +} + + +/** + * Window subdivision [16.2.1]. + */ +static bool +box_frameset(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + bool ok; + + if (content->frameset) { + NSLOG(netsurf, INFO, "Error: multiple framesets in document."); + /* Don't convert children */ + if (convert_children) + *convert_children = false; + /* And ignore this spurious frameset */ + box->type = BOX_NONE; + return true; + } + + content->frameset = talloc_zero(content->bctx, + struct content_html_frames); + if (!content->frameset) { + return false; + } + + ok = box_create_frameset(content->frameset, n, content); + if (ok) { + box->type = BOX_NONE; + } + + if (convert_children) { + *convert_children = false; + } + return ok; +} + + +/** + * Inline subwindow [16.5]. + */ +static bool +box_iframe(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + nsurl *url; + dom_string *s; + dom_exception err; + struct content_html_iframe *iframe; + int i; + + if (box->style && + ns_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) + return true; + + if (box->style && + css_computed_visibility(box->style) == CSS_VISIBILITY_HIDDEN) { + /* Don't create iframe discriptors for invisible iframes + * TODO: handle hidden iframes at browser_window generation + * time instead? */ + return true; + } + + /* get frame URL */ + err = dom_element_get_attribute(n, corestring_dom_src, &s); + if (err != DOM_NO_ERR || s == NULL) + return true; + if (box_extract_link(content, s, content->base_url, &url) == false) { + dom_string_unref(s); + return false; + } + dom_string_unref(s); + if (url == NULL) + return true; + + /* don't include ourself */ + if (nsurl_compare(content->base_url, url, NSURL_COMPLETE)) { + nsurl_unref(url); + return true; + } + + /* create a new iframe */ + iframe = talloc(content->bctx, struct content_html_iframe); + if (iframe == NULL) { + nsurl_unref(url); + return false; + } + + talloc_set_destructor(iframe, box_iframes_talloc_destructor); + + iframe->box = box; + iframe->margin_width = 0; + iframe->margin_height = 0; + iframe->name = NULL; + iframe->url = url; + iframe->scrolling = BW_SCROLLING_AUTO; + iframe->border = true; + + /* Add this iframe to the linked list of iframes */ + iframe->next = content->iframe; + content->iframe = iframe; + + /* fill in specified values */ + err = dom_element_get_attribute(n, corestring_dom_name, &s); + if (err == DOM_NO_ERR && s != NULL) { + iframe->name = talloc_strdup(content->bctx, dom_string_data(s)); + dom_string_unref(s); + } + + err = dom_element_get_attribute(n, corestring_dom_frameborder, &s); + if (err == DOM_NO_ERR && s != NULL) { + i = atoi(dom_string_data(s)); + iframe->border = (i != 0); + dom_string_unref(s); + } + + err = dom_element_get_attribute(n, corestring_dom_bordercolor, &s); + if (err == DOM_NO_ERR && s != NULL) { + css_color color; + + if (nscss_parse_colour(dom_string_data(s), &color)) + iframe->border_colour = nscss_color_to_ns(color); + + dom_string_unref(s); + } + + err = dom_element_get_attribute(n, corestring_dom_scrolling, &s); + if (err == DOM_NO_ERR && s != NULL) { + if (dom_string_caseless_lwc_isequal(s, + corestring_lwc_yes)) + iframe->scrolling = BW_SCROLLING_YES; + else if (dom_string_caseless_lwc_isequal(s, + corestring_lwc_no)) + iframe->scrolling = BW_SCROLLING_NO; + dom_string_unref(s); + } + + err = dom_element_get_attribute(n, corestring_dom_marginwidth, &s); + if (err == DOM_NO_ERR && s != NULL) { + iframe->margin_width = atoi(dom_string_data(s)); + dom_string_unref(s); + } + + err = dom_element_get_attribute(n, corestring_dom_marginheight, &s); + if (err == DOM_NO_ERR && s != NULL) { + iframe->margin_height = atoi(dom_string_data(s)); + dom_string_unref(s); + } + + /* box */ + assert(box->style); + box->flags |= IFRAME; + box->flags |= IS_REPLACED; + + /* Showing iframe, so don't show alternate content */ + if (convert_children) + *convert_children = false; + return true; +} + + +/** + * Embedded image [13.2]. + */ +static bool +box_image(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + bool ok; + dom_string *s; + dom_exception err; + nsurl *url; + enum css_width_e wtype; + enum css_height_e htype; + css_fixed value = 0; + css_unit wunit = CSS_UNIT_PX; + css_unit hunit = CSS_UNIT_PX; + + if (box->style && + ns_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) + return true; + + /* handle alt text */ + err = dom_element_get_attribute(n, corestring_dom_alt, &s); + if (err == DOM_NO_ERR && s != NULL) { + char *alt = squash_whitespace(dom_string_data(s)); + dom_string_unref(s); + if (alt == NULL) + return false; + box->text = talloc_strdup(content->bctx, alt); + free(alt); + if (box->text == NULL) + return false; + box->length = strlen(box->text); + } + + if (nsoption_bool(foreground_images) == false) { + return true; + } + + /* imagemap associated with this image */ + if (!box_get_attribute(n, "usemap", content->bctx, &box->usemap)) + return false; + if (box->usemap && box->usemap[0] == '#') + box->usemap++; + + /* get image URL */ + err = dom_element_get_attribute(n, corestring_dom_src, &s); + if (err != DOM_NO_ERR || s == NULL) + return true; + + if (box_extract_link(content, s, content->base_url, &url) == false) { + dom_string_unref(s); + return false; + } + + dom_string_unref(s); + + if (url == NULL) + return true; + + /* start fetch */ + box->flags |= IS_REPLACED; + ok = html_fetch_object(content, url, box, image_types, + content->base.available_width, 1000, false); + nsurl_unref(url); + + wtype = css_computed_width(box->style, &value, &wunit); + htype = css_computed_height(box->style, &value, &hunit); + + if (wtype == CSS_WIDTH_SET && + wunit != CSS_UNIT_PCT && + htype == CSS_HEIGHT_SET && + hunit != CSS_UNIT_PCT) { + /* We know the dimensions the image will be shown at + * before it's fetched. */ + box->flags |= REPLACE_DIM; + } + + return ok; +} + + +/** + * Form control [17.4]. + */ +static bool +box_input(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + struct form_control *gadget; + dom_string *type = NULL; + dom_exception err; + nsurl *url; + nserror error; + + gadget = html_forms_get_control_for_node(content->forms, n); + if (gadget == NULL) { + return false; + } + + box->gadget = gadget; + box->flags |= IS_REPLACED; + gadget->box = box; + gadget->html = content; + + /* get entry type */ + err = dom_element_get_attribute(n, corestring_dom_type, &type); + if ((err != DOM_NO_ERR) || (type == NULL)) { + /* no type so "text" is assumed */ + if (box_input_text(content, box, n) == false) { + return false; + } + *convert_children = false; + return true; + } + + if (dom_string_caseless_lwc_isequal(type, corestring_lwc_password)) { + if (box_input_text(content, box, n) == false) + goto no_memory; + + } else if (dom_string_caseless_lwc_isequal(type, corestring_lwc_file)) { + box->type = BOX_INLINE_BLOCK; + + } else if (dom_string_caseless_lwc_isequal(type, + corestring_lwc_hidden)) { + /* no box for hidden inputs */ + box->type = BOX_NONE; + + } else if ((dom_string_caseless_lwc_isequal(type, + corestring_lwc_checkbox) || + dom_string_caseless_lwc_isequal(type, + corestring_lwc_radio))) { + + } else if (dom_string_caseless_lwc_isequal(type, + corestring_lwc_submit) || + dom_string_caseless_lwc_isequal(type, + corestring_lwc_reset) || + dom_string_caseless_lwc_isequal(type, + corestring_lwc_button)) { + struct box *inline_container, *inline_box; + + if (box_button(n, content, box, 0) == false) + goto no_memory; + + inline_container = box_create(NULL, 0, false, 0, 0, 0, 0, + content->bctx); + if (inline_container == NULL) + goto no_memory; + + inline_container->type = BOX_INLINE_CONTAINER; + + inline_box = box_create(NULL, box->style, false, 0, 0, + box->title, 0, content->bctx); + if (inline_box == NULL) + goto no_memory; + + inline_box->type = BOX_TEXT; + + if (box->gadget->value != NULL) + inline_box->text = talloc_strdup(content->bctx, + box->gadget->value); + else if (box->gadget->type == GADGET_SUBMIT) + inline_box->text = talloc_strdup(content->bctx, + messages_get("Form_Submit")); + else if (box->gadget->type == GADGET_RESET) + inline_box->text = talloc_strdup(content->bctx, + messages_get("Form_Reset")); + else + inline_box->text = talloc_strdup(content->bctx, + "Button"); + + if (inline_box->text == NULL) + goto no_memory; + + inline_box->length = strlen(inline_box->text); + + box_add_child(inline_container, inline_box); + + box_add_child(box, inline_container); + + } else if (dom_string_caseless_lwc_isequal(type, + corestring_lwc_image)) { + gadget->type = GADGET_IMAGE; + + if (box->style && + ns_computed_display(box->style, + box_is_root(n)) != CSS_DISPLAY_NONE && + nsoption_bool(foreground_images) == true) { + dom_string *s; + + err = dom_element_get_attribute(n, corestring_dom_src, &s); + if (err == DOM_NO_ERR && s != NULL) { + error = nsurl_join(content->base_url, + dom_string_data(s), &url); + dom_string_unref(s); + if (error != NSERROR_OK) + goto no_memory; + + /* if url is equivalent to the parent's url, + * we've got infinite inclusion. stop it here + */ + if (nsurl_compare(url, content->base_url, + NSURL_COMPLETE) == false) { + if (!html_fetch_object(content, url, + box, image_types, + content->base. + available_width, + 1000, false)) { + nsurl_unref(url); + goto no_memory; + } + } + nsurl_unref(url); + } + } + } else { + /* unhandled type the default is "text" */ + if (box_input_text(content, box, n) == false) + goto no_memory; + } + + dom_string_unref(type); + + *convert_children = false; + + return true; + +no_memory: + dom_string_unref(type); + + return false; +} + + +/** + * Noscript element + */ +static bool +box_noscript(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + /* If scripting is enabled, do not display the contents of noscript */ + if (content->enable_scripting) { + *convert_children = false; + } + + return true; +} + + +/** + * Generic embedded object [13.3]. + */ +static bool +box_object(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + struct object_params *params; + struct object_param *param; + dom_string *codebase, *classid, *data; + dom_node *c; + dom_exception err; + + if (box->style && + ns_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) + return true; + + if (box_get_attribute(n, "usemap", content->bctx, &box->usemap) == + false) + return false; + if (box->usemap && box->usemap[0] == '#') + box->usemap++; + + params = talloc(content->bctx, struct object_params); + if (params == NULL) + return false; + + talloc_set_destructor(params, box_object_talloc_destructor); + + params->data = NULL; + params->type = NULL; + params->codetype = NULL; + params->codebase = NULL; + params->classid = NULL; + params->params = NULL; + + /* codebase, classid, and data are URLs + * (codebase is the base for the other two) */ + err = dom_element_get_attribute(n, corestring_dom_codebase, &codebase); + if (err == DOM_NO_ERR && codebase != NULL) { + if (box_extract_link(content, codebase, content->base_url, + &params->codebase) == false) { + dom_string_unref(codebase); + return false; + } + dom_string_unref(codebase); + } + if (params->codebase == NULL) + params->codebase = nsurl_ref(content->base_url); + + err = dom_element_get_attribute(n, corestring_dom_classid, &classid); + if (err == DOM_NO_ERR && classid != NULL) { + if (box_extract_link(content, classid, + params->codebase, &params->classid) == false) { + dom_string_unref(classid); + return false; + } + dom_string_unref(classid); + } + + err = dom_element_get_attribute(n, corestring_dom_data, &data); + if (err == DOM_NO_ERR && data != NULL) { + if (box_extract_link(content, data, + params->codebase, &params->data) == false) { + dom_string_unref(data); + return false; + } + dom_string_unref(data); + } + + if (params->classid == NULL && params->data == NULL) + /* nothing to embed; ignore */ + return true; + + /* Don't include ourself */ + if (params->classid != NULL && nsurl_compare(content->base_url, + params->classid, NSURL_COMPLETE)) + return true; + + if (params->data != NULL && nsurl_compare(content->base_url, + params->data, NSURL_COMPLETE)) + return true; + + /* codetype and type are MIME types */ + if (box_get_attribute(n, "codetype", params, + &params->codetype) == false) + return false; + if (box_get_attribute(n, "type", params, &params->type) == false) + return false; + + /* classid && !data => classid is used (consult codetype) + * (classid || !classid) && data => data is used (consult type) + * !classid && !data => invalid; ignored */ + + if (params->classid != NULL && params->data == NULL && + params->codetype != NULL) { + lwc_string *icodetype; + lwc_error lerror; + + lerror = lwc_intern_string(params->codetype, + strlen(params->codetype), &icodetype); + if (lerror != lwc_error_ok) + return false; + + if (content_factory_type_from_mime_type(icodetype) == + CONTENT_NONE) { + /* can't handle this MIME type */ + lwc_string_unref(icodetype); + return true; + } + + lwc_string_unref(icodetype); + } + + if (params->data != NULL && params->type != NULL) { + lwc_string *itype; + lwc_error lerror; + + lerror = lwc_intern_string(params->type, strlen(params->type), + &itype); + if (lerror != lwc_error_ok) + return false; + + if (content_factory_type_from_mime_type(itype) == + CONTENT_NONE) { + /* can't handle this MIME type */ + lwc_string_unref(itype); + return true; + } + + lwc_string_unref(itype); + } + + /* add parameters to linked list */ + err = dom_node_get_first_child(n, &c); + if (err != DOM_NO_ERR) + return false; + + while (c != NULL) { + dom_node *next; + dom_node_type type; + + err = dom_node_get_node_type(c, &type); + if (err != DOM_NO_ERR) { + dom_node_unref(c); + return false; + } + + if (type == DOM_ELEMENT_NODE) { + dom_string *name; + + err = dom_node_get_node_name(c, &name); + if (err != DOM_NO_ERR) { + dom_node_unref(c); + return false; + } + + if (!dom_string_caseless_lwc_isequal(name, + corestring_lwc_param)) { + /* The first non-param child is the start of + * the alt html. Therefore, we should break + * out of this loop. */ + dom_string_unref(name); + dom_node_unref(c); + break; + } + dom_string_unref(name); + + param = talloc(params, struct object_param); + if (param == NULL) { + dom_node_unref(c); + return false; + } + param->name = NULL; + param->value = NULL; + param->type = NULL; + param->valuetype = NULL; + param->next = NULL; + + if (box_get_attribute(c, "name", param, + &param->name) == false) { + dom_node_unref(c); + return false; + } + + if (box_get_attribute(c, "value", param, + &param->value) == false) { + dom_node_unref(c); + return false; + } + + if (box_get_attribute(c, "type", param, + &param->type) == false) { + dom_node_unref(c); + return false; + } + + if (box_get_attribute(c, "valuetype", param, + &param->valuetype) == false) { + dom_node_unref(c); + return false; + } + + if (param->valuetype == NULL) { + param->valuetype = talloc_strdup(param, "data"); + if (param->valuetype == NULL) { + dom_node_unref(c); + return false; + } + } + + param->next = params->params; + params->params = param; + } + + err = dom_node_get_next_sibling(c, &next); + if (err != DOM_NO_ERR) { + dom_node_unref(c); + return false; + } + + dom_node_unref(c); + c = next; + } + + box->object_params = params; + + /* start fetch (MIME type is ok or not specified) */ + box->flags |= IS_REPLACED; + if (!html_fetch_object(content, + params->data ? params->data : params->classid, + box, CONTENT_ANY, content->base.available_width, 1000, + false)) + return false; + + *convert_children = false; + return true; +} + + +/** + * Preformatted text [9.3.4]. + */ +static bool +box_pre(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + box->flags |= PRE_STRIP; + return true; +} + + +/** + * Option selector [17.6]. + */ +static bool +box_select(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + struct box *inline_container; + struct box *inline_box; + struct form_control *gadget; + dom_node *c, *c2; + dom_node *next, *next2; + dom_exception err; + + gadget = html_forms_get_control_for_node(content->forms, n); + if (gadget == NULL) + return false; + + gadget->html = content; + err = dom_node_get_first_child(n, &c); + if (err != DOM_NO_ERR) { + form_free_control(gadget); + return false; + } + + while (c != NULL) { + dom_string *name; + + err = dom_node_get_node_name(c, &name); + if (err != DOM_NO_ERR) { + dom_node_unref(c); + form_free_control(gadget); + return false; + } + + if (dom_string_caseless_lwc_isequal(name, + corestring_lwc_option)) { + dom_string_unref(name); + + if (box_select_add_option(gadget, c) == false) { + dom_node_unref(c); + form_free_control(gadget); + return false; + } + } else if (dom_string_caseless_lwc_isequal(name, + corestring_lwc_optgroup)) { + dom_string_unref(name); + + err = dom_node_get_first_child(c, &c2); + if (err != DOM_NO_ERR) { + dom_node_unref(c); + form_free_control(gadget); + return false; + } + + while (c2 != NULL) { + dom_string *c2_name; + + err = dom_node_get_node_name(c2, &c2_name); + if (err != DOM_NO_ERR) { + dom_node_unref(c2); + dom_node_unref(c); + form_free_control(gadget); + return false; + } + + if (dom_string_caseless_lwc_isequal(c2_name, + corestring_lwc_option)) { + dom_string_unref(c2_name); + + if (box_select_add_option(gadget, + c2) == false) { + dom_node_unref(c2); + dom_node_unref(c); + form_free_control(gadget); + return false; + } + } else { + dom_string_unref(c2_name); + } + + err = dom_node_get_next_sibling(c2, &next2); + if (err != DOM_NO_ERR) { + dom_node_unref(c2); + dom_node_unref(c); + form_free_control(gadget); + return false; + } + + dom_node_unref(c2); + c2 = next2; + } + } else { + dom_string_unref(name); + } + + err = dom_node_get_next_sibling(c, &next); + if (err != DOM_NO_ERR) { + dom_node_unref(c); + form_free_control(gadget); + return false; + } + + dom_node_unref(c); + c = next; + } + + if (gadget->data.select.num_items == 0) { + /* no options: ignore entire select */ + form_free_control(gadget); + return true; + } + + box->type = BOX_INLINE_BLOCK; + box->gadget = gadget; + box->flags |= IS_REPLACED; + gadget->box = box; + + inline_container = box_create(NULL, 0, false, 0, 0, 0, 0, content->bctx); + if (inline_container == NULL) + goto no_memory; + inline_container->type = BOX_INLINE_CONTAINER; + inline_box = box_create(NULL, box->style, false, 0, 0, box->title, 0, + content->bctx); + if (inline_box == NULL) + goto no_memory; + inline_box->type = BOX_TEXT; + box_add_child(inline_container, inline_box); + box_add_child(box, inline_container); + + if (gadget->data.select.multiple == false && + gadget->data.select.num_selected == 0) { + gadget->data.select.current = gadget->data.select.items; + gadget->data.select.current->initial_selected = + gadget->data.select.current->selected = true; + gadget->data.select.num_selected = 1; + dom_html_option_element_set_selected( + gadget->data.select.current->node, true); + } + + if (gadget->data.select.num_selected == 0) + inline_box->text = talloc_strdup(content->bctx, + messages_get("Form_None")); + else if (gadget->data.select.num_selected == 1) + inline_box->text = talloc_strdup(content->bctx, + gadget->data.select.current->text); + else + inline_box->text = talloc_strdup(content->bctx, + messages_get("Form_Many")); + if (inline_box->text == NULL) + goto no_memory; + + inline_box->length = strlen(inline_box->text); + + *convert_children = false; + return true; + +no_memory: + return false; +} + + +/** + * Multi-line text field [17.7]. + */ +static bool box_textarea(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + /* Get the form_control for the DOM node */ + box->gadget = html_forms_get_control_for_node(content->forms, n); + if (box->gadget == NULL) + return false; + + box->flags |= IS_REPLACED; + box->gadget->html = content; + box->gadget->box = box; + + if (!box_input_text(content, box, n)) + return false; + + *convert_children = false; + return true; +} + + +/** + * \} + */ + + +/* exported interface documented in html/box_special.h */ +bool +convert_special_elements(dom_node *node, + html_content *content, + struct box *box, + bool *convert_children) +{ + dom_exception exc; + dom_html_element_type tag_type; + bool res; + + exc = dom_html_element_get_tag_type(node, &tag_type); + if (exc != DOM_NO_ERR) { + tag_type = DOM_HTML_ELEMENT_TYPE__UNKNOWN; + } + + switch (tag_type) { + case DOM_HTML_ELEMENT_TYPE_A: + res = box_a(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_BODY: + res = box_body(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_BR: + res = box_br(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_BUTTON: + res = box_button(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_CANVAS: + res = box_canvas(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_EMBED: + res = box_embed(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_FRAMESET: + res = box_frameset(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_IFRAME: + res = box_iframe(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_IMG: + res = box_image(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_INPUT: + res = box_input(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_NOSCRIPT: + res = box_noscript(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_OBJECT: + res = box_object(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_PRE: + res = box_pre(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_SELECT: + res = box_select(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_TEXTAREA: + res = box_textarea(node, content, box, convert_children); + break; + + default: + res = true; + } + + return res; +} diff --git a/content/handlers/html/box_special.h b/content/handlers/html/box_special.h new file mode 100644 index 0000000..973ab97 --- /dev/null +++ b/content/handlers/html/box_special.h @@ -0,0 +1,35 @@ +/* + * Copyright 2020 Vincent Sanders <vince(a)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 + * HTML Box tree construction special element conversion interface. + */ + +#ifndef NETSURF_HTML_BOX_SPECIAL_H +#define NETSURF_HTML_BOX_SPECIAL_H + + +/** + * call an elements special conversion handler + * + * \return true if box construction should continue else false on error. + */ +bool convert_special_elements(dom_node *node, html_content *content, struct box *box, bool *convert_children); + +#endif diff --git a/content/handlers/html/box_textarea.c b/content/handlers/html/box_textarea.c index e253e16..476773f 100644 --- a/content/handlers/html/box_textarea.c +++ b/content/handlers/html/box_textarea.c @@ -33,6 +33,7 @@ #include "html/html_internal.h" #include "html/box.h" +#include "html/box_inspect.h" #include "html/box_textarea.h" #include "html/font.h" #include "html/form_internal.h" diff --git a/content/handlers/html/form.c b/content/handlers/html/form.c index fd0f2fa..86c4196 100644 --- a/content/handlers/html/form.c +++ b/content/handlers/html/form.c @@ -53,6 +53,7 @@ #include "desktop/gui_internal.h" #include "html/box.h" +#include "html/box_inspect.h" #include "html/font.h" #include "html/form_internal.h" #include "html/html.h" diff --git a/content/handlers/html/html.c b/content/handlers/html/html.c index 9b47858..01244cc 100644 --- a/content/handlers/html/html.c +++ b/content/handlers/html/html.c @@ -61,6 +61,7 @@ #include "html/interaction.h" #include "html/box.h" #include "html/box_construct.h" +#include "html/box_inspect.h" #include "html/form_internal.h" #include "html/imagemap.h" #include "html/layout.h" diff --git a/content/handlers/html/html_object.c b/content/handlers/html/html_object.c index 3a60c47..587c487 100644 --- a/content/handlers/html/html_object.c +++ b/content/handlers/html/html_object.c @@ -42,6 +42,7 @@ #include "html/html.h" #include "html/box.h" +#include "html/box_inspect.h" #include "html/html_internal.h" /* break reference loop */ diff --git a/content/handlers/html/html_redraw.c b/content/handlers/html/html_redraw.c index a60f44e..ee6fab2 100644 --- a/content/handlers/html/html_redraw.c +++ b/content/handlers/html/html_redraw.c @@ -54,6 +54,8 @@ #include "desktop/gui_internal.h" #include "html/box.h" +#include "html/box_inspect.h" +#include "html/box_manipulate.h" #include "html/font.h" #include "html/form_internal.h" #include "html/html_internal.h" diff --git a/content/handlers/html/interaction.c b/content/handlers/html/interaction.c index 7c4d54f..e4ef2f1 100644 --- a/content/handlers/html/interaction.c +++ b/content/handlers/html/interaction.c @@ -50,6 +50,7 @@ #include "html/box.h" #include "html/box_textarea.h" +#include "html/box_inspect.h" #include "html/font.h" #include "html/form_internal.h" #include "html/html_internal.h" diff --git a/content/handlers/html/layout.c b/content/handlers/html/layout.c index 611c778..128b12c 100644 --- a/content/handlers/html/layout.c +++ b/content/handlers/html/layout.c @@ -60,6 +60,7 @@ #include "html/html_save.h" #include "html/html_internal.h" #include "html/box.h" +#include "html/box_inspect.h" #include "html/font.h" #include "html/form_internal.h" #include "html/layout.h" diff --git a/content/handlers/html/search.c b/content/handlers/html/search.c index 981c80b..864fac6 100644 --- a/content/handlers/html/search.c +++ b/content/handlers/html/search.c @@ -40,6 +40,7 @@ #include "text/textplain.h" #include "html/box.h" +#include "html/box_inspect.h" #include "html/html.h" #include "html/html_internal.h" #include "html/search.h" diff --git a/desktop/frames.c b/desktop/frames.c index 1ed1145..a03f86c 100644 --- a/desktop/frames.c +++ b/desktop/frames.c @@ -35,6 +35,7 @@ #include "content/hlcache.h" #include "html/html.h" #include "html/box.h" +#include "html/box_inspect.h" #include "desktop/browser_private.h" #include "desktop/frames.h" diff --git a/desktop/scrollbar.h b/desktop/scrollbar.h index fa5e167..7965207 100644 --- a/desktop/scrollbar.h +++ b/desktop/scrollbar.h @@ -38,6 +38,7 @@ #define SCROLL_BOTTOM INT_MAX struct scrollbar; +struct redraw_context; /** * scrollbar message types diff --git a/desktop/selection.c b/desktop/selection.c index c8edda7..6c8f5d7 100644 --- a/desktop/selection.c +++ b/desktop/selection.c @@ -33,6 +33,7 @@ #include "utils/utils.h" #include "netsurf/form.h" #include "html/box.h" +#include "html/box_inspect.h" #include "html/html_internal.h" #include "html/font.h" #include "text/textplain.h" ----------------------------------------------------------------------- Summary of changes: content/handlers/html/Makefile | 26 +- content/handlers/html/box.h | 258 +-- content/handlers/html/box_construct.c | 2021 +------------------- content/handlers/html/box_construct.h | 48 + content/handlers/html/{box.c => box_inspect.c} | 868 +++------ content/handlers/html/box_inspect.h | 143 ++ content/handlers/html/box_manipulate.c | 350 ++++ content/handlers/html/box_manipulate.h | 106 + content/handlers/html/box_normalise.c | 1 + content/handlers/html/box_normalise.h | 15 + .../html/{box_construct.c => box_special.c} | 1406 +------------- .../handlers/html/box_special.h | 18 +- content/handlers/html/box_textarea.c | 1 + content/handlers/html/form.c | 1 + content/handlers/html/html.c | 1 + content/handlers/html/html_object.c | 1 + content/handlers/html/html_redraw.c | 2 + content/handlers/html/interaction.c | 1 + content/handlers/html/layout.c | 1 + content/handlers/html/search.c | 1 + desktop/frames.c | 1 + desktop/scrollbar.h | 1 + desktop/selection.c | 1 + 23 files changed, 1109 insertions(+), 4163 deletions(-) rename content/handlers/html/{box.c => box_inspect.c} (56%) create mode 100644 content/handlers/html/box_inspect.h create mode 100644 content/handlers/html/box_manipulate.c create mode 100644 content/handlers/html/box_manipulate.h copy content/handlers/html/{box_construct.c => box_special.c} (56%) copy desktop/gui_internal.h => content/handlers/html/box_special.h (62%) diff --git a/content/handlers/html/Makefile b/content/handlers/html/Makefile index 6b4c1e8..1976624 100644 --- a/content/handlers/html/Makefile +++ b/content/handlers/html/Makefile @@ -1,7 +1,23 @@ # HTML content handler sources -S_HTML := box.c box_construct.c box_normalise.c box_textarea.c \ - font.c form.c imagemap.c layout.c search.c table.c \ - html.c html_css.c html_css_fetcher.c html_script.c \ - interaction.c html_redraw.c html_redraw_border.c \ - html_forms.c html_object.c +S_HTML := box_construct.c \ + box_inspect.c \ + box_manipulate.c \ + box_normalise.c \ + box_special.c \ + box_textarea.c \ + font.c \ + form.c \ + imagemap.c \ + layout.c \ + search.c \ + table.c \ + html.c \ + html_css.c \ + html_css_fetcher.c \ + html_script.c \ + interaction.c \ + html_redraw.c \ + html_redraw_border.c \ + html_forms.c \ + html_object.c diff --git a/content/handlers/html/box.h b/content/handlers/html/box.h index 1781d13..b4da031 100644 --- a/content/handlers/html/box.h +++ b/content/handlers/html/box.h @@ -1,6 +1,7 @@ /* * Copyright 2005 James Bursa <bursa(a)users.sourceforge.net> * Copyright 2003 Phil Mellor <monkeyson(a)users.sourceforge.net> + * Copyright 2020 Vincent Sanders <vince(a)netsurf-browser.org> * * This file is part of NetSurf, http://www.netsurf-browser.org/ * @@ -19,69 +20,8 @@ /** * \file - * Box tree construction and manipulation interface. + * Box interface. * - * This stage of rendering converts a tree of dom_nodes (produced by libdom) - * to a tree of struct box. The box tree represents the structure of the - * document as given by the CSS display and float properties. - * - * For example, consider the following HTML: - * \code - * <h1>Example Heading</h1> - * <p>Example paragraph <em>with emphasised text</em> etc.</p> \endcode - * - * This would produce approximately the following box tree with default CSS - * rules: - * \code - * BOX_BLOCK (corresponds to h1) - * BOX_INLINE_CONTAINER - * BOX_INLINE "Example Heading" - * BOX_BLOCK (p) - * BOX_INLINE_CONTAINER - * BOX_INLINE "Example paragraph " - * BOX_INLINE "with emphasised text" (em) - * BOX_INLINE "etc." \endcode - * - * Note that the em has been collapsed into the INLINE_CONTAINER. - * - * If these CSS rules were applied: - * \code - * h1 { display: table-cell } - * p { display: table-cell } - * em { float: left; width: 5em } \endcode - * - * then the box tree would instead look like this: - * \code - * BOX_TABLE - * BOX_TABLE_ROW_GROUP - * BOX_TABLE_ROW - * BOX_TABLE_CELL (h1) - * BOX_INLINE_CONTAINER - * BOX_INLINE "Example Heading" - * BOX_TABLE_CELL (p) - * BOX_INLINE_CONTAINER - * BOX_INLINE "Example paragraph " - * BOX_FLOAT_LEFT (em) - * BOX_BLOCK - * BOX_INLINE_CONTAINER - * BOX_INLINE "with emphasised text" - * BOX_INLINE "etc." \endcode - * - * Here implied boxes have been added and a float is present. - * - * A box tree is "normalized" if the following is satisfied: - * \code - * parent permitted child nodes - * BLOCK, INLINE_BLOCK BLOCK, INLINE_CONTAINER, TABLE - * INLINE_CONTAINER INLINE, INLINE_BLOCK, FLOAT_LEFT, FLOAT_RIGHT, BR, TEXT, - * INLINE_END - * INLINE none - * TABLE at least 1 TABLE_ROW_GROUP - * TABLE_ROW_GROUP at least 1 TABLE_ROW - * TABLE_ROW at least 1 TABLE_CELL - * TABLE_CELL BLOCK, INLINE_CONTAINER, TABLE (same as BLOCK) - * FLOAT_(LEFT|RIGHT) exactly 1 BLOCK or TABLE - * \endcode */ #ifndef NETSURF_HTML_BOX_H @@ -89,7 +29,6 @@ #include <limits.h> #include <stdbool.h> -#include <stdio.h> #include <libcss/libcss.h> #include "content/handlers/css/utils.h" @@ -517,197 +456,4 @@ extern const char *TARGET_TOP; extern const char *TARGET_BLANK; -/** - * Create a box tree node. - * - * \param styles selection results for the box, or NULL - * \param style computed style for the box (not copied), or 0 - * \param style_owned whether style is owned by this box - * \param href href for the box (copied), or 0 - * \param target target for the box (not copied), or 0 - * \param title title for the box (not copied), or 0 - * \param id id for the box (not copied), or 0 - * \param context context for allocations - * \return allocated and initialised box, or 0 on memory exhaustion - * - * styles is always owned by the box, if it is set. - * style is only owned by the box in the case of implied boxes. - */ -struct box * box_create(css_select_results *styles, css_computed_style *style, bool style_owned, struct nsurl *href, const char *target, const char *title, lwc_string *id, void *context); - - -/** - * Add a child to a box tree node. - * - * \param parent box giving birth - * \param child box to link as last child of parent - */ -void box_add_child(struct box *parent, struct box *child); - - -/** - * Insert a new box as a sibling to a box in a tree. - * - * \param box box already in tree - * \param new_box box to link into tree as next sibling - */ -void box_insert_sibling(struct box *box, struct box *new_box); - - -/** - * Unlink a box from the box tree and then free it recursively. - * - * \param box box to unlink and free recursively. - */ -void box_unlink_and_free(struct box *box); - - -/** - * Free a box tree recursively. - * - * \param box box to free recursively - * - * The box and all its children is freed. - */ -void box_free(struct box *box); - - -/** - * Free the data in a single box structure. - * - * \param box box to free - */ -void box_free_box(struct box *box); - - -/** - * Find the absolute coordinates of a box. - * - * \param box the box to calculate coordinates of - * \param x updated to x coordinate - * \param y updated to y coordinate - */ -void box_coords(struct box *box, int *x, int *y); - - -/** - * Find the bounds of a box. - * - * \param box the box to calculate bounds of - * \param r receives bounds - */ -void box_bounds(struct box *box, struct rect *r); - - -/** - * Find the boxes at a point. - * - * \param len_ctx CSS length conversion context for document. - * \param box box to search children of - * \param x point to find, in global document coordinates - * \param y point to find, in global document coordinates - * \param box_x position of box, in global document coordinates, updated - * to position of returned box, if any - * \param box_y position of box, in global document coordinates, updated - * to position of returned box, if any - * \return box at given point, or 0 if none found - * - * To find all the boxes in the hierarchy at a certain point, use code like - * this: - * \code - * struct box *box = top_of_document_to_search; - * int box_x = 0, box_y = 0; - * - * while ((box = box_at_point(len_ctx, box, x, y, &box_x, &box_y))) { - * // process box - * } - * \endcode - */ -struct box *box_at_point(const nscss_len_ctx *len_ctx, struct box *box, const int x, const int y, int *box_x, int *box_y); - - -/** - * Peform pick text on browser window contents to locate the box under - * the mouse pointer, or nearest in the given direction if the pointer is - * not over a text box. - * - * \param html an HTML content - * \param x coordinate of mouse - * \param y coordinate of mouse - * \param dir direction to search (-1 = above-left, +1 = below-right) - * \param dx receives x ordinate of mouse relative to text box - * \param dy receives y ordinate of mouse relative to text box - */ -struct box *box_pick_text_box(struct html_content *html, int x, int y, int dir, int *dx, int *dy); - - -/** - * Find a box based upon its id attribute. - * - * \param box box tree to search - * \param id id to look for - * \return the box or 0 if not found - */ -struct box *box_find_by_id(struct box *box, lwc_string *id); - - -/** - * Determine if a box is visible when the tree is rendered. - * - * \param box box to check - * \return true iff the box is rendered - */ -bool box_visible(struct box *box); - - -/** - * Print a box tree to a file. - */ -void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style); - - -/** - * Applies the given scroll setup to a box. This includes scroll - * creation/deletion as well as scroll dimension updates. - * - * \param c content in which the box is located - * \param box the box to handle the scrolls for - * \param bottom whether the horizontal scrollbar should be present - * \param right whether the vertical scrollbar should be present - * \return true on success false otherwise - */ -nserror box_handle_scrollbars(struct content *c, struct box *box, - bool bottom, bool right); - - -/** - * Determine if a box has a vertical scrollbar. - * - * \param box scrolling box - * \return the box has a vertical scrollbar - */ -bool box_vscrollbar_present(const struct box *box); - - -/** - * Determine if a box has a horizontal scrollbar. - * - * \param box scrolling box - * \return the box has a horizontal scrollbar - */ -bool box_hscrollbar_present(const struct box *box); - - -/** - * Check if layout box is a first child. - * - * \param[in] b Box to check. - * \return true iff box is first child. - */ -static inline bool box_is_first_child(struct box *b) -{ - return (b->parent == NULL || b == b->parent->children); -} - - #endif diff --git a/content/handlers/html/box_construct.c b/content/handlers/html/box_construct.c index a833302..1637c0f 100644 --- a/content/handlers/html/box_construct.c +++ b/content/handlers/html/box_construct.c @@ -25,1886 +25,128 @@ * Implementation of conversion from DOM tree to box tree. */ -#include <assert.h> -#include <stdio.h> -#include <stdbool.h> -#include <stdlib.h> -#include <string.h> -#include <strings.h> - -#include "utils/config.h" -#include "utils/nsoption.h" -#include "utils/corestrings.h" -#include "utils/log.h" -#include "utils/messages.h" -#include "utils/talloc.h" -#include "utils/string.h" -#include "utils/ascii.h" -#include "netsurf/css.h" -#include "netsurf/misc.h" -#include "netsurf/plot_style.h" -#include "content/content_protected.h" -#include "css/hints.h" -#include "css/select.h" -#include "css/utils.h" -#include "desktop/gui_internal.h" - -#include "html/html.h" -#include "html/box.h" -#include "html/box_construct.h" -#include "html/box_normalise.h" -#include "html/box_textarea.h" -#include "html/form_internal.h" -#include "html/html_internal.h" - -/** - * Context for box tree construction - */ -struct box_construct_ctx { - html_content *content; /**< Content we're constructing for */ - - dom_node *n; /**< Current node to process */ - - struct box *root_box; /**< Root box in the tree */ - - box_construct_complete_cb cb; /**< Callback to invoke on completion */ - - int *bctx; /**< talloc context */ -}; - -/** - * Transient properties for construction of current node - */ -struct box_construct_props { - /** Style from which to inherit, or NULL if none */ - const css_computed_style *parent_style; - /** Current link target, or NULL if none */ - nsurl *href; - /** Current frame target, or NULL if none */ - const char *target; - /** Current title attribute, or NULL if none */ - const char *title; - /** Identity of the current block-level container */ - struct box *containing_block; - /** Current container for inlines, or NULL if none - * \note If non-NULL, will be the last child of containing_block */ - struct box *inline_container; - /** Whether the current node is the root of the DOM tree */ - bool node_is_root; -}; - -static const content_type image_types = CONTENT_IMAGE; - -/* the strings are not important, since we just compare the pointers */ -const char *TARGET_SELF = "_self"; -const char *TARGET_PARENT = "_parent"; -const char *TARGET_TOP = "_top"; -const char *TARGET_BLANK = "_blank"; - -/** - * mapping from CSS display to box type this table must be in sync - * with libcss' css_display enum - */ -static const box_type box_map[] = { - 0, /* CSS_DISPLAY_INHERIT, */ - BOX_INLINE, /* CSS_DISPLAY_INLINE, */ - BOX_BLOCK, /* CSS_DISPLAY_BLOCK, */ - BOX_BLOCK, /* CSS_DISPLAY_LIST_ITEM, */ - BOX_INLINE, /* CSS_DISPLAY_RUN_IN, */ - BOX_INLINE_BLOCK, /* CSS_DISPLAY_INLINE_BLOCK, */ - BOX_TABLE, /* CSS_DISPLAY_TABLE, */ - BOX_TABLE, /* CSS_DISPLAY_INLINE_TABLE, */ - BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_ROW_GROUP, */ - BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_HEADER_GROUP, */ - BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_FOOTER_GROUP, */ - BOX_TABLE_ROW, /* CSS_DISPLAY_TABLE_ROW, */ - BOX_NONE, /* CSS_DISPLAY_TABLE_COLUMN_GROUP, */ - BOX_NONE, /* CSS_DISPLAY_TABLE_COLUMN, */ - BOX_TABLE_CELL, /* CSS_DISPLAY_TABLE_CELL, */ - BOX_INLINE, /* CSS_DISPLAY_TABLE_CAPTION, */ - BOX_NONE /* CSS_DISPLAY_NONE */ -}; - - -/** - * determine if a box is the root node - * - * \param n node to check - * \return true if node is root else false. - */ -static inline bool box_is_root(dom_node *n) -{ - dom_node *parent; - dom_node_type type; - dom_exception err; - - err = dom_node_get_parent_node(n, &parent); - if (err != DOM_NO_ERR) - return false; - - if (parent != NULL) { - err = dom_node_get_node_type(parent, &type); - - dom_node_unref(parent); - - if (err != DOM_NO_ERR) - return false; - - if (type != DOM_DOCUMENT_NODE) - return false; - } - - return true; -} - - -/** - * Destructor for object_params, for <object> elements - * - * \param o The object params being destroyed. - * \return 0 to allow talloc to continue destroying the tree. - */ -static int box_object_talloc_destructor(struct object_params *o) -{ - if (o->codebase != NULL) - nsurl_unref(o->codebase); - if (o->classid != NULL) - nsurl_unref(o->classid); - if (o->data != NULL) - nsurl_unref(o->data); - - return 0; -} - - -/** - * Parse a multi-length-list, as defined by HTML 4.01. - * - * \param ds dom string to parse - * \param count updated to number of entries - * \return array of struct box_multi_length, or 0 on memory exhaustion - */ -static struct frame_dimension * -box_parse_multi_lengths(const dom_string *ds, unsigned int *count) -{ - char *end; - unsigned int i, n; - struct frame_dimension *length; - const char *s; - - s = dom_string_data(ds); - - for (i = 0, n = 1; s[i]; i++) - if (s[i] == ',') - n++; - - length = calloc(n, sizeof(struct frame_dimension)); - if (!length) - return NULL; - - for (i = 0; i != n; i++) { - while (ascii_is_space(*s)) { - s++; - } - length[i].value = strtof(s, &end); - if (length[i].value <= 0) { - length[i].value = 1; - } - s = end; - switch (*s) { - case '%': - length[i].unit = FRAME_DIMENSION_PERCENT; - break; - case '*': - length[i].unit = FRAME_DIMENSION_RELATIVE; - break; - default: - length[i].unit = FRAME_DIMENSION_PIXELS; - break; - } - while (*s && *s != ',') { - s++; - } - if (*s == ',') { - s++; - } - } - - *count = n; - return length; -} - - -/** - * Destructor for content_html_frames, for frame elements - * - * \param f The frame params being destroyed. - * \return 0 to allow talloc to continue destroying the tree. - */ -static int box_frames_talloc_destructor(struct content_html_frames *f) -{ - if (f->url != NULL) { - nsurl_unref(f->url); - f->url = NULL; - } - - return 0; -} - - -/** - * create a frameset box tree - */ -static bool -box_create_frameset(struct content_html_frames *f, - dom_node *n, - html_content *content) -{ - unsigned int row, col, index, i; - unsigned int rows = 1, cols = 1; - dom_string *s; - dom_exception err; - nsurl *url; - struct frame_dimension *row_height = 0, *col_width = 0; - dom_node *c, *next; - struct content_html_frames *frame; - bool default_border = true; - colour default_border_colour = 0x000000; - - /* parse rows and columns */ - err = dom_element_get_attribute(n, corestring_dom_rows, &s); - if (err == DOM_NO_ERR && s != NULL) { - row_height = box_parse_multi_lengths(s, &rows); - dom_string_unref(s); - if (row_height == NULL) - return false; - } else { - row_height = calloc(1, sizeof(struct frame_dimension)); - if (row_height == NULL) - return false; - row_height->value = 100; - row_height->unit = FRAME_DIMENSION_PERCENT; - } - - err = dom_element_get_attribute(n, corestring_dom_cols, &s); - if (err == DOM_NO_ERR && s != NULL) { - col_width = box_parse_multi_lengths(s, &cols); - dom_string_unref(s); - if (col_width == NULL) { - free(row_height); - return false; - } - } else { - col_width = calloc(1, sizeof(struct frame_dimension)); - if (col_width == NULL) { - free(row_height); - return false; - } - col_width->value = 100; - col_width->unit = FRAME_DIMENSION_PERCENT; - } - - /* common extension: border="0|1" to control all children */ - err = dom_element_get_attribute(n, corestring_dom_border, &s); - if (err == DOM_NO_ERR && s != NULL) { - if ((dom_string_data(s)[0] == '0') && - (dom_string_data(s)[1] == '\0')) - default_border = false; - dom_string_unref(s); - } - - /* common extension: frameborder="yes|no" to control all children */ - err = dom_element_get_attribute(n, corestring_dom_frameborder, &s); - if (err == DOM_NO_ERR && s != NULL) { - if (dom_string_caseless_lwc_isequal(s, - corestring_lwc_no) == 0) - default_border = false; - dom_string_unref(s); - } - - /* common extension: bordercolor="#RRGGBB|<named colour>" to control - *all children */ - err = dom_element_get_attribute(n, corestring_dom_bordercolor, &s); - if (err == DOM_NO_ERR && s != NULL) { - css_color color; - - if (nscss_parse_colour(dom_string_data(s), &color)) - default_border_colour = nscss_color_to_ns(color); - - dom_string_unref(s); - } - - /* update frameset and create default children */ - f->cols = cols; - f->rows = rows; - f->scrolling = BW_SCROLLING_NO; - f->children = talloc_array(content->bctx, struct content_html_frames, - (rows * cols)); - - talloc_set_destructor(f->children, box_frames_talloc_destructor); - - for (row = 0; row < rows; row++) { - for (col = 0; col < cols; col++) { - index = (row * cols) + col; - frame = &f->children[index]; - frame->cols = 0; - frame->rows = 0; - frame->width = col_width[col]; - frame->height = row_height[row]; - frame->margin_width = 0; - frame->margin_height = 0; - frame->name = NULL; - frame->url = NULL; - frame->no_resize = false; - frame->scrolling = BW_SCROLLING_AUTO; - frame->border = default_border; - frame->border_colour = default_border_colour; - frame->children = NULL; - } - } - free(col_width); - free(row_height); - - /* create the frameset windows */ - err = dom_node_get_first_child(n, &c); - if (err != DOM_NO_ERR) - return false; - - for (row = 0; c != NULL && row < rows; row++) { - for (col = 0; c != NULL && col < cols; col++) { - while (c != NULL) { - dom_node_type type; - dom_string *name; - - err = dom_node_get_node_type(c, &type); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } - - err = dom_node_get_node_name(c, &name); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } - - if (type != DOM_ELEMENT_NODE || - (!dom_string_caseless_lwc_isequal( - name, - corestring_lwc_frame) && - !dom_string_caseless_lwc_isequal( - name, - corestring_lwc_frameset - ))) { - err = dom_node_get_next_sibling(c, - &next); - if (err != DOM_NO_ERR) { - dom_string_unref(name); - dom_node_unref(c); - return false; - } - - dom_string_unref(name); - dom_node_unref(c); - c = next; - } else { - /* Got a FRAME or FRAMESET element */ - dom_string_unref(name); - break; - } - } - - if (c == NULL) - break; - - /* get current frame */ - index = (row * cols) + col; - frame = &f->children[index]; - - /* nest framesets */ - err = dom_node_get_node_name(c, &s); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } - - if (dom_string_caseless_lwc_isequal(s, - corestring_lwc_frameset)) { - dom_string_unref(s); - frame->border = 0; - if (box_create_frameset(frame, c, - content) == false) { - dom_node_unref(c); - return false; - } - - err = dom_node_get_next_sibling(c, &next); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } - - dom_node_unref(c); - c = next; - continue; - } - - dom_string_unref(s); - - /* get frame URL (not required) */ - url = NULL; - err = dom_element_get_attribute(c, corestring_dom_src, &s); - if (err == DOM_NO_ERR && s != NULL) { - box_extract_link(content, s, content->base_url, - &url); - dom_string_unref(s); - } - - /* copy url */ - if (url != NULL) { - /* no self-references */ - if (nsurl_compare(content->base_url, url, - NSURL_COMPLETE) == false) - frame->url = url; - url = NULL; - } - - /* fill in specified values */ - err = dom_element_get_attribute(c, corestring_dom_name, &s); - if (err == DOM_NO_ERR && s != NULL) { - frame->name = talloc_strdup(content->bctx, - dom_string_data(s)); - dom_string_unref(s); - } - - if (dom_element_has_attribute(c, corestring_dom_noresize, - &frame->no_resize) != DOM_NO_ERR) { - /* If we can't read the attribute for some reason, - * assume we didn't have it. - */ - frame->no_resize = false; - } - - err = dom_element_get_attribute(c, corestring_dom_frameborder, - &s); - if (err == DOM_NO_ERR && s != NULL) { - i = atoi(dom_string_data(s)); - frame->border = (i != 0); - dom_string_unref(s); - } - - err = dom_element_get_attribute(c, corestring_dom_scrolling, &s); - if (err == DOM_NO_ERR && s != NULL) { - if (dom_string_caseless_lwc_isequal(s, - corestring_lwc_yes)) - frame->scrolling = BW_SCROLLING_YES; - else if (dom_string_caseless_lwc_isequal(s, - corestring_lwc_no)) - frame->scrolling = BW_SCROLLING_NO; - dom_string_unref(s); - } - - err = dom_element_get_attribute(c, corestring_dom_marginwidth, - &s); - if (err == DOM_NO_ERR && s != NULL) { - frame->margin_width = atoi(dom_string_data(s)); - dom_string_unref(s); - } - - err = dom_element_get_attribute(c, corestring_dom_marginheight, - &s); - if (err == DOM_NO_ERR && s != NULL) { - frame->margin_height = atoi(dom_string_data(s)); - dom_string_unref(s); - } - - err = dom_element_get_attribute(c, corestring_dom_bordercolor, - &s); - if (err == DOM_NO_ERR && s != NULL) { - css_color color; - - if (nscss_parse_colour(dom_string_data(s), - &color)) - frame->border_colour = - nscss_color_to_ns(color); - - dom_string_unref(s); - } - - /* advance */ - err = dom_node_get_next_sibling(c, &next); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } - - dom_node_unref(c); - c = next; - } - } - - /* If the last child wasn't a frame, we still need to unref it */ - if (c != NULL) { - dom_node_unref(c); - } - - return true; -} - - -/** - * Destructor for content_html_iframe, for <iframe> elements - * - * \param f The iframe params being destroyed. - * \return 0 to allow talloc to continue destroying the tree. - */ -static int box_iframes_talloc_destructor(struct content_html_iframe *f) -{ - if (f->url != NULL) { - nsurl_unref(f->url); - f->url = NULL; - } - - return 0; -} - - -/** - * Get the value of a dom node element's attribute. - * - * \param n dom element node - * \param attribute name of attribute - * \param context talloc context for result buffer - * \param value updated to value, if the attribute is present - * \return true on success, false if attribute present but memory exhausted - * - * \note returning true does not imply that the attribute was found. If the - * attribute was not found, *value will be unchanged. - */ -static bool -box_get_attribute(dom_node *n, - const char *attribute, - void *context, - char **value) -{ - char *result; - dom_string *attr, *attr_name; - dom_exception err; - - err = dom_string_create_interned((const uint8_t *) attribute, - strlen(attribute), &attr_name); - if (err != DOM_NO_ERR) - return false; - - err = dom_element_get_attribute(n, attr_name, &attr); - if (err != DOM_NO_ERR) { - dom_string_unref(attr_name); - return false; - } - - dom_string_unref(attr_name); - - if (attr != NULL) { - result = talloc_strdup(context, dom_string_data(attr)); - - dom_string_unref(attr); - - if (result == NULL) - return false; - - *value = result; - } - - return true; -} - - -/** - * Helper function for adding textarea widget to box. - * - * This is a load of hacks to ensure boxes replaced with textareas - * can be handled by the layout code. - */ -static bool -box_input_text(html_content *html, struct box *box, struct dom_node *node) -{ - struct box *inline_container, *inline_box; - - box->type = BOX_INLINE_BLOCK; - - inline_container = box_create(NULL, 0, false, 0, 0, 0, 0, html->bctx); - if (!inline_container) - return false; - inline_container->type = BOX_INLINE_CONTAINER; - inline_box = box_create(NULL, box->style, false, 0, 0, box->title, 0, - html->bctx); - if (!inline_box) - return false; - inline_box->type = BOX_TEXT; - inline_box->text = talloc_strdup(html->bctx, ""); - - box_add_child(inline_container, inline_box); - box_add_child(box, inline_container); - - return box_textarea_create_textarea(html, box, node); -} - - -/** - * Add an option to a form select control (helper function for box_select()). - * - * \param control select containing the <option> - * \param n xml element node for <option> - * \return true on success, false on memory exhaustion - */ -static bool box_select_add_option(struct form_control *control, dom_node *n) -{ - char *value = NULL; - char *text = NULL; - char *text_nowrap = NULL; - bool selected; - dom_string *content, *s; - dom_exception err; - - err = dom_node_get_text_content(n, &content); - if (err != DOM_NO_ERR) - return false; - - if (content != NULL) { - text = squash_whitespace(dom_string_data(content)); - dom_string_unref(content); - } else { - text = strdup(""); - } - - if (text == NULL) - goto no_memory; - - err = dom_element_get_attribute(n, corestring_dom_value, &s); - if (err == DOM_NO_ERR && s != NULL) { - value = strdup(dom_string_data(s)); - dom_string_unref(s); - } else { - value = strdup(text); - } - - if (value == NULL) - goto no_memory; - - if (dom_element_has_attribute(n, corestring_dom_selected, &selected) != DOM_NO_ERR) { - /* Assume not selected if we can't read the attribute presence */ - selected = false; - } - - /* replace spaces/TABs with hard spaces to prevent line wrapping */ - text_nowrap = cnv_space2nbsp(text); - if (text_nowrap == NULL) - goto no_memory; - - if (form_add_option(control, value, text_nowrap, selected, n) == false) - goto no_memory; - - free(text); - - return true; - -no_memory: - free(value); - free(text); - free(text_nowrap); - return false; -} - - -/** - * \name Special case element handlers - * - * These functions are called by box_construct_element() when an element is - * being converted, according to the entries in element_table. - * - * The parameters are the xmlNode, the content for the document, and a partly - * filled in box structure for the element. - * - * Return true on success, false on memory exhaustion. Set *convert_children - * to false if children of this element in the XML tree should be skipped (for - * example, if they have been processed in some special way already). - * - * Elements ordered as in the HTML 4.01 specification. Section numbers in - * brackets [] refer to the spec. - * - * \{ - */ - -/** - * special element handler for Anchor [12.2]. - */ -static bool -box_a(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - bool ok; - nsurl *url; - dom_string *s; - dom_exception err; - - err = dom_element_get_attribute(n, corestring_dom_href, &s); - if (err == DOM_NO_ERR && s != NULL) { - ok = box_extract_link(content, s, content->base_url, &url); - dom_string_unref(s); - if (!ok) - return false; - if (url) { - if (box->href != NULL) - nsurl_unref(box->href); - box->href = url; - } - } - - /* name and id share the same namespace */ - err = dom_element_get_attribute(n, corestring_dom_name, &s); - if (err == DOM_NO_ERR && s != NULL) { - lwc_string *lwc_name; - - err = dom_string_intern(s, &lwc_name); - - dom_string_unref(s); - - if (err == DOM_NO_ERR) { - /* name replaces existing id - * TODO: really? */ - if (box->id != NULL) - lwc_string_unref(box->id); - - box->id = lwc_name; - } - } - - /* target frame [16.3] */ - err = dom_element_get_attribute(n, corestring_dom_target, &s); - if (err == DOM_NO_ERR && s != NULL) { - if (dom_string_caseless_lwc_isequal(s, - corestring_lwc__blank)) - box->target = TARGET_BLANK; - else if (dom_string_caseless_lwc_isequal(s, - corestring_lwc__top)) - box->target = TARGET_TOP; - else if (dom_string_caseless_lwc_isequal(s, - corestring_lwc__parent)) - box->target = TARGET_PARENT; - else if (dom_string_caseless_lwc_isequal(s, - corestring_lwc__self)) - /* the default may have been overridden by a - * <base target=...>, so this is different to 0 */ - box->target = TARGET_SELF; - else { - /* 6.16 says that frame names must begin with [a-zA-Z] - * This doesn't match reality, so just take anything */ - box->target = talloc_strdup(content->bctx, - dom_string_data(s)); - if (!box->target) { - dom_string_unref(s); - return false; - } - } - dom_string_unref(s); - } - - return true; -} - - -/** - * Document body special element handler [7.5.1]. - */ -static bool -box_body(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - css_color color; - - css_computed_background_color(box->style, &color); - if (nscss_color_is_transparent(color)) { - content->background_colour = NS_TRANSPARENT; - } else { - content->background_colour = nscss_color_to_ns(color); - } - - return true; -} - - -/** - * special element handler for forced line break [9.3.2]. - */ -static bool -box_br(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - box->type = BOX_BR; - return true; -} - - -/** - * special element handler for Push button [17.5]. - */ -static bool -box_button(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - struct form_control *gadget; - - gadget = html_forms_get_control_for_node(content->forms, n); - if (!gadget) - return false; - - gadget->html = content; - box->gadget = gadget; - box->flags |= IS_REPLACED; - gadget->box = box; - - box->type = BOX_INLINE_BLOCK; - - /* Just render the contents */ - - return true; -} - - -/** - * Canvas element - */ -static bool -box_canvas(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - /* If scripting is not enabled display the contents of canvas */ - if (!content->enable_scripting) { - return true; - } - *convert_children = false; - - return true; -} - - -/** - * Embedded object (not in any HTML specification: - * see http://wp.netscape.com/assist/net_sites/new_html3_prop.html ) - */ -static bool -box_embed(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - struct object_params *params; - struct object_param *param; - dom_namednodemap *attrs; - unsigned long idx; - uint32_t num_attrs; - dom_string *src; - dom_exception err; - - if (box->style && - ns_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) - return true; - - params = talloc(content->bctx, struct object_params); - if (params == NULL) - return false; - - talloc_set_destructor(params, box_object_talloc_destructor); - - params->data = NULL; - params->type = NULL; - params->codetype = NULL; - params->codebase = NULL; - params->classid = NULL; - params->params = NULL; - - /* src is a URL */ - err = dom_element_get_attribute(n, corestring_dom_src, &src); - if (err != DOM_NO_ERR || src == NULL) - return true; - if (box_extract_link(content, src, content->base_url, - &params->data) == false) { - dom_string_unref(src); - return false; - } - - dom_string_unref(src); - - if (params->data == NULL) - return true; - - /* Don't include ourself */ - if (nsurl_compare(content->base_url, params->data, NSURL_COMPLETE)) - return true; - - /* add attributes as parameters to linked list */ - err = dom_node_get_attributes(n, &attrs); - if (err != DOM_NO_ERR) - return false; - - err = dom_namednodemap_get_length(attrs, &num_attrs); - if (err != DOM_NO_ERR) { - dom_namednodemap_unref(attrs); - return false; - } - - for (idx = 0; idx < num_attrs; idx++) { - dom_attr *attr; - dom_string *name, *value; - - err = dom_namednodemap_item(attrs, idx, (void *) &attr); - if (err != DOM_NO_ERR) { - dom_namednodemap_unref(attrs); - return false; - } - - err = dom_attr_get_name(attr, &name); - if (err != DOM_NO_ERR) { - dom_node_unref(attr); - dom_namednodemap_unref(attrs); - return false; - } - - if (dom_string_caseless_lwc_isequal(name, corestring_lwc_src)) { - dom_node_unref(attr); - dom_string_unref(name); - continue; - } - - err = dom_attr_get_value(attr, &value); - if (err != DOM_NO_ERR) { - dom_node_unref(attr); - dom_string_unref(name); - dom_namednodemap_unref(attrs); - return false; - } - - param = talloc(content->bctx, struct object_param); - if (param == NULL) { - dom_node_unref(attr); - dom_string_unref(value); - dom_string_unref(name); - dom_namednodemap_unref(attrs); - return false; - } - - param->name = talloc_strdup(content->bctx, dom_string_data(name)); - param->value = talloc_strdup(content->bctx, dom_string_data(value)); - param->type = NULL; - param->valuetype = talloc_strdup(content->bctx, "data"); - param->next = NULL; - - dom_string_unref(value); - dom_string_unref(name); - dom_node_unref(attr); - - if (param->name == NULL || param->value == NULL || - param->valuetype == NULL) { - dom_namednodemap_unref(attrs); - return false; - } - - param->next = params->params; - params->params = param; - } - - dom_namednodemap_unref(attrs); - - box->object_params = params; - - /* start fetch */ - box->flags |= IS_REPLACED; - return html_fetch_object(content, params->data, box, CONTENT_ANY, - content->base.available_width, 1000, false); -} - - -/** - * Window subdivision [16.2.1]. - */ -static bool -box_frameset(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - bool ok; - - if (content->frameset) { - NSLOG(netsurf, INFO, "Error: multiple framesets in document."); - /* Don't convert children */ - if (convert_children) - *convert_children = false; - /* And ignore this spurious frameset */ - box->type = BOX_NONE; - return true; - } - - content->frameset = talloc_zero(content->bctx, - struct content_html_frames); - if (!content->frameset) { - return false; - } - - ok = box_create_frameset(content->frameset, n, content); - if (ok) { - box->type = BOX_NONE; - } - - if (convert_children) { - *convert_children = false; - } - return ok; -} - - -/** - * Inline subwindow [16.5]. - */ -static bool -box_iframe(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - nsurl *url; - dom_string *s; - dom_exception err; - struct content_html_iframe *iframe; - int i; - - if (box->style && - ns_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) - return true; - - if (box->style && - css_computed_visibility(box->style) == CSS_VISIBILITY_HIDDEN) { - /* Don't create iframe discriptors for invisible iframes - * TODO: handle hidden iframes at browser_window generation - * time instead? */ - return true; - } - - /* get frame URL */ - err = dom_element_get_attribute(n, corestring_dom_src, &s); - if (err != DOM_NO_ERR || s == NULL) - return true; - if (box_extract_link(content, s, content->base_url, &url) == false) { - dom_string_unref(s); - return false; - } - dom_string_unref(s); - if (url == NULL) - return true; - - /* don't include ourself */ - if (nsurl_compare(content->base_url, url, NSURL_COMPLETE)) { - nsurl_unref(url); - return true; - } - - /* create a new iframe */ - iframe = talloc(content->bctx, struct content_html_iframe); - if (iframe == NULL) { - nsurl_unref(url); - return false; - } - - talloc_set_destructor(iframe, box_iframes_talloc_destructor); - - iframe->box = box; - iframe->margin_width = 0; - iframe->margin_height = 0; - iframe->name = NULL; - iframe->url = url; - iframe->scrolling = BW_SCROLLING_AUTO; - iframe->border = true; - - /* Add this iframe to the linked list of iframes */ - iframe->next = content->iframe; - content->iframe = iframe; - - /* fill in specified values */ - err = dom_element_get_attribute(n, corestring_dom_name, &s); - if (err == DOM_NO_ERR && s != NULL) { - iframe->name = talloc_strdup(content->bctx, dom_string_data(s)); - dom_string_unref(s); - } - - err = dom_element_get_attribute(n, corestring_dom_frameborder, &s); - if (err == DOM_NO_ERR && s != NULL) { - i = atoi(dom_string_data(s)); - iframe->border = (i != 0); - dom_string_unref(s); - } - - err = dom_element_get_attribute(n, corestring_dom_bordercolor, &s); - if (err == DOM_NO_ERR && s != NULL) { - css_color color; - - if (nscss_parse_colour(dom_string_data(s), &color)) - iframe->border_colour = nscss_color_to_ns(color); - - dom_string_unref(s); - } - - err = dom_element_get_attribute(n, corestring_dom_scrolling, &s); - if (err == DOM_NO_ERR && s != NULL) { - if (dom_string_caseless_lwc_isequal(s, - corestring_lwc_yes)) - iframe->scrolling = BW_SCROLLING_YES; - else if (dom_string_caseless_lwc_isequal(s, - corestring_lwc_no)) - iframe->scrolling = BW_SCROLLING_NO; - dom_string_unref(s); - } - - err = dom_element_get_attribute(n, corestring_dom_marginwidth, &s); - if (err == DOM_NO_ERR && s != NULL) { - iframe->margin_width = atoi(dom_string_data(s)); - dom_string_unref(s); - } - - err = dom_element_get_attribute(n, corestring_dom_marginheight, &s); - if (err == DOM_NO_ERR && s != NULL) { - iframe->margin_height = atoi(dom_string_data(s)); - dom_string_unref(s); - } - - /* box */ - assert(box->style); - box->flags |= IFRAME; - box->flags |= IS_REPLACED; - - /* Showing iframe, so don't show alternate content */ - if (convert_children) - *convert_children = false; - return true; -} - - -/** - * Embedded image [13.2]. - */ -static bool -box_image(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - bool ok; - dom_string *s; - dom_exception err; - nsurl *url; - enum css_width_e wtype; - enum css_height_e htype; - css_fixed value = 0; - css_unit wunit = CSS_UNIT_PX; - css_unit hunit = CSS_UNIT_PX; - - if (box->style && - ns_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) - return true; - - /* handle alt text */ - err = dom_element_get_attribute(n, corestring_dom_alt, &s); - if (err == DOM_NO_ERR && s != NULL) { - char *alt = squash_whitespace(dom_string_data(s)); - dom_string_unref(s); - if (alt == NULL) - return false; - box->text = talloc_strdup(content->bctx, alt); - free(alt); - if (box->text == NULL) - return false; - box->length = strlen(box->text); - } - - if (nsoption_bool(foreground_images) == false) { - return true; - } - - /* imagemap associated with this image */ - if (!box_get_attribute(n, "usemap", content->bctx, &box->usemap)) - return false; - if (box->usemap && box->usemap[0] == '#') - box->usemap++; - - /* get image URL */ - err = dom_element_get_attribute(n, corestring_dom_src, &s); - if (err != DOM_NO_ERR || s == NULL) - return true; - - if (box_extract_link(content, s, content->base_url, &url) == false) { - dom_string_unref(s); - return false; - } - - dom_string_unref(s); - - if (url == NULL) - return true; - - /* start fetch */ - box->flags |= IS_REPLACED; - ok = html_fetch_object(content, url, box, image_types, - content->base.available_width, 1000, false); - nsurl_unref(url); - - wtype = css_computed_width(box->style, &value, &wunit); - htype = css_computed_height(box->style, &value, &hunit); - - if (wtype == CSS_WIDTH_SET && - wunit != CSS_UNIT_PCT && - htype == CSS_HEIGHT_SET && - hunit != CSS_UNIT_PCT) { - /* We know the dimensions the image will be shown at - * before it's fetched. */ - box->flags |= REPLACE_DIM; - } - - return ok; -} - - -/** - * Form control [17.4]. - */ -static bool -box_input(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - struct form_control *gadget; - dom_string *type = NULL; - dom_exception err; - nsurl *url; - nserror error; - - gadget = html_forms_get_control_for_node(content->forms, n); - if (gadget == NULL) { - return false; - } - - box->gadget = gadget; - box->flags |= IS_REPLACED; - gadget->box = box; - gadget->html = content; - - /* get entry type */ - err = dom_element_get_attribute(n, corestring_dom_type, &type); - if ((err != DOM_NO_ERR) || (type == NULL)) { - /* no type so "text" is assumed */ - if (box_input_text(content, box, n) == false) { - return false; - } - *convert_children = false; - return true; - } - - if (dom_string_caseless_lwc_isequal(type, corestring_lwc_password)) { - if (box_input_text(content, box, n) == false) - goto no_memory; - - } else if (dom_string_caseless_lwc_isequal(type, corestring_lwc_file)) { - box->type = BOX_INLINE_BLOCK; - - } else if (dom_string_caseless_lwc_isequal(type, - corestring_lwc_hidden)) { - /* no box for hidden inputs */ - box->type = BOX_NONE; - - } else if ((dom_string_caseless_lwc_isequal(type, - corestring_lwc_checkbox) || - dom_string_caseless_lwc_isequal(type, - corestring_lwc_radio))) { - - } else if (dom_string_caseless_lwc_isequal(type, - corestring_lwc_submit) || - dom_string_caseless_lwc_isequal(type, - corestring_lwc_reset) || - dom_string_caseless_lwc_isequal(type, - corestring_lwc_button)) { - struct box *inline_container, *inline_box; - - if (box_button(n, content, box, 0) == false) - goto no_memory; - - inline_container = box_create(NULL, 0, false, 0, 0, 0, 0, - content->bctx); - if (inline_container == NULL) - goto no_memory; - - inline_container->type = BOX_INLINE_CONTAINER; - - inline_box = box_create(NULL, box->style, false, 0, 0, - box->title, 0, content->bctx); - if (inline_box == NULL) - goto no_memory; - - inline_box->type = BOX_TEXT; - - if (box->gadget->value != NULL) - inline_box->text = talloc_strdup(content->bctx, - box->gadget->value); - else if (box->gadget->type == GADGET_SUBMIT) - inline_box->text = talloc_strdup(content->bctx, - messages_get("Form_Submit")); - else if (box->gadget->type == GADGET_RESET) - inline_box->text = talloc_strdup(content->bctx, - messages_get("Form_Reset")); - else - inline_box->text = talloc_strdup(content->bctx, - "Button"); - - if (inline_box->text == NULL) - goto no_memory; - - inline_box->length = strlen(inline_box->text); - - box_add_child(inline_container, inline_box); - - box_add_child(box, inline_container); - - } else if (dom_string_caseless_lwc_isequal(type, - corestring_lwc_image)) { - gadget->type = GADGET_IMAGE; - - if (box->style && - ns_computed_display(box->style, - box_is_root(n)) != CSS_DISPLAY_NONE && - nsoption_bool(foreground_images) == true) { - dom_string *s; - - err = dom_element_get_attribute(n, corestring_dom_src, &s); - if (err == DOM_NO_ERR && s != NULL) { - error = nsurl_join(content->base_url, - dom_string_data(s), &url); - dom_string_unref(s); - if (error != NSERROR_OK) - goto no_memory; - - /* if url is equivalent to the parent's url, - * we've got infinite inclusion. stop it here - */ - if (nsurl_compare(url, content->base_url, - NSURL_COMPLETE) == false) { - if (!html_fetch_object(content, url, - box, image_types, - content->base. - available_width, - 1000, false)) { - nsurl_unref(url); - goto no_memory; - } - } - nsurl_unref(url); - } - } - } else { - /* unhandled type the default is "text" */ - if (box_input_text(content, box, n) == false) - goto no_memory; - } - - dom_string_unref(type); - - *convert_children = false; - - return true; - -no_memory: - dom_string_unref(type); - - return false; -} - - -/** - * Noscript element - */ -static bool -box_noscript(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - /* If scripting is enabled, do not display the contents of noscript */ - if (content->enable_scripting) { - *convert_children = false; - } - - return true; -} - - -/** - * Generic embedded object [13.3]. - */ -static bool -box_object(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - struct object_params *params; - struct object_param *param; - dom_string *codebase, *classid, *data; - dom_node *c; - dom_exception err; - - if (box->style && - ns_computed_display(box->style, box_is_root(n)) == CSS_DISPLAY_NONE) - return true; - - if (box_get_attribute(n, "usemap", content->bctx, &box->usemap) == - false) - return false; - if (box->usemap && box->usemap[0] == '#') - box->usemap++; - - params = talloc(content->bctx, struct object_params); - if (params == NULL) - return false; - - talloc_set_destructor(params, box_object_talloc_destructor); - - params->data = NULL; - params->type = NULL; - params->codetype = NULL; - params->codebase = NULL; - params->classid = NULL; - params->params = NULL; - - /* codebase, classid, and data are URLs - * (codebase is the base for the other two) */ - err = dom_element_get_attribute(n, corestring_dom_codebase, &codebase); - if (err == DOM_NO_ERR && codebase != NULL) { - if (box_extract_link(content, codebase, content->base_url, - &params->codebase) == false) { - dom_string_unref(codebase); - return false; - } - dom_string_unref(codebase); - } - if (params->codebase == NULL) - params->codebase = nsurl_ref(content->base_url); - - err = dom_element_get_attribute(n, corestring_dom_classid, &classid); - if (err == DOM_NO_ERR && classid != NULL) { - if (box_extract_link(content, classid, - params->codebase, &params->classid) == false) { - dom_string_unref(classid); - return false; - } - dom_string_unref(classid); - } - - err = dom_element_get_attribute(n, corestring_dom_data, &data); - if (err == DOM_NO_ERR && data != NULL) { - if (box_extract_link(content, data, - params->codebase, &params->data) == false) { - dom_string_unref(data); - return false; - } - dom_string_unref(data); - } - - if (params->classid == NULL && params->data == NULL) - /* nothing to embed; ignore */ - return true; - - /* Don't include ourself */ - if (params->classid != NULL && nsurl_compare(content->base_url, - params->classid, NSURL_COMPLETE)) - return true; - - if (params->data != NULL && nsurl_compare(content->base_url, - params->data, NSURL_COMPLETE)) - return true; - - /* codetype and type are MIME types */ - if (box_get_attribute(n, "codetype", params, - &params->codetype) == false) - return false; - if (box_get_attribute(n, "type", params, &params->type) == false) - return false; - - /* classid && !data => classid is used (consult codetype) - * (classid || !classid) && data => data is used (consult type) - * !classid && !data => invalid; ignored */ - - if (params->classid != NULL && params->data == NULL && - params->codetype != NULL) { - lwc_string *icodetype; - lwc_error lerror; - - lerror = lwc_intern_string(params->codetype, - strlen(params->codetype), &icodetype); - if (lerror != lwc_error_ok) - return false; - - if (content_factory_type_from_mime_type(icodetype) == - CONTENT_NONE) { - /* can't handle this MIME type */ - lwc_string_unref(icodetype); - return true; - } - - lwc_string_unref(icodetype); - } - - if (params->data != NULL && params->type != NULL) { - lwc_string *itype; - lwc_error lerror; - - lerror = lwc_intern_string(params->type, strlen(params->type), - &itype); - if (lerror != lwc_error_ok) - return false; - - if (content_factory_type_from_mime_type(itype) == - CONTENT_NONE) { - /* can't handle this MIME type */ - lwc_string_unref(itype); - return true; - } - - lwc_string_unref(itype); - } - - /* add parameters to linked list */ - err = dom_node_get_first_child(n, &c); - if (err != DOM_NO_ERR) - return false; - - while (c != NULL) { - dom_node *next; - dom_node_type type; +#include <dom/dom.h> - err = dom_node_get_node_type(c, &type); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } - - if (type == DOM_ELEMENT_NODE) { - dom_string *name; - - err = dom_node_get_node_name(c, &name); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } - - if (!dom_string_caseless_lwc_isequal(name, - corestring_lwc_param)) { - /* The first non-param child is the start of - * the alt html. Therefore, we should break - * out of this loop. */ - dom_string_unref(name); - dom_node_unref(c); - break; - } - dom_string_unref(name); - - param = talloc(params, struct object_param); - if (param == NULL) { - dom_node_unref(c); - return false; - } - param->name = NULL; - param->value = NULL; - param->type = NULL; - param->valuetype = NULL; - param->next = NULL; - - if (box_get_attribute(c, "name", param, - &param->name) == false) { - dom_node_unref(c); - return false; - } - - if (box_get_attribute(c, "value", param, - &param->value) == false) { - dom_node_unref(c); - return false; - } - - if (box_get_attribute(c, "type", param, - &param->type) == false) { - dom_node_unref(c); - return false; - } +#include "utils/errors.h" +#include "utils/nsoption.h" +#include "utils/corestrings.h" +#include "utils/talloc.h" +#include "utils/string.h" +#include "utils/ascii.h" +#include "netsurf/misc.h" +#include "css/select.h" +#include "desktop/gui_internal.h" - if (box_get_attribute(c, "valuetype", param, - &param->valuetype) == false) { - dom_node_unref(c); - return false; - } +#include "html/html_internal.h" +#include "html/box.h" +#include "html/box_manipulate.h" +#include "html/box_construct.h" +#include "html/box_special.h" +#include "html/box_normalise.h" +#include "html/form_internal.h" - if (param->valuetype == NULL) { - param->valuetype = talloc_strdup(param, "data"); - if (param->valuetype == NULL) { - dom_node_unref(c); - return false; - } - } +/** + * Context for box tree construction + */ +struct box_construct_ctx { + html_content *content; /**< Content we're constructing for */ - param->next = params->params; - params->params = param; - } + dom_node *n; /**< Current node to process */ - err = dom_node_get_next_sibling(c, &next); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - return false; - } + struct box *root_box; /**< Root box in the tree */ - dom_node_unref(c); - c = next; - } + box_construct_complete_cb cb; /**< Callback to invoke on completion */ - box->object_params = params; + int *bctx; /**< talloc context */ +}; - /* start fetch (MIME type is ok or not specified) */ - box->flags |= IS_REPLACED; - if (!html_fetch_object(content, - params->data ? params->data : params->classid, - box, CONTENT_ANY, content->base.available_width, 1000, - false)) - return false; +/** + * Transient properties for construction of current node + */ +struct box_construct_props { + /** Style from which to inherit, or NULL if none */ + const css_computed_style *parent_style; + /** Current link target, or NULL if none */ + nsurl *href; + /** Current frame target, or NULL if none */ + const char *target; + /** Current title attribute, or NULL if none */ + const char *title; + /** Identity of the current block-level container */ + struct box *containing_block; + /** Current container for inlines, or NULL if none + * \note If non-NULL, will be the last child of containing_block */ + struct box *inline_container; + /** Whether the current node is the root of the DOM tree */ + bool node_is_root; +}; - *convert_children = false; - return true; -} +static const content_type image_types = CONTENT_IMAGE; +/* the strings are not important, since we just compare the pointers */ +const char *TARGET_SELF = "_self"; +const char *TARGET_PARENT = "_parent"; +const char *TARGET_TOP = "_top"; +const char *TARGET_BLANK = "_blank"; /** - * Preformatted text [9.3.4]. + * mapping from CSS display to box type this table must be in sync + * with libcss' css_display enum */ -static bool -box_pre(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - box->flags |= PRE_STRIP; - return true; -} +static const box_type box_map[] = { + 0, /* CSS_DISPLAY_INHERIT, */ + BOX_INLINE, /* CSS_DISPLAY_INLINE, */ + BOX_BLOCK, /* CSS_DISPLAY_BLOCK, */ + BOX_BLOCK, /* CSS_DISPLAY_LIST_ITEM, */ + BOX_INLINE, /* CSS_DISPLAY_RUN_IN, */ + BOX_INLINE_BLOCK, /* CSS_DISPLAY_INLINE_BLOCK, */ + BOX_TABLE, /* CSS_DISPLAY_TABLE, */ + BOX_TABLE, /* CSS_DISPLAY_INLINE_TABLE, */ + BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_ROW_GROUP, */ + BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_HEADER_GROUP, */ + BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_FOOTER_GROUP, */ + BOX_TABLE_ROW, /* CSS_DISPLAY_TABLE_ROW, */ + BOX_NONE, /* CSS_DISPLAY_TABLE_COLUMN_GROUP, */ + BOX_NONE, /* CSS_DISPLAY_TABLE_COLUMN, */ + BOX_TABLE_CELL, /* CSS_DISPLAY_TABLE_CELL, */ + BOX_INLINE, /* CSS_DISPLAY_TABLE_CAPTION, */ + BOX_NONE /* CSS_DISPLAY_NONE */ +}; /** - * Option selector [17.6]. + * determine if a box is the root node + * + * \param n node to check + * \return true if node is root else false. */ -static bool -box_select(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) +static inline bool box_is_root(dom_node *n) { - struct box *inline_container; - struct box *inline_box; - struct form_control *gadget; - dom_node *c, *c2; - dom_node *next, *next2; + dom_node *parent; + dom_node_type type; dom_exception err; - gadget = html_forms_get_control_for_node(content->forms, n); - if (gadget == NULL) + err = dom_node_get_parent_node(n, &parent); + if (err != DOM_NO_ERR) return false; - gadget->html = content; - err = dom_node_get_first_child(n, &c); - if (err != DOM_NO_ERR) { - form_free_control(gadget); - return false; - } + if (parent != NULL) { + err = dom_node_get_node_type(parent, &type); - while (c != NULL) { - dom_string *name; + dom_node_unref(parent); - err = dom_node_get_node_name(c, &name); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - form_free_control(gadget); + if (err != DOM_NO_ERR) return false; - } - - if (dom_string_caseless_lwc_isequal(name, - corestring_lwc_option)) { - dom_string_unref(name); - - if (box_select_add_option(gadget, c) == false) { - dom_node_unref(c); - form_free_control(gadget); - return false; - } - } else if (dom_string_caseless_lwc_isequal(name, - corestring_lwc_optgroup)) { - dom_string_unref(name); - - err = dom_node_get_first_child(c, &c2); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - form_free_control(gadget); - return false; - } - - while (c2 != NULL) { - dom_string *c2_name; - - err = dom_node_get_node_name(c2, &c2_name); - if (err != DOM_NO_ERR) { - dom_node_unref(c2); - dom_node_unref(c); - form_free_control(gadget); - return false; - } - - if (dom_string_caseless_lwc_isequal(c2_name, - corestring_lwc_option)) { - dom_string_unref(c2_name); - - if (box_select_add_option(gadget, - c2) == false) { - dom_node_unref(c2); - dom_node_unref(c); - form_free_control(gadget); - return false; - } - } else { - dom_string_unref(c2_name); - } - - err = dom_node_get_next_sibling(c2, &next2); - if (err != DOM_NO_ERR) { - dom_node_unref(c2); - dom_node_unref(c); - form_free_control(gadget); - return false; - } - - dom_node_unref(c2); - c2 = next2; - } - } else { - dom_string_unref(name); - } - err = dom_node_get_next_sibling(c, &next); - if (err != DOM_NO_ERR) { - dom_node_unref(c); - form_free_control(gadget); + if (type != DOM_DOCUMENT_NODE) return false; - } - - dom_node_unref(c); - c = next; - } - - if (gadget->data.select.num_items == 0) { - /* no options: ignore entire select */ - form_free_control(gadget); - return true; - } - - box->type = BOX_INLINE_BLOCK; - box->gadget = gadget; - box->flags |= IS_REPLACED; - gadget->box = box; - - inline_container = box_create(NULL, 0, false, 0, 0, 0, 0, content->bctx); - if (inline_container == NULL) - goto no_memory; - inline_container->type = BOX_INLINE_CONTAINER; - inline_box = box_create(NULL, box->style, false, 0, 0, box->title, 0, - content->bctx); - if (inline_box == NULL) - goto no_memory; - inline_box->type = BOX_TEXT; - box_add_child(inline_container, inline_box); - box_add_child(box, inline_container); - - if (gadget->data.select.multiple == false && - gadget->data.select.num_selected == 0) { - gadget->data.select.current = gadget->data.select.items; - gadget->data.select.current->initial_selected = - gadget->data.select.current->selected = true; - gadget->data.select.num_selected = 1; - dom_html_option_element_set_selected( - gadget->data.select.current->node, true); } - if (gadget->data.select.num_selected == 0) - inline_box->text = talloc_strdup(content->bctx, - messages_get("Form_None")); - else if (gadget->data.select.num_selected == 1) - inline_box->text = talloc_strdup(content->bctx, - gadget->data.select.current->text); - else - inline_box->text = talloc_strdup(content->bctx, - messages_get("Form_Many")); - if (inline_box->text == NULL) - goto no_memory; - - inline_box->length = strlen(inline_box->text); - - *convert_children = false; - return true; - -no_memory: - return false; -} - - -/** - * Multi-line text field [17.7]. - */ -static bool box_textarea(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children) -{ - /* Get the form_control for the DOM node */ - box->gadget = html_forms_get_control_for_node(content->forms, n); - if (box->gadget == NULL) - return false; - - box->flags |= IS_REPLACED; - box->gadget->html = content; - box->gadget->box = box; - - if (!box_input_text(content, box, n)) - return false; - - *convert_children = false; return true; } /** - * \} - */ - - -/** * Extract transient construction properties * * \param n Current DOM node to convert @@ -2245,93 +487,6 @@ box_construct_marker(struct box *box, /** - * call an elements special handler - */ -static bool -convert_special_elements(dom_node *node, - html_content *content, - struct box *box, - bool *convert_children) -{ - dom_exception exc; - dom_html_element_type tag_type; - bool res; - - exc = dom_html_element_get_tag_type(node, &tag_type); - if (exc != DOM_NO_ERR) { - tag_type = DOM_HTML_ELEMENT_TYPE__UNKNOWN; - } - - switch (tag_type) { - case DOM_HTML_ELEMENT_TYPE_A: - res = box_a(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_BODY: - res = box_body(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_BR: - res = box_br(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_BUTTON: - res = box_button(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_CANVAS: - res = box_canvas(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_EMBED: - res = box_embed(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_FRAMESET: - res = box_frameset(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_IFRAME: - res = box_iframe(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_IMG: - res = box_image(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_INPUT: - res = box_input(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_NOSCRIPT: - res = box_noscript(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_OBJECT: - res = box_object(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_PRE: - res = box_pre(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_SELECT: - res = box_select(node, content, box, convert_children); - break; - - case DOM_HTML_ELEMENT_TYPE_TEXTAREA: - res = box_textarea(node, content, box, convert_children); - break; - - default: - res = true; - } - - return res; -} - - -/** * Construct the box tree for an XML element. * * \param ctx Tree construction context diff --git a/content/handlers/html/box_construct.h b/content/handlers/html/box_construct.h index e93f515..f4bd119 100644 --- a/content/handlers/html/box_construct.h +++ b/content/handlers/html/box_construct.h @@ -19,6 +19,54 @@ /** * \file * HTML Box tree construction interface. + * + * This stage of rendering converts a tree of dom_nodes (produced by libdom) + * to a tree of struct box. The box tree represents the structure of the + * document as given by the CSS display and float properties. + * + * For example, consider the following HTML: + * \code + * <h1>Example Heading</h1> + * <p>Example paragraph <em>with emphasised text</em> etc.</p> \endcode + * + * This would produce approximately the following box tree with default CSS + * rules: + * \code + * BOX_BLOCK (corresponds to h1) + * BOX_INLINE_CONTAINER + * BOX_INLINE "Example Heading" + * BOX_BLOCK (p) + * BOX_INLINE_CONTAINER + * BOX_INLINE "Example paragraph " + * BOX_INLINE "with emphasised text" (em) + * BOX_INLINE "etc." \endcode + * + * Note that the em has been collapsed into the INLINE_CONTAINER. + * + * If these CSS rules were applied: + * \code + * h1 { display: table-cell } + * p { display: table-cell } + * em { float: left; width: 5em } \endcode + * + * then the box tree would instead look like this: + * \code + * BOX_TABLE + * BOX_TABLE_ROW_GROUP + * BOX_TABLE_ROW + * BOX_TABLE_CELL (h1) + * BOX_INLINE_CONTAINER + * BOX_INLINE "Example Heading" + * BOX_TABLE_CELL (p) + * BOX_INLINE_CONTAINER + * BOX_INLINE "Example paragraph " + * BOX_FLOAT_LEFT (em) + * BOX_BLOCK + * BOX_INLINE_CONTAINER + * BOX_INLINE "with emphasised text" + * BOX_INLINE "etc." \endcode + * + * Here implied boxes have been added and a float is present. */ #ifndef NETSURF_HTML_BOX_CONSTRUCT_H diff --git a/content/handlers/html/box.c b/content/handlers/html/box_inspect.c similarity index 56% rename from content/handlers/html/box.c rename to content/handlers/html/box_inspect.c index 0ad1061..268ed3d 100644 --- a/content/handlers/html/box.c +++ b/content/handlers/html/box_inspect.c @@ -1,8 +1,6 @@ /* - * Copyright 2005-2007 James Bursa <bursa(a)users.sourceforge.net> - * Copyright 2003 Phil Mellor <monkeyson(a)users.sourceforge.net> - * Copyright 2005 John M Bell <jmb202(a)ecs.soton.ac.uk> * Copyright 2008 Michael Drake <tlsa(a)netsurf-browser.org> + * Copyright 2020 Vincent Sanders <vince(a)netsurf-browser.org> * * This file is part of NetSurf, http://www.netsurf-browser.org/ * @@ -21,276 +19,39 @@ /** * \file - * implementation of box tree manipulation. + * implementation of box tree inspection. */ -#include <assert.h> -#include <stdbool.h> #include <stdio.h> -#include <string.h> #include <dom/dom.h> -#include "utils/nsoption.h" -#include "utils/log.h" -#include "utils/talloc.h" #include "utils/nsurl.h" -#include "netsurf/misc.h" +#include "utils/errors.h" +#include "netsurf/types.h" #include "netsurf/content.h" #include "netsurf/mouse.h" #include "css/utils.h" #include "css/dump.h" #include "desktop/scrollbar.h" -#include "desktop/gui_internal.h" -#include "desktop/search.h" #include "html/box.h" -#include "html/form_internal.h" +#include "html/box_inspect.h" #include "html/html_internal.h" -#include "html/interaction.h" - -#define box_is_float(box) (box->type == BOX_FLOAT_LEFT || \ - box->type == BOX_FLOAT_RIGHT) /** - * Destructor for box nodes which own styles - * - * \param b The box being destroyed. - * \return 0 to allow talloc to continue destroying the tree. + * Direction to move in a box-tree walk */ -static int box_talloc_destructor(struct box *b) -{ - struct html_scrollbar_data *data; - - if ((b->flags & STYLE_OWNED) && b->style != NULL) { - css_computed_style_destroy(b->style); - b->style = NULL; - } - - if (b->styles != NULL) { - css_select_results_destroy(b->styles); - b->styles = NULL; - } - - if (b->href != NULL) - nsurl_unref(b->href); - - if (b->id != NULL) { - lwc_string_unref(b->id); - } - - if (b->node != NULL) { - dom_node_unref(b->node); - } - - if (b->scroll_x != NULL) { - data = scrollbar_get_data(b->scroll_x); - scrollbar_destroy(b->scroll_x); - free(data); - } - - if (b->scroll_y != NULL) { - data = scrollbar_get_data(b->scroll_y); - scrollbar_destroy(b->scroll_y); - free(data); - } - - return 0; -} - - -/* Exported function documented in html/box.h */ -struct box * -box_create(css_select_results *styles, - css_computed_style *style, - bool style_owned, - nsurl *href, - const char *target, - const char *title, - lwc_string *id, - void *context) -{ - unsigned int i; - struct box *box; - - box = talloc(context, struct box); - if (!box) { - return 0; - } - - talloc_set_destructor(box, box_talloc_destructor); - - box->type = BOX_INLINE; - box->flags = 0; - box->flags = style_owned ? (box->flags | STYLE_OWNED) : box->flags; - box->styles = styles; - box->style = style; - box->x = box->y = 0; - box->width = UNKNOWN_WIDTH; - box->height = 0; - box->descendant_x0 = box->descendant_y0 = 0; - box->descendant_x1 = box->descendant_y1 = 0; - for (i = 0; i != 4; i++) - box->margin[i] = box->padding[i] = box->border[i].width = 0; - box->scroll_x = box->scroll_y = NULL; - box->min_width = 0; - box->max_width = UNKNOWN_MAX_WIDTH; - box->byte_offset = 0; - box->text = NULL; - box->length = 0; - box->space = 0; - box->href = (href == NULL) ? NULL : nsurl_ref(href); - box->target = target; - box->title = title; - box->columns = 1; - box->rows = 1; - box->start_column = 0; - box->next = NULL; - box->prev = NULL; - box->children = NULL; - box->last = NULL; - box->parent = NULL; - box->inline_end = NULL; - box->float_children = NULL; - box->float_container = NULL; - box->next_float = NULL; - box->cached_place_below_level = 0; - box->list_marker = NULL; - box->col = NULL; - box->gadget = NULL; - box->usemap = NULL; - box->id = id; - box->background = NULL; - box->object = NULL; - box->object_params = NULL; - box->iframe = NULL; - box->node = NULL; - - return box; -} - - -/* Exported function documented in html/box.h */ -void box_add_child(struct box *parent, struct box *child) -{ - assert(parent); - assert(child); - - if (parent->children != 0) { /* has children already */ - parent->last->next = child; - child->prev = parent->last; - } else { /* this is the first child */ - parent->children = child; - child->prev = 0; - } - - parent->last = child; - child->parent = parent; -} - - -/* Exported function documented in html/box.h */ -void box_insert_sibling(struct box *box, struct box *new_box) -{ - new_box->parent = box->parent; - new_box->prev = box; - new_box->next = box->next; - box->next = new_box; - if (new_box->next) - new_box->next->prev = new_box; - else if (new_box->parent) - new_box->parent->last = new_box; -} - - -/* Exported function documented in html/box.h */ -void box_unlink_and_free(struct box *box) -{ - struct box *parent = box->parent; - struct box *next = box->next; - struct box *prev = box->prev; - - if (parent) { - if (parent->children == box) - parent->children = next; - if (parent->last == box) - parent->last = next ? next : prev; - } - - if (prev) - prev->next = next; - if (next) - next->prev = prev; - - box_free(box); -} - - -/* Exported function documented in html/box.h */ -void box_free(struct box *box) -{ - struct box *child, *next; - - /* free children first */ - for (child = box->children; child; child = next) { - next = child->next; - box_free(child); - } - - /* last this box */ - box_free_box(box); -} - - -/* Exported function documented in html/box.h */ -void box_free_box(struct box *box) -{ - if (!(box->flags & CLONE)) { - if (box->gadget) - form_free_control(box->gadget); - if (box->scroll_x != NULL) - scrollbar_destroy(box->scroll_x); - if (box->scroll_y != NULL) - scrollbar_destroy(box->scroll_y); - if (box->styles != NULL) - css_select_results_destroy(box->styles); - } - - talloc_free(box); -} - - -/* Exported function documented in html/box.h */ -void box_coords(struct box *box, int *x, int *y) -{ - *x = box->x; - *y = box->y; - while (box->parent) { - if (box_is_float(box)) { - assert(box->float_container); - box = box->float_container; - } else { - box = box->parent; - } - *x += box->x - scrollbar_get_offset(box->scroll_x); - *y += box->y - scrollbar_get_offset(box->scroll_y); - } -} - - -/* Exported function documented in html/box.h */ -void box_bounds(struct box *box, struct rect *r) -{ - int width, height; - - box_coords(box, &r->x0, &r->y0); - - width = box->padding[LEFT] + box->width + box->padding[RIGHT]; - height = box->padding[TOP] + box->height + box->padding[BOTTOM]; - - r->x1 = r->x0 + width; - r->y1 = r->y0 + height; -} +enum box_walk_dir { + BOX_WALK_CHILDREN, + BOX_WALK_PARENT, + BOX_WALK_NEXT_SIBLING, + BOX_WALK_FLOAT_CHILDREN, + BOX_WALK_NEXT_FLOAT_SIBLING, + BOX_WALK_FLOAT_CONTAINER +}; +#define box_is_float(box) (box->type == BOX_FLOAT_LEFT || \ + box->type == BOX_FLOAT_RIGHT) /** * Determine if a point lies within a box. @@ -309,60 +70,61 @@ void box_bounds(struct box *box, struct rect *r) * * This is a helper function for box_at_point(). */ -static bool box_contains_point( - const nscss_len_ctx *len_ctx, - const struct box *box, - int x, - int y, - bool *physically) +static bool +box_contains_point(const nscss_len_ctx *len_ctx, + const struct box *box, + int x, + int y, + bool *physically) { css_computed_clip_rect css_rect; if (box->style != NULL && - css_computed_position(box->style) == - CSS_POSITION_ABSOLUTE && - css_computed_clip(box->style, &css_rect) == - CSS_CLIP_RECT) { + css_computed_position(box->style) == CSS_POSITION_ABSOLUTE && + css_computed_clip(box->style, &css_rect) == CSS_CLIP_RECT) { /* We have an absolutly positioned box with a clip rect */ struct rect r = { - .x0 = box->border[LEFT].width, - .y0 = box->border[TOP].width, - .x1 = box->padding[LEFT] + box->width + - box->border[RIGHT].width + - box->padding[RIGHT], - .y1 = box->padding[TOP] + box->height + - box->border[BOTTOM].width + - box->padding[BOTTOM] + .x0 = box->border[LEFT].width, + .y0 = box->border[TOP].width, + .x1 = box->padding[LEFT] + box->width + + box->border[RIGHT].width + + box->padding[RIGHT], + .y1 = box->padding[TOP] + box->height + + box->border[BOTTOM].width + + box->padding[BOTTOM] }; - if (x >= r.x0 && x < r.x1 && y >= r.y0 && y < r.y1) + if (x >= r.x0 && x < r.x1 && y >= r.y0 && y < r.y1) { *physically = true; - else + } else { *physically = false; + } /* Adjust rect to css clip region */ if (css_rect.left_auto == false) { r.x0 += FIXTOINT(nscss_len2px(len_ctx, - css_rect.left, css_rect.lunit, - box->style)); + css_rect.left, + css_rect.lunit, + box->style)); } if (css_rect.top_auto == false) { r.y0 += FIXTOINT(nscss_len2px(len_ctx, - css_rect.top, css_rect.tunit, - box->style)); + css_rect.top, + css_rect.tunit, + box->style)); } if (css_rect.right_auto == false) { r.x1 = box->border[LEFT].width + - FIXTOINT(nscss_len2px(len_ctx, - css_rect.right, - css_rect.runit, - box->style)); + FIXTOINT(nscss_len2px(len_ctx, + css_rect.right, + css_rect.runit, + box->style)); } if (css_rect.bottom_auto == false) { r.y1 = box->border[TOP].width + - FIXTOINT(nscss_len2px(len_ctx, - css_rect.bottom, - css_rect.bunit, - box->style)); + FIXTOINT(nscss_len2px(len_ctx, + css_rect.bottom, + css_rect.bunit, + box->style)); } /* Test if point is in clipped box */ @@ -375,43 +137,43 @@ static bool box_contains_point( return false; } if (x >= -box->border[LEFT].width && - x < box->padding[LEFT] + box->width + - box->padding[RIGHT] + box->border[RIGHT].width && - y >= -box->border[TOP].width && - y < box->padding[TOP] + box->height + - box->padding[BOTTOM] + box->border[BOTTOM].width) { + x < box->padding[LEFT] + box->width + + box->padding[RIGHT] + box->border[RIGHT].width && + y >= -box->border[TOP].width && + y < box->padding[TOP] + box->height + + box->padding[BOTTOM] + box->border[BOTTOM].width) { *physically = true; return true; } if (box->list_marker && box->list_marker->x - box->x <= x + - box->list_marker->border[LEFT].width && - x < box->list_marker->x - box->x + - box->list_marker->padding[LEFT] + - box->list_marker->width + - box->list_marker->border[RIGHT].width + - box->list_marker->padding[RIGHT] && - box->list_marker->y - box->y <= y + - box->list_marker->border[TOP].width && - y < box->list_marker->y - box->y + - box->list_marker->padding[TOP] + - box->list_marker->height + - box->list_marker->border[BOTTOM].width + - box->list_marker->padding[BOTTOM]) { + box->list_marker->border[LEFT].width && + x < box->list_marker->x - box->x + + box->list_marker->padding[LEFT] + + box->list_marker->width + + box->list_marker->border[RIGHT].width + + box->list_marker->padding[RIGHT] && + box->list_marker->y - box->y <= y + + box->list_marker->border[TOP].width && + y < box->list_marker->y - box->y + + box->list_marker->padding[TOP] + + box->list_marker->height + + box->list_marker->border[BOTTOM].width + + box->list_marker->padding[BOTTOM]) { *physically = true; return true; } if ((box->style && css_computed_overflow_x(box->style) == - CSS_OVERFLOW_VISIBLE) || !box->style) { + CSS_OVERFLOW_VISIBLE) || !box->style) { if (box->descendant_x0 <= x && - x < box->descendant_x1) { + x < box->descendant_x1) { *physically = false; return true; } } if ((box->style && css_computed_overflow_y(box->style) == - CSS_OVERFLOW_VISIBLE) || !box->style) { + CSS_OVERFLOW_VISIBLE) || !box->style) { if (box->descendant_y0 <= y && - y < box->descendant_y1) { + y < box->descendant_y1) { *physically = false; return true; } @@ -421,25 +183,12 @@ static bool box_contains_point( /** - * Direction to move in a box-tree walk - */ -enum box_walk_dir { - BOX_WALK_CHILDREN, - BOX_WALK_PARENT, - BOX_WALK_NEXT_SIBLING, - BOX_WALK_FLOAT_CHILDREN, - BOX_WALK_NEXT_FLOAT_SIBLING, - BOX_WALK_FLOAT_CONTAINER -}; - - -/** * Move from box to next box in given direction, adjusting for box coord change * - * \param b box to move from from - * \param dir direction to move in - * \param x box's global x-coord, updated to position of next box - * \param y box's global y-coord, updated to position of next box + * \param b box to move from from + * \param dir direction to move in + * \param x box's global x-coord, updated to position of next box + * \param y box's global y-coord, updated to position of next box * * If no box can be found in given direction, NULL is returned. */ @@ -525,8 +274,8 @@ box_move_xy(struct box *b, enum box_walk_dir dir, int *x, int *y) * This walks to a boxes float children before its children. When walking * children, floating boxes are skipped. */ -static inline struct box *box_next_xy(struct box *b, int *x, int *y, - bool skip_children) +static inline struct box * +box_next_xy(struct box *b, int *x, int *y, bool skip_children) { struct box *n; int tx, ty; @@ -546,7 +295,7 @@ static inline struct box *box_next_xy(struct box *b, int *x, int *y, *y = ty; return n; } -done_float_children: + done_float_children: tx = *x; ty = *y; n = box_move_xy(b, BOX_WALK_CHILDREN, &tx, &ty); @@ -557,7 +306,7 @@ done_float_children: return n; } -skip_children: + skip_children: tx = *x; ty = *y; n = box_move_xy(b, BOX_WALK_NEXT_FLOAT_SIBLING, &tx, &ty); if (n) { @@ -616,38 +365,6 @@ skip_children: } -/* Exported function documented in html/box.h */ -struct box * -box_at_point(const nscss_len_ctx *len_ctx, - struct box *box, - const int x, const int y, - int *box_x, int *box_y) -{ - bool skip_children; - bool physically; - - assert(box); - - skip_children = false; - while ((box = box_next_xy(box, box_x, box_y, skip_children))) { - if (box_contains_point(len_ctx, box, x - *box_x, y - *box_y, - &physically)) { - *box_x -= scrollbar_get_offset(box->scroll_x); - *box_y -= scrollbar_get_offset(box->scroll_y); - - if (physically) - return box; - - skip_children = false; - } else { - skip_children = true; - } - } - - return NULL; -} - - /** * Check whether box is nearer mouse coordinates than current nearest box * @@ -746,9 +463,15 @@ box_nearer_text_box(struct box *box, * updated if a descendant of box is nearer than old nearest * \return true if mouse point is inside text_box */ -static bool box_nearest_text_box(struct box *box, int bx, int by, - int fx, int fy, int x, int y, int dir, struct box **nearest, - int *tx, int *ty, int *nr_xd, int *nr_yd) +static bool +box_nearest_text_box(struct box *box, + int bx, int by, + int fx, int fy, + int x, int y, + int dir, + struct box **nearest, + int *tx, int *ty, + int *nr_xd, int *nr_yd) { struct box *child = box->children; int c_bx, c_by; @@ -771,16 +494,16 @@ static bool box_nearest_text_box(struct box *box, int bx, int by, while (child) { if (child->type == BOX_FLOAT_LEFT || - child->type == BOX_FLOAT_RIGHT) { + child->type == BOX_FLOAT_RIGHT) { c_bx = fx + child->x - - scrollbar_get_offset(child->scroll_x); + scrollbar_get_offset(child->scroll_x); c_by = fy + child->y - - scrollbar_get_offset(child->scroll_y); + scrollbar_get_offset(child->scroll_y); } else { c_bx = bx + child->x - - scrollbar_get_offset(child->scroll_x); + scrollbar_get_offset(child->scroll_x); c_by = by + child->y - - scrollbar_get_offset(child->scroll_y); + scrollbar_get_offset(child->scroll_y); } if (child->float_children) { c_fx = c_bx; @@ -791,8 +514,8 @@ static bool box_nearest_text_box(struct box *box, int bx, int by, } if (in_box && child->text && !child->object) { if (box_nearer_text_box(child, - c_bx, c_by, x, y, dir, nearest, - tx, ty, nr_xd, nr_yd)) + c_bx, c_by, x, y, dir, nearest, + tx, ty, nr_xd, nr_yd)) return true; } else { if (child->list_marker) { @@ -805,8 +528,9 @@ static bool box_nearest_text_box(struct box *box, int bx, int by, return true; } if (box_nearest_text_box(child, c_bx, c_by, - c_fx, c_fy, x, y, dir, nearest, tx, ty, - nr_xd, nr_yd)) + c_fx, c_fy, + x, y, dir, nearest, tx, ty, + nr_xd, nr_yd)) return true; } child = child->next; @@ -817,55 +541,67 @@ static bool box_nearest_text_box(struct box *box, int bx, int by, /* Exported function documented in html/box.h */ -struct box * -box_pick_text_box(struct html_content *html, - int x, int y, - int dir, - int *dx, int *dy) +void box_coords(struct box *box, int *x, int *y) { - struct box *text_box = NULL; - struct box *box; - int nr_xd, nr_yd; - int bx, by; - int fx, fy; - int tx, ty; + *x = box->x; + *y = box->y; + while (box->parent) { + if (box_is_float(box)) { + assert(box->float_container); + box = box->float_container; + } else { + box = box->parent; + } + *x += box->x - scrollbar_get_offset(box->scroll_x); + *y += box->y - scrollbar_get_offset(box->scroll_y); + } +} - if (html == NULL) - return NULL; - box = html->layout; - bx = box->margin[LEFT]; - by = box->margin[TOP]; - fx = bx; - fy = by; +/* Exported function documented in html/box.h */ +void box_bounds(struct box *box, struct rect *r) +{ + int width, height; - if (!box_nearest_text_box(box, bx, by, fx, fy, x, y, - dir, &text_box, &tx, &ty, &nr_xd, &nr_yd)) { - if (text_box && text_box->text && !text_box->object) { - int w = (text_box->padding[LEFT] + - text_box->width + - text_box->padding[RIGHT]); - int h = (text_box->padding[TOP] + - text_box->height + - text_box->padding[BOTTOM]); - int x1, y1; + box_coords(box, &r->x0, &r->y0); - y1 = ty + h; - x1 = tx + w; + width = box->padding[LEFT] + box->width + box->padding[RIGHT]; + height = box->padding[TOP] + box->height + box->padding[BOTTOM]; - /* ensure point lies within the text box */ - if (x < tx) x = tx; - if (y < ty) y = ty; - if (y > y1) y = y1; - if (x > x1) x = x1; + r->x1 = r->x0 + width; + r->y1 = r->y0 + height; +} + + +/* Exported function documented in html/box.h */ +struct box * +box_at_point(const nscss_len_ctx *len_ctx, + struct box *box, + const int x, const int y, + int *box_x, int *box_y) +{ + bool skip_children; + bool physically; + + assert(box); + + skip_children = false; + while ((box = box_next_xy(box, box_x, box_y, skip_children))) { + if (box_contains_point(len_ctx, box, x - *box_x, y - *box_y, + &physically)) { + *box_x -= scrollbar_get_offset(box->scroll_x); + *box_y -= scrollbar_get_offset(box->scroll_y); + + if (physically) + return box; + + skip_children = false; + } else { + skip_children = true; } } - /* return coordinates relative to box */ - *dx = x - tx; - *dy = y - ty; - - return text_box; + return NULL; } @@ -876,13 +612,15 @@ struct box *box_find_by_id(struct box *box, lwc_string *id) bool m; if (box->id != NULL && - lwc_string_isequal(id, box->id, &m) == lwc_error_ok && - m == true) + lwc_string_isequal(id, box->id, &m) == lwc_error_ok && + m == true) { return box; + } for (a = box->children; a; a = a->next) { - if ((b = box_find_by_id(a, id)) != NULL) + if ((b = box_find_by_id(a, id)) != NULL) { return b; + } } return NULL; @@ -893,9 +631,10 @@ struct box *box_find_by_id(struct box *box, lwc_string *id) bool box_visible(struct box *box) { /* visibility: hidden */ - if (box->style && css_computed_visibility(box->style) == - CSS_VISIBILITY_HIDDEN) + if (box->style && + css_computed_visibility(box->style) == CSS_VISIBILITY_HIDDEN) { return false; + } return true; } @@ -907,50 +646,92 @@ void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style) unsigned int i; struct box *c, *prev; - for (i = 0; i != depth; i++) + for (i = 0; i != depth; i++) { fprintf(stream, " "); + } fprintf(stream, "%p ", box); - fprintf(stream, "x%i y%i w%i h%i ", box->x, box->y, - box->width, box->height); - if (box->max_width != UNKNOWN_MAX_WIDTH) + fprintf(stream, "x%i y%i w%i h%i ", + box->x, box->y, box->width, box->height); + if (box->max_width != UNKNOWN_MAX_WIDTH) { fprintf(stream, "min%i max%i ", box->min_width, box->max_width); + } fprintf(stream, "(%i %i %i %i) ", - box->descendant_x0, box->descendant_y0, - box->descendant_x1, box->descendant_y1); + box->descendant_x0, box->descendant_y0, + box->descendant_x1, box->descendant_y1); fprintf(stream, "m(%i %i %i %i) ", - box->margin[TOP], box->margin[LEFT], - box->margin[BOTTOM], box->margin[RIGHT]); + box->margin[TOP], box->margin[LEFT], + box->margin[BOTTOM], box->margin[RIGHT]); switch (box->type) { - case BOX_BLOCK: fprintf(stream, "BLOCK "); break; - case BOX_INLINE_CONTAINER: fprintf(stream, "INLINE_CONTAINER "); break; - case BOX_INLINE: fprintf(stream, "INLINE "); break; - case BOX_INLINE_END: fprintf(stream, "INLINE_END "); break; - case BOX_INLINE_BLOCK: fprintf(stream, "INLINE_BLOCK "); break; - case BOX_TABLE: fprintf(stream, "TABLE [columns %i] ", - box->columns); break; - case BOX_TABLE_ROW: fprintf(stream, "TABLE_ROW "); break; - case BOX_TABLE_CELL: fprintf(stream, "TABLE_CELL [columns %i, " - "start %i, rows %i] ", box->columns, - box->start_column, box->rows); break; - case BOX_TABLE_ROW_GROUP: fprintf(stream, "TABLE_ROW_GROUP "); break; - case BOX_FLOAT_LEFT: fprintf(stream, "FLOAT_LEFT "); break; - case BOX_FLOAT_RIGHT: fprintf(stream, "FLOAT_RIGHT "); break; - case BOX_BR: fprintf(stream, "BR "); break; - case BOX_TEXT: fprintf(stream, "TEXT "); break; - default: fprintf(stream, "Unknown box type "); + case BOX_BLOCK: + fprintf(stream, "BLOCK "); + break; + + case BOX_INLINE_CONTAINER: + fprintf(stream, "INLINE_CONTAINER "); + break; + + case BOX_INLINE: + fprintf(stream, "INLINE "); + break; + + case BOX_INLINE_END: + fprintf(stream, "INLINE_END "); + break; + + case BOX_INLINE_BLOCK: + fprintf(stream, "INLINE_BLOCK "); + break; + + case BOX_TABLE: + fprintf(stream, "TABLE [columns %i] ", box->columns); + break; + + case BOX_TABLE_ROW: + fprintf(stream, "TABLE_ROW "); + break; + + case BOX_TABLE_CELL: + fprintf(stream, "TABLE_CELL [columns %i, start %i, rows %i] ", + box->columns, + box->start_column, + box->rows); + break; + + case BOX_TABLE_ROW_GROUP: + fprintf(stream, "TABLE_ROW_GROUP "); + break; + + case BOX_FLOAT_LEFT: + fprintf(stream, "FLOAT_LEFT "); + break; + + case BOX_FLOAT_RIGHT: + fprintf(stream, "FLOAT_RIGHT "); + break; + + case BOX_BR: + fprintf(stream, "BR "); + break; + + case BOX_TEXT: + fprintf(stream, "TEXT "); + break; + + default: + fprintf(stream, "Unknown box type "); } if (box->text) fprintf(stream, "%li '%.*s' ", (unsigned long) box->byte_offset, - (int) box->length, box->text); + (int) box->length, box->text); if (box->space) fprintf(stream, "space "); if (box->object) { fprintf(stream, "(object '%s') ", - nsurl_access(hlcache_handle_get_url(box->object))); + nsurl_access(hlcache_handle_get_url(box->object))); } if (box->iframe) { fprintf(stream, "(iframe) "); @@ -977,16 +758,23 @@ void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style) fprintf(stream, " float_container %p", box->float_container); if (box->col) { fprintf(stream, " (columns"); - for (i = 0; i != box->columns; i++) + for (i = 0; i != box->columns; i++) { fprintf(stream, " (%s %s %i %i %i)", - ((const char *[]) {"UNKNOWN", "FIXED", - "AUTO", "PERCENT", "RELATIVE"}) - [box->col[i].type], - ((const char *[]) {"normal", + ((const char *[]) { + "UNKNOWN", + "FIXED", + "AUTO", + "PERCENT", + "RELATIVE" + }) + [box->col[i].type], + ((const char *[]) { + "normal", "positioned"}) - [box->col[i].positioned], - box->col[i].width, - box->col[i].min, box->col[i].max); + [box->col[i].positioned], + box->col[i].width, + box->col[i].min, box->col[i].max); + } fprintf(stream, ")"); } if (box->node != NULL) { @@ -1009,133 +797,89 @@ void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style) ; if (box->last != c) fprintf(stream, "warning: box->last %p (should be %p) " - "(box %p)\n", box->last, c, box); + "(box %p)\n", box->last, c, box); for (prev = 0, c = box->children; c; prev = c, c = c->next) { if (c->parent != box) fprintf(stream, "warning: box->parent %p (should be " - "%p) (box on next line)\n", - c->parent, box); + "%p) (box on next line)\n", + c->parent, box); if (c->prev != prev) fprintf(stream, "warning: box->prev %p (should be " - "%p) (box on next line)\n", - c->prev, prev); + "%p) (box on next line)\n", + c->prev, prev); box_dump(stream, c, depth + 1, style); } } /* exported interface documented in html/box.h */ -nserror -box_handle_scrollbars(struct content *c, - struct box *box, - bool bottom, - bool right) +bool box_vscrollbar_present(const struct box * const box) { - struct html_scrollbar_data *data; - int visible_width, visible_height; - int full_width, full_height; - nserror res; - - if (!bottom && box->scroll_x != NULL) { - data = scrollbar_get_data(box->scroll_x); - scrollbar_destroy(box->scroll_x); - free(data); - box->scroll_x = NULL; - } - - if (!right && box->scroll_y != NULL) { - data = scrollbar_get_data(box->scroll_y); - scrollbar_destroy(box->scroll_y); - free(data); - box->scroll_y = NULL; - } - - if (!bottom && !right) { - return NSERROR_OK; - } - - visible_width = box->width + box->padding[RIGHT] + box->padding[LEFT]; - visible_height = box->height + box->padding[TOP] + box->padding[BOTTOM]; - - full_width = ((box->descendant_x1 - box->border[RIGHT].width) > - visible_width) ? - box->descendant_x1 + box->padding[RIGHT] : - visible_width; - full_height = ((box->descendant_y1 - box->border[BOTTOM].width) > - visible_height) ? - box->descendant_y1 + box->padding[BOTTOM] : - visible_height; - - if (right) { - if (box->scroll_y == NULL) { - data = malloc(sizeof(struct html_scrollbar_data)); - if (data == NULL) { - return NSERROR_NOMEM; - } - data->c = c; - data->box = box; - res = scrollbar_create(false, - visible_height, - full_height, - visible_height, - data, - html_overflow_scroll_callback, - &(box->scroll_y)); - if (res != NSERROR_OK) { - return res; - } - } else { - scrollbar_set_extents(box->scroll_y, - visible_height, - visible_height, - full_height); - } - } - if (bottom) { - if (box->scroll_x == NULL) { - data = malloc(sizeof(struct html_scrollbar_data)); - if (data == NULL) { - return NSERROR_OK; - } - data->c = c; - data->box = box; - res = scrollbar_create(true, - visible_width - (right ? SCROLLBAR_WIDTH : 0), - full_width, - visible_width, - data, - html_overflow_scroll_callback, - &box->scroll_x); - if (res != NSERROR_OK) { - return res; - } - } else { - scrollbar_set_extents(box->scroll_x, - visible_width - - (right ? SCROLLBAR_WIDTH : 0), - visible_width, full_width); - } - } - - if (right && bottom) { - scrollbar_make_pair(box->scroll_x, box->scroll_y); - } - - return NSERROR_OK; + return box->padding[TOP] + + box->height + + box->padding[BOTTOM] + + box->border[BOTTOM].width < box->descendant_y1; } /* exported interface documented in html/box.h */ -bool box_vscrollbar_present(const struct box * const box) +bool box_hscrollbar_present(const struct box * const box) { - return box->padding[TOP] + box->height + box->padding[BOTTOM] + - box->border[BOTTOM].width < box->descendant_y1; + return box->padding[LEFT] + + box->width + + box->padding[RIGHT] + + box->border[RIGHT].width < box->descendant_x1; } -/* exported interface documented in html/box.h */ -bool box_hscrollbar_present(const struct box * const box) +/* Exported function documented in html/box.h */ +struct box * +box_pick_text_box(struct html_content *html, + int x, int y, + int dir, + int *dx, int *dy) { - return box->padding[LEFT] + box->width + box->padding[RIGHT] + - box->border[RIGHT].width < box->descendant_x1; + struct box *text_box = NULL; + struct box *box; + int nr_xd, nr_yd; + int bx, by; + int fx, fy; + int tx, ty; + + if (html == NULL) + return NULL; + + box = html->layout; + bx = box->margin[LEFT]; + by = box->margin[TOP]; + fx = bx; + fy = by; + + if (!box_nearest_text_box(box, bx, by, fx, fy, x, y, + dir, &text_box, &tx, &ty, &nr_xd, &nr_yd)) { + if (text_box && text_box->text && !text_box->object) { + int w = (text_box->padding[LEFT] + + text_box->width + + text_box->padding[RIGHT]); + int h = (text_box->padding[TOP] + + text_box->height + + text_box->padding[BOTTOM]); + int x1, y1; + + y1 = ty + h; + x1 = tx + w; + + /* ensure point lies within the text box */ + if (x < tx) x = tx; + if (y < ty) y = ty; + if (y > y1) y = y1; + if (x > x1) x = x1; + } + } + + /* return coordinates relative to box */ + *dx = x - tx; + *dy = y - ty; + + return text_box; } diff --git a/content/handlers/html/box_inspect.h b/content/handlers/html/box_inspect.h new file mode 100644 index 0000000..d50b848 --- /dev/null +++ b/content/handlers/html/box_inspect.h @@ -0,0 +1,143 @@ +/* + * Copyright 2020 Vincent Sanders <vince(a)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 + * HTML Box tree inspection interface. + */ + +#ifndef NETSURF_HTML_BOX_INSPECT_H +#define NETSURF_HTML_BOX_INSPECT_H + +/** + * Find the absolute coordinates of a box. + * + * \param box the box to calculate coordinates of + * \param x updated to x coordinate + * \param y updated to y coordinate + */ +void box_coords(struct box *box, int *x, int *y); + + +/** + * Find the bounds of a box. + * + * \param box the box to calculate bounds of + * \param r receives bounds + */ +void box_bounds(struct box *box, struct rect *r); + + +/** + * Find the boxes at a point. + * + * \param len_ctx CSS length conversion context for document. + * \param box box to search children of + * \param x point to find, in global document coordinates + * \param y point to find, in global document coordinates + * \param box_x position of box, in global document coordinates, updated + * to position of returned box, if any + * \param box_y position of box, in global document coordinates, updated + * to position of returned box, if any + * \return box at given point, or 0 if none found + * + * To find all the boxes in the hierarchy at a certain point, use code like + * this: + * \code + * struct box *box = top_of_document_to_search; + * int box_x = 0, box_y = 0; + * + * while ((box = box_at_point(len_ctx, box, x, y, &box_x, &box_y))) { + * // process box + * } + * \endcode + */ +struct box *box_at_point(const nscss_len_ctx *len_ctx, struct box *box, const int x, const int y, int *box_x, int *box_y); + + +/** + * Find a box based upon its id attribute. + * + * \param box box tree to search + * \param id id to look for + * \return the box or 0 if not found + */ +struct box *box_find_by_id(struct box *box, lwc_string *id); + + +/** + * Determine if a box is visible when the tree is rendered. + * + * \param box box to check + * \return true iff the box is rendered + */ +bool box_visible(struct box *box); + + +/** + * Print a box tree to a file. + */ +void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style); + + +/** + * Determine if a box has a vertical scrollbar. + * + * \param box scrolling box + * \return the box has a vertical scrollbar + */ +bool box_vscrollbar_present(const struct box *box); + + +/** + * Determine if a box has a horizontal scrollbar. + * + * \param box scrolling box + * \return the box has a horizontal scrollbar + */ +bool box_hscrollbar_present(const struct box *box); + + +/** + * Peform pick text on browser window contents to locate the box under + * the mouse pointer, or nearest in the given direction if the pointer is + * not over a text box. + * + * \param html an HTML content + * \param x coordinate of mouse + * \param y coordinate of mouse + * \param dir direction to search (-1 = above-left, +1 = below-right) + * \param dx receives x ordinate of mouse relative to text box + * \param dy receives y ordinate of mouse relative to text box + */ +struct box *box_pick_text_box(struct html_content *html, int x, int y, int dir, int *dx, int *dy); + + +/** + * Check if layout box is a first child. + * + * \param[in] b Box to check. + * \return true iff box is first child. + */ +static inline bool box_is_first_child(struct box *b) +{ + return (b->parent == NULL || b == b->parent->children); +} + + +#endif diff --git a/content/handlers/html/box_manipulate.c b/content/handlers/html/box_manipulate.c new file mode 100644 index 0000000..0bc1c9f --- /dev/null +++ b/content/handlers/html/box_manipulate.c @@ -0,0 +1,350 @@ +/* + * Copyright 2005-2007 James Bursa <bursa(a)users.sourceforge.net> + * Copyright 2003 Phil Mellor <monkeyson(a)users.sourceforge.net> + * Copyright 2005 John M Bell <jmb202(a)ecs.soton.ac.uk> + * Copyright 2008 Michael Drake <tlsa(a)netsurf-browser.org> + * Copyright 2020 Vincent Sanders <vince(a)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 + * implementation of box tree manipulation. + */ + + +#include "utils/errors.h" +#include "utils/talloc.h" +#include "netsurf/types.h" +#include "netsurf/mouse.h" +#include "desktop/scrollbar.h" + +#include "html/box.h" +#include "html/box_manipulate.h" +#include "html/form_internal.h" +#include "html/html_internal.h" +#include "html/interaction.h" + + +/** + * Destructor for box nodes which own styles + * + * \param b The box being destroyed. + * \return 0 to allow talloc to continue destroying the tree. + */ +static int box_talloc_destructor(struct box *b) +{ + struct html_scrollbar_data *data; + + if ((b->flags & STYLE_OWNED) && b->style != NULL) { + css_computed_style_destroy(b->style); + b->style = NULL; + } + + if (b->styles != NULL) { + css_select_results_destroy(b->styles); + b->styles = NULL; + } + + if (b->href != NULL) + nsurl_unref(b->href); + + if (b->id != NULL) { + lwc_string_unref(b->id); + } + + if (b->node != NULL) { + dom_node_unref(b->node); + } + + if (b->scroll_x != NULL) { + data = scrollbar_get_data(b->scroll_x); + scrollbar_destroy(b->scroll_x); + free(data); + } + + if (b->scroll_y != NULL) { + data = scrollbar_get_data(b->scroll_y); + scrollbar_destroy(b->scroll_y); + free(data); + } + + return 0; +} + + +/* Exported function documented in html/box.h */ +struct box * +box_create(css_select_results *styles, + css_computed_style *style, + bool style_owned, + nsurl *href, + const char *target, + const char *title, + lwc_string *id, + void *context) +{ + unsigned int i; + struct box *box; + + box = talloc(context, struct box); + if (!box) { + return 0; + } + + talloc_set_destructor(box, box_talloc_destructor); + + box->type = BOX_INLINE; + box->flags = 0; + box->flags = style_owned ? (box->flags | STYLE_OWNED) : box->flags; + box->styles = styles; + box->style = style; + box->x = box->y = 0; + box->width = UNKNOWN_WIDTH; + box->height = 0; + box->descendant_x0 = box->descendant_y0 = 0; + box->descendant_x1 = box->descendant_y1 = 0; + for (i = 0; i != 4; i++) + box->margin[i] = box->padding[i] = box->border[i].width = 0; + box->scroll_x = box->scroll_y = NULL; + box->min_width = 0; + box->max_width = UNKNOWN_MAX_WIDTH; + box->byte_offset = 0; + box->text = NULL; + box->length = 0; + box->space = 0; + box->href = (href == NULL) ? NULL : nsurl_ref(href); + box->target = target; + box->title = title; + box->columns = 1; + box->rows = 1; + box->start_column = 0; + box->next = NULL; + box->prev = NULL; + box->children = NULL; + box->last = NULL; + box->parent = NULL; + box->inline_end = NULL; + box->float_children = NULL; + box->float_container = NULL; + box->next_float = NULL; + box->cached_place_below_level = 0; + box->list_marker = NULL; + box->col = NULL; + box->gadget = NULL; + box->usemap = NULL; + box->id = id; + box->background = NULL; + box->object = NULL; + box->object_params = NULL; + box->iframe = NULL; + box->node = NULL; + + return box; +} + + +/* Exported function documented in html/box.h */ +void box_add_child(struct box *parent, struct box *child) +{ + assert(parent); + assert(child); + + if (parent->children != 0) { /* has children already */ + parent->last->next = child; + child->prev = parent->last; + } else { /* this is the first child */ + parent->children = child; + child->prev = 0; + } + + parent->last = child; + child->parent = parent; +} + + +/* Exported function documented in html/box.h */ +void box_insert_sibling(struct box *box, struct box *new_box) +{ + new_box->parent = box->parent; + new_box->prev = box; + new_box->next = box->next; + box->next = new_box; + if (new_box->next) + new_box->next->prev = new_box; + else if (new_box->parent) + new_box->parent->last = new_box; +} + + +/* Exported function documented in html/box.h */ +void box_unlink_and_free(struct box *box) +{ + struct box *parent = box->parent; + struct box *next = box->next; + struct box *prev = box->prev; + + if (parent) { + if (parent->children == box) + parent->children = next; + if (parent->last == box) + parent->last = next ? next : prev; + } + + if (prev) + prev->next = next; + if (next) + next->prev = prev; + + box_free(box); +} + + +/* Exported function documented in html/box.h */ +void box_free(struct box *box) +{ + struct box *child, *next; + + /* free children first */ + for (child = box->children; child; child = next) { + next = child->next; + box_free(child); + } + + /* last this box */ + box_free_box(box); +} + + +/* Exported function documented in html/box.h */ +void box_free_box(struct box *box) +{ + if (!(box->flags & CLONE)) { + if (box->gadget) + form_free_control(box->gadget); + if (box->scroll_x != NULL) + scrollbar_destroy(box->scroll_x); + if (box->scroll_y != NULL) + scrollbar_destroy(box->scroll_y); + if (box->styles != NULL) + css_select_results_destroy(box->styles); + } + + talloc_free(box); +} + + +/* exported interface documented in html/box.h */ +nserror +box_handle_scrollbars(struct content *c, + struct box *box, + bool bottom, + bool right) +{ + struct html_scrollbar_data *data; + int visible_width, visible_height; + int full_width, full_height; + nserror res; + + if (!bottom && box->scroll_x != NULL) { + data = scrollbar_get_data(box->scroll_x); + scrollbar_destroy(box->scroll_x); + free(data); + box->scroll_x = NULL; + } + + if (!right && box->scroll_y != NULL) { + data = scrollbar_get_data(box->scroll_y); + scrollbar_destroy(box->scroll_y); + free(data); + box->scroll_y = NULL; + } + + if (!bottom && !right) { + return NSERROR_OK; + } + + visible_width = box->width + box->padding[RIGHT] + box->padding[LEFT]; + visible_height = box->height + box->padding[TOP] + box->padding[BOTTOM]; + + full_width = ((box->descendant_x1 - box->border[RIGHT].width) > + visible_width) ? + box->descendant_x1 + box->padding[RIGHT] : + visible_width; + full_height = ((box->descendant_y1 - box->border[BOTTOM].width) > + visible_height) ? + box->descendant_y1 + box->padding[BOTTOM] : + visible_height; + + if (right) { + if (box->scroll_y == NULL) { + data = malloc(sizeof(struct html_scrollbar_data)); + if (data == NULL) { + return NSERROR_NOMEM; + } + data->c = c; + data->box = box; + res = scrollbar_create(false, + visible_height, + full_height, + visible_height, + data, + html_overflow_scroll_callback, + &(box->scroll_y)); + if (res != NSERROR_OK) { + return res; + } + } else { + scrollbar_set_extents(box->scroll_y, + visible_height, + visible_height, + full_height); + } + } + if (bottom) { + if (box->scroll_x == NULL) { + data = malloc(sizeof(struct html_scrollbar_data)); + if (data == NULL) { + return NSERROR_OK; + } + data->c = c; + data->box = box; + res = scrollbar_create(true, + visible_width - (right ? SCROLLBAR_WIDTH : 0), + full_width, + visible_width, + data, + html_overflow_scroll_callback, + &box->scroll_x); + if (res != NSERROR_OK) { + return res; + } + } else { + scrollbar_set_extents(box->scroll_x, + visible_width - + (right ? SCROLLBAR_WIDTH : 0), + visible_width, full_width); + } + } + + if (right && bottom) { + scrollbar_make_pair(box->scroll_x, box->scroll_y); + } + + return NSERROR_OK; +} + + diff --git a/content/handlers/html/box_manipulate.h b/content/handlers/html/box_manipulate.h new file mode 100644 index 0000000..43a66a7 --- /dev/null +++ b/content/handlers/html/box_manipulate.h @@ -0,0 +1,106 @@ +/* + * Copyright 2005 James Bursa <bursa(a)users.sourceforge.net> + * Copyright 2003 Phil Mellor <monkeyson(a)users.sourceforge.net> + * + * 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 + * Box tree manipulation interface. + */ + +#ifndef NETSURF_HTML_BOX_MANIPULATE_H +#define NETSURF_HTML_BOX_MANIPULATE_H + + +/** + * Create a box tree node. + * + * \param styles selection results for the box, or NULL + * \param style computed style for the box (not copied), or 0 + * \param style_owned whether style is owned by this box + * \param href href for the box (copied), or 0 + * \param target target for the box (not copied), or 0 + * \param title title for the box (not copied), or 0 + * \param id id for the box (not copied), or 0 + * \param context context for allocations + * \return allocated and initialised box, or 0 on memory exhaustion + * + * styles is always owned by the box, if it is set. + * style is only owned by the box in the case of implied boxes. + */ +struct box * box_create(css_select_results *styles, css_computed_style *style, bool style_owned, struct nsurl *href, const char *target, const char *title, lwc_string *id, void *context); + + +/** + * Add a child to a box tree node. + * + * \param parent box giving birth + * \param child box to link as last child of parent + */ +void box_add_child(struct box *parent, struct box *child); + + +/** + * Insert a new box as a sibling to a box in a tree. + * + * \param box box already in tree + * \param new_box box to link into tree as next sibling + */ +void box_insert_sibling(struct box *box, struct box *new_box); + + +/** + * Unlink a box from the box tree and then free it recursively. + * + * \param box box to unlink and free recursively. + */ +void box_unlink_and_free(struct box *box); + + +/** + * Free a box tree recursively. + * + * \param box box to free recursively + * + * The box and all its children is freed. + */ +void box_free(struct box *box); + + +/** + * Free the data in a single box structure. + * + * \param box box to free + */ +void box_free_box(struct box *box); + + +/** + * Applies the given scroll setup to a box. This includes scroll + * creation/deletion as well as scroll dimension updates. + * + * \param c content in which the box is located + * \param box the box to handle the scrolls for + * \param bottom whether the horizontal scrollbar should be present + * \param right whether the vertical scrollbar should be present + * \return true on success false otherwise + */ +nserror box_handle_scrollbars(struct content *c, struct box *box, + bool bottom, bool right); + + +#endif diff --git a/content/handlers/html/box_normalise.c b/content/handlers/html/box_normalise.c index 03fe731..fbdb6cd 100644 --- a/content/handlers/html/box_normalise.c +++ b/content/handlers/html/box_normalise.c @@ -33,6 +33,7 @@ #include "css/select.h" #include "html/box.h" +#include "html/box_manipulate.h" #include "html/box_normalise.h" #include "html/html_internal.h" #include "html/table.h" diff --git a/content/handlers/html/box_normalise.h b/content/handlers/html/box_normalise.h index 60f2591..591feab 100644 --- a/content/handlers/html/box_normalise.h +++ b/content/handlers/html/box_normalise.h @@ -19,6 +19,21 @@ /** * \file * HTML Box tree normalise interface. + * + * A box tree is "normalized" if the following is satisfied: + * \code + * parent permitted child nodes + * BLOCK, INLINE_BLOCK BLOCK, INLINE_CONTAINER, TABLE + * INLINE_CONTAINER INLINE, INLINE_BLOCK, FLOAT_LEFT, FLOAT_RIGHT, BR, TEXT, + * INLINE_END + * INLINE none + * TABLE at least 1 TABLE_ROW_GROUP + * TABLE_ROW_GROUP at least 1 TABLE_ROW + * TABLE_ROW at least 1 TABLE_CELL + * TABLE_CELL BLOCK, INLINE_CONTAINER, TABLE (same as BLOCK) + * FLOAT_(LEFT|RIGHT) exactly 1 BLOCK or TABLE + * \endcode + * */ #ifndef NETSURF_HTML_BOX_NORMALISE_H diff --git a/content/handlers/html/box_construct.c b/content/handlers/html/box_special.c similarity index 56% copy from content/handlers/html/box_construct.c copy to content/handlers/html/box_special.c index a833302..38031ce 100644 --- a/content/handlers/html/box_construct.c +++ b/content/handlers/html/box_special.c @@ -4,6 +4,7 @@ * Copyright 2005 John M Bell <jmb202(a)ecs.soton.ac.uk> * Copyright 2006 Richard Wilson <info(a)tinct.net> * Copyright 2008 Michael Drake <tlsa(a)netsurf-browser.org> + * Copyright 2020 Vincent Sanders <vince(a)netsurf-browser.org> * * This file is part of NetSurf, http://www.netsurf-browser.org/ * @@ -22,17 +23,12 @@ /** * \file - * Implementation of conversion from DOM tree to box tree. + * Implementation of special element handling conversion. */ -#include <assert.h> -#include <stdio.h> #include <stdbool.h> -#include <stdlib.h> -#include <string.h> -#include <strings.h> +#include <dom/dom.h> -#include "utils/config.h" #include "utils/nsoption.h" #include "utils/corestrings.h" #include "utils/log.h" @@ -40,91 +36,22 @@ #include "utils/talloc.h" #include "utils/string.h" #include "utils/ascii.h" -#include "netsurf/css.h" -#include "netsurf/misc.h" #include "netsurf/plot_style.h" -#include "content/content_protected.h" #include "css/hints.h" -#include "css/select.h" -#include "css/utils.h" -#include "desktop/gui_internal.h" +#include "desktop/frame_types.h" #include "html/html.h" +#include "html/html_internal.h" #include "html/box.h" +#include "html/box_manipulate.h" #include "html/box_construct.h" -#include "html/box_normalise.h" +#include "html/box_special.h" #include "html/box_textarea.h" #include "html/form_internal.h" -#include "html/html_internal.h" - -/** - * Context for box tree construction - */ -struct box_construct_ctx { - html_content *content; /**< Content we're constructing for */ - - dom_node *n; /**< Current node to process */ - - struct box *root_box; /**< Root box in the tree */ - - box_construct_complete_cb cb; /**< Callback to invoke on completion */ - int *bctx; /**< talloc context */ -}; - -/** - * Transient properties for construction of current node - */ -struct box_construct_props { - /** Style from which to inherit, or NULL if none */ - const css_computed_style *parent_style; - /** Current link target, or NULL if none */ - nsurl *href; - /** Current frame target, or NULL if none */ - const char *target; - /** Current title attribute, or NULL if none */ - const char *title; - /** Identity of the current block-level container */ - struct box *containing_block; - /** Current container for inlines, or NULL if none - * \note If non-NULL, will be the last child of containing_block */ - struct box *inline_container; - /** Whether the current node is the root of the DOM tree */ - bool node_is_root; -}; static const content_type image_types = CONTENT_IMAGE; -/* the strings are not important, since we just compare the pointers */ -const char *TARGET_SELF = "_self"; -const char *TARGET_PARENT = "_parent"; -const char *TARGET_TOP = "_top"; -const char *TARGET_BLANK = "_blank"; - -/** - * mapping from CSS display to box type this table must be in sync - * with libcss' css_display enum - */ -static const box_type box_map[] = { - 0, /* CSS_DISPLAY_INHERIT, */ - BOX_INLINE, /* CSS_DISPLAY_INLINE, */ - BOX_BLOCK, /* CSS_DISPLAY_BLOCK, */ - BOX_BLOCK, /* CSS_DISPLAY_LIST_ITEM, */ - BOX_INLINE, /* CSS_DISPLAY_RUN_IN, */ - BOX_INLINE_BLOCK, /* CSS_DISPLAY_INLINE_BLOCK, */ - BOX_TABLE, /* CSS_DISPLAY_TABLE, */ - BOX_TABLE, /* CSS_DISPLAY_INLINE_TABLE, */ - BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_ROW_GROUP, */ - BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_HEADER_GROUP, */ - BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_FOOTER_GROUP, */ - BOX_TABLE_ROW, /* CSS_DISPLAY_TABLE_ROW, */ - BOX_NONE, /* CSS_DISPLAY_TABLE_COLUMN_GROUP, */ - BOX_NONE, /* CSS_DISPLAY_TABLE_COLUMN, */ - BOX_TABLE_CELL, /* CSS_DISPLAY_TABLE_CELL, */ - BOX_INLINE, /* CSS_DISPLAY_TABLE_CAPTION, */ - BOX_NONE /* CSS_DISPLAY_NONE */ -}; - /** * determine if a box is the root node @@ -1904,350 +1831,8 @@ static bool box_textarea(dom_node *n, */ -/** - * Extract transient construction properties - * - * \param n Current DOM node to convert - * \param props Property object to populate - */ -static void -box_extract_properties(dom_node *n, struct box_construct_props *props) -{ - memset(props, 0, sizeof(*props)); - - props->node_is_root = box_is_root(n); - - /* Extract properties from containing DOM node */ - if (props->node_is_root == false) { - dom_node *current_node = n; - dom_node *parent_node = NULL; - struct box *parent_box; - dom_exception err; - - /* Find ancestor node containing parent box */ - while (true) { - err = dom_node_get_parent_node(current_node, - &parent_node); - if (err != DOM_NO_ERR || parent_node == NULL) - break; - - parent_box = box_for_node(parent_node); - - if (parent_box != NULL) { - props->parent_style = parent_box->style; - props->href = parent_box->href; - props->target = parent_box->target; - props->title = parent_box->title; - - dom_node_unref(parent_node); - break; - } else { - if (current_node != n) - dom_node_unref(current_node); - current_node = parent_node; - parent_node = NULL; - } - } - - /* Find containing block (may be parent) */ - while (true) { - struct box *b; - - err = dom_node_get_parent_node(current_node, - &parent_node); - if (err != DOM_NO_ERR || parent_node == NULL) { - if (current_node != n) - dom_node_unref(current_node); - break; - } - - if (current_node != n) - dom_node_unref(current_node); - - b = box_for_node(parent_node); - - /* Children of nodes that created an inline box - * will generate boxes which are attached as - * _siblings_ of the box generated for their - * parent node. Note, however, that we'll still - * use the parent node's styling as the parent - * style, above. */ - if (b != NULL && b->type != BOX_INLINE && - b->type != BOX_BR) { - props->containing_block = b; - - dom_node_unref(parent_node); - break; - } else { - current_node = parent_node; - parent_node = NULL; - } - } - } - - /* Compute current inline container, if any */ - if (props->containing_block != NULL && - props->containing_block->last != NULL && - props->containing_block->last->type == - BOX_INLINE_CONTAINER) - props->inline_container = props->containing_block->last; -} - - -/** - * Get the style for an element. - * - * \param c content of type CONTENT_HTML that is being processed - * \param parent_style style at this point in xml tree, or NULL for root - * \param root_style root node's style, or NULL for root - * \param n node in xml tree - * \return the new style, or NULL on memory exhaustion - */ -static css_select_results * -box_get_style(html_content *c, - const css_computed_style *parent_style, - const css_computed_style *root_style, - dom_node *n) -{ - dom_string *s; - dom_exception err; - css_stylesheet *inline_style = NULL; - css_select_results *styles; - nscss_select_ctx ctx; - - /* Firstly, construct inline stylesheet, if any */ - err = dom_element_get_attribute(n, corestring_dom_style, &s); - if (err != DOM_NO_ERR) - return NULL; - - if (s != NULL) { - inline_style = nscss_create_inline_style( - (const uint8_t *) dom_string_data(s), - dom_string_byte_length(s), - c->encoding, - nsurl_access(c->base_url), - c->quirks != DOM_DOCUMENT_QUIRKS_MODE_NONE); - - dom_string_unref(s); - - if (inline_style == NULL) - return NULL; - } - - /* Populate selection context */ - ctx.ctx = c->select_ctx; - ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); - ctx.base_url = c->base_url; - ctx.universal = c->universal; - ctx.root_style = root_style; - ctx.parent_style = parent_style; - - /* Select style for element */ - styles = nscss_get_style(&ctx, n, &c->media, inline_style); - - /* No longer need inline style */ - if (inline_style != NULL) - css_stylesheet_destroy(inline_style); - - return styles; -} - - -/** - * Construct the box required for a generated element. - * - * \param n XML node of type XML_ELEMENT_NODE - * \param content Content of type CONTENT_HTML that is being processed - * \param box Box which may have generated content - * \param style Complete computed style for pseudo element, or NULL - * - * \todo This is currently incomplete. It just does enough to support - * the clearfix hack. (http://www.positioniseverything.net/easyclearing.html ) - */ -static void -box_construct_generate(dom_node *n, - html_content *content, - struct box *box, - const css_computed_style *style) -{ - struct box *gen = NULL; - enum css_display_e computed_display; - const css_computed_content_item *c_item; - - /* Nothing to generate if the parent box is not a block */ - if (box->type != BOX_BLOCK) - return; - - /* To determine if an element has a pseudo element, we select - * for it and test to see if the returned style's content - * property is set to normal. */ - if (style == NULL || - css_computed_content(style, &c_item) == - CSS_CONTENT_NORMAL) { - /* No pseudo element */ - return; - } - - /* create box for this element */ - computed_display = ns_computed_display(style, box_is_root(n)); - if (computed_display == CSS_DISPLAY_BLOCK || - computed_display == CSS_DISPLAY_TABLE) { - /* currently only support block level boxes */ - - /** \todo Not wise to drop const from the computed style */ - gen = box_create(NULL, (css_computed_style *) style, - false, NULL, NULL, NULL, NULL, content->bctx); - if (gen == NULL) { - return; - } - - /* set box type from computed display */ - gen->type = box_map[ns_computed_display( - style, box_is_root(n))]; - - box_add_child(box, gen); - } -} - - -/** - * Construct a list marker box - * - * \param box Box to attach marker to - * \param title Current title attribute - * \param ctx Box construction context - * \param parent Current block-level container - * \return true on success, false on memory exhaustion - */ -static bool -box_construct_marker(struct box *box, - const char *title, - struct box_construct_ctx *ctx, - struct box *parent) -{ - lwc_string *image_uri; - struct box *marker; - - marker = box_create(NULL, box->style, false, NULL, NULL, title, - NULL, ctx->bctx); - if (marker == false) - return false; - - marker->type = BOX_BLOCK; - - /** \todo marker content (list-style-type) */ - switch (css_computed_list_style_type(box->style)) { - case CSS_LIST_STYLE_TYPE_DISC: - /* 2022 BULLET */ - marker->text = (char *) "\342\200\242"; - marker->length = 3; - break; - case CSS_LIST_STYLE_TYPE_CIRCLE: - /* 25CB WHITE CIRCLE */ - marker->text = (char *) "\342\227\213"; - marker->length = 3; - break; - case CSS_LIST_STYLE_TYPE_SQUARE: - /* 25AA BLACK SMALL SQUARE */ - marker->text = (char *) "\342\226\252"; - marker->length = 3; - break; - case CSS_LIST_STYLE_TYPE_DECIMAL: - case CSS_LIST_STYLE_TYPE_LOWER_ALPHA: - case CSS_LIST_STYLE_TYPE_LOWER_ROMAN: - case CSS_LIST_STYLE_TYPE_UPPER_ALPHA: - case CSS_LIST_STYLE_TYPE_UPPER_ROMAN: - default: - if (parent->last) { - struct box *last = parent->last; - - /* Drill down into last child of parent - * to find the list marker (if any) - * - * Floated list boxes end up as: - * - * parent - * BOX_INLINE_CONTAINER - * BOX_FLOAT_{LEFT,RIGHT} - * BOX_BLOCK <-- list box - * ... - */ - while (last != NULL && last->list_marker == NULL) { - struct box *last_inner = last; - - while (last_inner != NULL) { - if (last_inner->list_marker != NULL) - break; - if (last_inner->type == - BOX_INLINE_CONTAINER || - last_inner->type == - BOX_FLOAT_LEFT || - last_inner->type == - BOX_FLOAT_RIGHT) { - last_inner = last_inner->last; - } else { - last_inner = NULL; - } - } - if (last_inner != NULL) { - last = last_inner; - } else { - last = last->prev; - } - } - - if (last && last->list_marker) { - marker->rows = last->list_marker->rows + 1; - } - } - - marker->text = talloc_array(ctx->bctx, char, 20); - if (marker->text == NULL) - return false; - - snprintf(marker->text, 20, "%u.", marker->rows); - marker->length = strlen(marker->text); - break; - case CSS_LIST_STYLE_TYPE_NONE: - marker->text = 0; - marker->length = 0; - break; - } - - if (css_computed_list_style_image(box->style, &image_uri) == CSS_LIST_STYLE_IMAGE_URI && - (image_uri != NULL) && - (nsoption_bool(foreground_images) == true)) { - nsurl *url; - nserror error; - - /* TODO: we get a url out of libcss as a lwc string, but - * earlier we already had it as a nsurl after we - * nsurl_joined it. Can this be improved? - * For now, just making another nsurl. */ - error = nsurl_create(lwc_string_data(image_uri), &url); - if (error != NSERROR_OK) - return false; - - if (html_fetch_object(ctx->content, url, marker, image_types, - ctx->content->base.available_width, 1000, false) == - false) { - nsurl_unref(url); - return false; - } - nsurl_unref(url); - } - - box->list_marker = marker; - marker->parent = box; - - return true; -} - - -/** - * call an elements special handler - */ -static bool +/* exported interface documented in html/box_special.h */ +bool convert_special_elements(dom_node *node, html_content *content, struct box *box, @@ -2329,976 +1914,3 @@ convert_special_elements(dom_node *node, return res; } - - -/** - * Construct the box tree for an XML element. - * - * \param ctx Tree construction context - * \param convert_children Whether to convert children - * \return true on success, false on memory exhaustion - */ -static bool -box_construct_element(struct box_construct_ctx *ctx, bool *convert_children) -{ - dom_string *title0, *s; - lwc_string *id = NULL; - struct box *box = NULL, *old_box; - css_select_results *styles = NULL; - lwc_string *bgimage_uri; - dom_exception err; - struct box_construct_props props; - const css_computed_style *root_style = NULL; - - assert(ctx->n != NULL); - - box_extract_properties(ctx->n, &props); - - if (props.containing_block != NULL) { - /* In case the containing block is a pre block, we clear - * the PRE_STRIP flag since it is not used if we follow - * the pre with a tag */ - props.containing_block->flags &= ~PRE_STRIP; - } - - if (props.node_is_root == false) { - root_style = ctx->root_box->style; - } - - styles = box_get_style(ctx->content, props.parent_style, root_style, - ctx->n); - if (styles == NULL) - return false; - - /* Extract title attribute, if present */ - err = dom_element_get_attribute(ctx->n, corestring_dom_title, &title0); - if (err != DOM_NO_ERR) - return false; - - if (title0 != NULL) { - char *t = squash_whitespace(dom_string_data(title0)); - - dom_string_unref(title0); - - if (t == NULL) - return false; - - props.title = talloc_strdup(ctx->bctx, t); - - free(t); - - if (props.title == NULL) - return false; - } - - /* Extract id attribute, if present */ - err = dom_element_get_attribute(ctx->n, corestring_dom_id, &s); - if (err != DOM_NO_ERR) - return false; - - if (s != NULL) { - err = dom_string_intern(s, &id); - if (err != DOM_NO_ERR) - id = NULL; - - dom_string_unref(s); - } - - box = box_create(styles, styles->styles[CSS_PSEUDO_ELEMENT_NONE], false, - props.href, props.target, props.title, id, - ctx->bctx); - if (box == NULL) - return false; - - /* If this is the root box, add it to the context */ - if (props.node_is_root) - ctx->root_box = box; - - /* Deal with colspan/rowspan */ - err = dom_element_get_attribute(ctx->n, corestring_dom_colspan, &s); - if (err != DOM_NO_ERR) - return false; - - if (s != NULL) { - const char *val = dom_string_data(s); - - if ('0' <= val[0] && val[0] <= '9') - box->columns = strtol(val, NULL, 10); - - dom_string_unref(s); - } - - err = dom_element_get_attribute(ctx->n, corestring_dom_rowspan, &s); - if (err != DOM_NO_ERR) - return false; - - if (s != NULL) { - const char *val = dom_string_data(s); - - if ('0' <= val[0] && val[0] <= '9') - box->rows = strtol(val, NULL, 10); - - dom_string_unref(s); - } - - /* Set box type from computed display */ - if ((css_computed_position(box->style) == CSS_POSITION_ABSOLUTE || - css_computed_position(box->style) == - CSS_POSITION_FIXED) && - (ns_computed_display_static(box->style) == - CSS_DISPLAY_INLINE || - ns_computed_display_static(box->style) == - CSS_DISPLAY_INLINE_BLOCK || - ns_computed_display_static(box->style) == - CSS_DISPLAY_INLINE_TABLE)) { - /* Special case for absolute positioning: make absolute inlines - * into inline block so that the boxes are constructed in an - * inline container as if they were not absolutely positioned. - * Layout expects and handles this. */ - box->type = box_map[CSS_DISPLAY_INLINE_BLOCK]; - } else if (props.node_is_root) { - /* Special case for root element: force it to BLOCK, or the - * rest of the layout will break. */ - box->type = BOX_BLOCK; - } else { - /* Normal mapping */ - box->type = box_map[ns_computed_display(box->style, - props.node_is_root)]; - } - - if (convert_special_elements(ctx->n, - ctx->content, - box, - convert_children) == false) { - return false; - } - - /* Handle the :before pseudo element */ - if (!(box->flags & IS_REPLACED)) { - box_construct_generate(ctx->n, ctx->content, box, - box->styles->styles[CSS_PSEUDO_ELEMENT_BEFORE]); - } - - if (box->type == BOX_NONE || - (ns_computed_display(box->style, - props.node_is_root) == CSS_DISPLAY_NONE && - props.node_is_root == false)) { - css_select_results_destroy(styles); - box->styles = NULL; - box->style = NULL; - - /* Invalidate associated gadget, if any */ - if (box->gadget != NULL) { - box->gadget->box = NULL; - box->gadget = NULL; - } - - /* Can't do this, because the lifetimes of boxes and gadgets - * are inextricably linked. Fortunately, talloc will save us - * (for now) */ - /* box_free_box(box); */ - - *convert_children = false; - - return true; - } - - /* Attach DOM node to box */ - err = dom_node_set_user_data(ctx->n, - corestring_dom___ns_key_box_node_data, box, NULL, - (void *) &old_box); - if (err != DOM_NO_ERR) - return false; - - /* Attach box to DOM node */ - box->node = dom_node_ref(ctx->n); - - if (props.inline_container == NULL && - (box->type == BOX_INLINE || - box->type == BOX_BR || - box->type == BOX_INLINE_BLOCK || - css_computed_float(box->style) == CSS_FLOAT_LEFT || - css_computed_float(box->style) == CSS_FLOAT_RIGHT) && - props.node_is_root == false) { - /* Found an inline child of a block without a current container - * (i.e. this box is the first child of its parent, or was - * preceded by block-level siblings) */ - assert(props.containing_block != NULL && - "Box must have containing block."); - - props.inline_container = box_create(NULL, NULL, false, NULL, - NULL, NULL, NULL, ctx->bctx); - if (props.inline_container == NULL) - return false; - - props.inline_container->type = BOX_INLINE_CONTAINER; - - box_add_child(props.containing_block, props.inline_container); - } - - /* Kick off fetch for any background image */ - if (css_computed_background_image(box->style, &bgimage_uri) == - CSS_BACKGROUND_IMAGE_IMAGE && bgimage_uri != NULL && - nsoption_bool(background_images) == true) { - nsurl *url; - nserror error; - - /* TODO: we get a url out of libcss as a lwc string, but - * earlier we already had it as a nsurl after we - * nsurl_joined it. Can this be improved? - * For now, just making another nsurl. */ - error = nsurl_create(lwc_string_data(bgimage_uri), &url); - if (error == NSERROR_OK) { - /* Fetch image if we got a valid URL */ - if (html_fetch_object(ctx->content, url, box, - image_types, - ctx->content->base.available_width, - 1000, true) == false) { - nsurl_unref(url); - return false; - } - nsurl_unref(url); - } - } - - if (*convert_children) - box->flags |= CONVERT_CHILDREN; - - if (box->type == BOX_INLINE || box->type == BOX_BR || - box->type == BOX_INLINE_BLOCK) { - /* Inline container must exist, as we'll have - * created it above if it didn't */ - assert(props.inline_container != NULL); - - box_add_child(props.inline_container, box); - } else { - if (ns_computed_display(box->style, props.node_is_root) == - CSS_DISPLAY_LIST_ITEM) { - /* List item: compute marker */ - if (box_construct_marker(box, props.title, ctx, - props.containing_block) == false) - return false; - } - - if (props.node_is_root == false && - (css_computed_float(box->style) == - CSS_FLOAT_LEFT || - css_computed_float(box->style) == - CSS_FLOAT_RIGHT)) { - /* Float: insert a float between the parent and box. */ - struct box *flt = box_create(NULL, NULL, false, - props.href, props.target, props.title, - NULL, ctx->bctx); - if (flt == NULL) - return false; - - if (css_computed_float(box->style) == CSS_FLOAT_LEFT) - flt->type = BOX_FLOAT_LEFT; - else - flt->type = BOX_FLOAT_RIGHT; - - box_add_child(props.inline_container, flt); - box_add_child(flt, box); - } else { - /* Non-floated block-level box: add to containing block - * if there is one. If we're the root box, then there - * won't be. */ - if (props.containing_block != NULL) - box_add_child(props.containing_block, box); - } - } - - return true; -} - - -/** - * Complete construction of the box tree for an element. - * - * \param n DOM node to construct for - * \param content Containing document - * - * This will be called after all children of an element have been processed - */ -static void box_construct_element_after(dom_node *n, html_content *content) -{ - struct box_construct_props props; - struct box *box = box_for_node(n); - - assert(box != NULL); - - box_extract_properties(n, &props); - - if (box->type == BOX_INLINE || box->type == BOX_BR) { - /* Insert INLINE_END into containing block */ - struct box *inline_end; - bool has_children; - dom_exception err; - - err = dom_node_has_child_nodes(n, &has_children); - if (err != DOM_NO_ERR) - return; - - if (has_children == false || - (box->flags & CONVERT_CHILDREN) == 0) { - /* No children, or didn't want children converted */ - return; - } - - if (props.inline_container == NULL) { - /* Create inline container if we don't have one */ - props.inline_container = box_create(NULL, NULL, false, - NULL, NULL, NULL, NULL, content->bctx); - if (props.inline_container == NULL) - return; - - props.inline_container->type = BOX_INLINE_CONTAINER; - - box_add_child(props.containing_block, - props.inline_container); - } - - inline_end = box_create(NULL, box->style, false, - box->href, box->target, box->title, - box->id == NULL ? NULL : - lwc_string_ref(box->id), content->bctx); - if (inline_end != NULL) { - inline_end->type = BOX_INLINE_END; - - assert(props.inline_container != NULL); - - box_add_child(props.inline_container, inline_end); - - box->inline_end = inline_end; - inline_end->inline_end = box; - } - } else if (!(box->flags & IS_REPLACED)) { - /* Handle the :after pseudo element */ - box_construct_generate(n, content, box, - box->styles->styles[CSS_PSEUDO_ELEMENT_AFTER]); - } -} - - -/** - * Find the next node in the DOM tree, completing element construction - * where appropriate. - * - * \param n Current node - * \param content Containing content - * \param convert_children Whether to consider children of \a n - * \return Next node to process, or NULL if complete - * - * \note \a n will be unreferenced - */ -static dom_node * -next_node(dom_node *n, html_content *content, bool convert_children) -{ - dom_node *next = NULL; - bool has_children; - dom_exception err; - - err = dom_node_has_child_nodes(n, &has_children); - if (err != DOM_NO_ERR) { - dom_node_unref(n); - return NULL; - } - - if (convert_children && has_children) { - err = dom_node_get_first_child(n, &next); - if (err != DOM_NO_ERR) { - dom_node_unref(n); - return NULL; - } - dom_node_unref(n); - } else { - err = dom_node_get_next_sibling(n, &next); - if (err != DOM_NO_ERR) { - dom_node_unref(n); - return NULL; - } - - if (next != NULL) { - if (box_for_node(n) != NULL) - box_construct_element_after(n, content); - dom_node_unref(n); - } else { - if (box_for_node(n) != NULL) - box_construct_element_after(n, content); - - while (box_is_root(n) == false) { - dom_node *parent = NULL; - dom_node *parent_next = NULL; - - err = dom_node_get_parent_node(n, &parent); - if (err != DOM_NO_ERR) { - dom_node_unref(n); - return NULL; - } - - assert(parent != NULL); - - err = dom_node_get_next_sibling(parent, - &parent_next); - if (err != DOM_NO_ERR) { - dom_node_unref(parent); - dom_node_unref(n); - return NULL; - } - - if (parent_next != NULL) { - dom_node_unref(parent_next); - dom_node_unref(parent); - break; - } - - dom_node_unref(n); - n = parent; - parent = NULL; - - if (box_for_node(n) != NULL) { - box_construct_element_after( - n, content); - } - } - - if (box_is_root(n) == false) { - dom_node *parent = NULL; - - err = dom_node_get_parent_node(n, &parent); - if (err != DOM_NO_ERR) { - dom_node_unref(n); - return NULL; - } - - assert(parent != NULL); - - err = dom_node_get_next_sibling(parent, &next); - if (err != DOM_NO_ERR) { - dom_node_unref(parent); - dom_node_unref(n); - return NULL; - } - - if (box_for_node(parent) != NULL) { - box_construct_element_after(parent, - content); - } - - dom_node_unref(parent); - } - - dom_node_unref(n); - } - } - - return next; -} - - -/** - * Apply the CSS text-transform property to given text for its ASCII chars. - * - * \param s string to transform - * \param len length of s - * \param tt transform type - */ -static void -box_text_transform(char *s, unsigned int len, enum css_text_transform_e tt) -{ - unsigned int i; - if (len == 0) - return; - switch (tt) { - case CSS_TEXT_TRANSFORM_UPPERCASE: - for (i = 0; i < len; ++i) - if ((unsigned char) s[i] < 0x80) - s[i] = toupper(s[i]); - break; - case CSS_TEXT_TRANSFORM_LOWERCASE: - for (i = 0; i < len; ++i) - if ((unsigned char) s[i] < 0x80) - s[i] = tolower(s[i]); - break; - case CSS_TEXT_TRANSFORM_CAPITALIZE: - if ((unsigned char) s[0] < 0x80) - s[0] = toupper(s[0]); - for (i = 1; i < len; ++i) - if ((unsigned char) s[i] < 0x80 && - isspace(s[i - 1])) - s[i] = toupper(s[i]); - break; - default: - break; - } -} - - -/** - * Construct the box tree for an XML text node. - * - * \param ctx Tree construction context - * \return true on success, false on memory exhaustion - */ -static bool box_construct_text(struct box_construct_ctx *ctx) -{ - struct box_construct_props props; - struct box *box = NULL; - dom_string *content; - dom_exception err; - - assert(ctx->n != NULL); - - box_extract_properties(ctx->n, &props); - - assert(props.containing_block != NULL); - - err = dom_characterdata_get_data(ctx->n, &content); - if (err != DOM_NO_ERR || content == NULL) - return false; - - if (css_computed_white_space(props.parent_style) == - CSS_WHITE_SPACE_NORMAL || - css_computed_white_space(props.parent_style) == - CSS_WHITE_SPACE_NOWRAP) { - char *text; - - text = squash_whitespace(dom_string_data(content)); - - dom_string_unref(content); - - if (text == NULL) - return false; - - /* if the text is just a space, combine it with the preceding - * text node, if any */ - if (text[0] == ' ' && text[1] == 0) { - if (props.inline_container != NULL) { - assert(props.inline_container->last != NULL); - - props.inline_container->last->space = - UNKNOWN_WIDTH; - } - - free(text); - - return true; - } - - if (props.inline_container == NULL) { - /* Child of a block without a current container - * (i.e. this box is the first child of its parent, or - * was preceded by block-level siblings) */ - props.inline_container = box_create(NULL, NULL, false, - NULL, NULL, NULL, NULL, ctx->bctx); - if (props.inline_container == NULL) { - free(text); - return false; - } - - props.inline_container->type = BOX_INLINE_CONTAINER; - - box_add_child(props.containing_block, - props.inline_container); - } - - /** \todo Dropping const here is not clever */ - box = box_create(NULL, - (css_computed_style *) props.parent_style, - false, props.href, props.target, props.title, - NULL, ctx->bctx); - if (box == NULL) { - free(text); - return false; - } - - box->type = BOX_TEXT; - - box->text = talloc_strdup(ctx->bctx, text); - free(text); - if (box->text == NULL) - return false; - - box->length = strlen(box->text); - - /* strip ending space char off */ - if (box->length > 1 && box->text[box->length - 1] == ' ') { - box->space = UNKNOWN_WIDTH; - box->length--; - } - - if (css_computed_text_transform(props.parent_style) != - CSS_TEXT_TRANSFORM_NONE) - box_text_transform(box->text, box->length, - css_computed_text_transform( - props.parent_style)); - - box_add_child(props.inline_container, box); - - if (box->text[0] == ' ') { - box->length--; - - memmove(box->text, &box->text[1], box->length); - - if (box->prev != NULL) - box->prev->space = UNKNOWN_WIDTH; - } - } else { - /* white-space: pre */ - char *text; - size_t text_len = dom_string_byte_length(content); - size_t i; - char *current; - enum css_white_space_e white_space = - css_computed_white_space(props.parent_style); - - /* note: pre-wrap/pre-line are unimplemented */ - assert(white_space == CSS_WHITE_SPACE_PRE || - white_space == CSS_WHITE_SPACE_PRE_LINE || - white_space == CSS_WHITE_SPACE_PRE_WRAP); - - text = malloc(text_len + 1); - dom_string_unref(content); - - if (text == NULL) - return false; - - memcpy(text, dom_string_data(content), text_len); - text[text_len] = '\0'; - - /* TODO: Handle tabs properly */ - for (i = 0; i < text_len; i++) - if (text[i] == '\t') - text[i] = ' '; - - if (css_computed_text_transform(props.parent_style) != - CSS_TEXT_TRANSFORM_NONE) - box_text_transform(text, strlen(text), - css_computed_text_transform( - props.parent_style)); - - current = text; - - /* swallow a single leading new line */ - if (props.containing_block->flags & PRE_STRIP) { - switch (*current) { - case '\n': - current++; - break; - case '\r': - current++; - if (*current == '\n') - current++; - break; - } - props.containing_block->flags &= ~PRE_STRIP; - } - - do { - size_t len = strcspn(current, "\r\n"); - - char old = current[len]; - - current[len] = 0; - - if (props.inline_container == NULL) { - /* Child of a block without a current container - * (i.e. this box is the first child of its - * parent, or was preceded by block-level - * siblings) */ - props.inline_container = box_create(NULL, NULL, - false, NULL, NULL, NULL, NULL, - ctx->bctx); - if (props.inline_container == NULL) { - free(text); - return false; - } - - props.inline_container->type = - BOX_INLINE_CONTAINER; - - box_add_child(props.containing_block, - props.inline_container); - } - - /** \todo Dropping const isn't clever */ - box = box_create(NULL, - (css_computed_style *) props.parent_style, - false, props.href, props.target, props.title, - NULL, ctx->bctx); - if (box == NULL) { - free(text); - return false; - } - - box->type = BOX_TEXT; - - box->text = talloc_strdup(ctx->bctx, current); - if (box->text == NULL) { - free(text); - return false; - } - - box->length = strlen(box->text); - - box_add_child(props.inline_container, box); - - current[len] = old; - - current += len; - - if (current[0] != '\0') { - /* Linebreak: create new inline container */ - props.inline_container = box_create(NULL, NULL, - false, NULL, NULL, NULL, NULL, - ctx->bctx); - if (props.inline_container == NULL) { - free(text); - return false; - } - - props.inline_container->type = - BOX_INLINE_CONTAINER; - - box_add_child(props.containing_block, - props.inline_container); - - if (current[0] == '\r' && current[1] == '\n') - current += 2; - else - current++; - } - } while (*current); - - free(text); - } - - return true; -} - - -/** - * Convert an ELEMENT node to a box tree fragment, - * then schedule conversion of the next ELEMENT node - */ -static void convert_xml_to_box(struct box_construct_ctx *ctx) -{ - dom_node *next; - bool convert_children; - uint32_t num_processed = 0; - const uint32_t max_processed_before_yield = 10; - - do { - convert_children = true; - - assert(ctx->n != NULL); - - if (box_construct_element(ctx, &convert_children) == false) { - ctx->cb(ctx->content, false); - dom_node_unref(ctx->n); - free(ctx); - return; - } - - /* Find next element to process, converting text nodes as we go */ - next = next_node(ctx->n, ctx->content, convert_children); - while (next != NULL) { - dom_node_type type; - dom_exception err; - - err = dom_node_get_node_type(next, &type); - if (err != DOM_NO_ERR) { - ctx->cb(ctx->content, false); - dom_node_unref(next); - free(ctx); - return; - } - - if (type == DOM_ELEMENT_NODE) - break; - - if (type == DOM_TEXT_NODE) { - ctx->n = next; - if (box_construct_text(ctx) == false) { - ctx->cb(ctx->content, false); - dom_node_unref(ctx->n); - free(ctx); - return; - } - } - - next = next_node(next, ctx->content, true); - } - - ctx->n = next; - - if (next == NULL) { - /* Conversion complete */ - struct box root; - - memset(&root, 0, sizeof(root)); - - root.type = BOX_BLOCK; - root.children = root.last = ctx->root_box; - root.children->parent = &root; - - /** \todo Remove box_normalise_block */ - if (box_normalise_block(&root, ctx->root_box, - ctx->content) == false) { - ctx->cb(ctx->content, false); - } else { - ctx->content->layout = root.children; - ctx->content->layout->parent = NULL; - - ctx->cb(ctx->content, true); - } - - assert(ctx->n == NULL); - - free(ctx); - return; - } - } while (++num_processed < max_processed_before_yield); - - /* More work to do: schedule a continuation */ - guit->misc->schedule(0, (void *)convert_xml_to_box, ctx); -} - - -/* exported function documented in html/box_construct.h */ -nserror -dom_to_box(dom_node *n, - html_content *c, - box_construct_complete_cb cb, - void **box_conversion_context) -{ - struct box_construct_ctx *ctx; - - assert(box_conversion_context != NULL); - - if (c->bctx == NULL) { - /* create a context allocation for this box tree */ - c->bctx = talloc_zero(0, int); - if (c->bctx == NULL) { - return NSERROR_NOMEM; - } - } - - ctx = malloc(sizeof(*ctx)); - if (ctx == NULL) { - return NSERROR_NOMEM; - } - - ctx->content = c; - ctx->n = dom_node_ref(n); - ctx->root_box = NULL; - ctx->cb = cb; - ctx->bctx = c->bctx; - - *box_conversion_context = ctx; - - return guit->misc->schedule(0, (void *)convert_xml_to_box, ctx); -} - - -/* exported function documented in html/box_construct.h */ -nserror cancel_dom_to_box(void *box_conversion_context) -{ - struct box_construct_ctx *ctx = box_conversion_context; - nserror err; - - err = guit->misc->schedule(-1, (void *)convert_xml_to_box, ctx); - if (err != NSERROR_OK) { - return err; - } - - dom_node_unref(ctx->n); - free(ctx); - - return NSERROR_OK; -} - - -/* exported function documented in html/box_construct.h */ -struct box *box_for_node(dom_node *n) -{ - struct box *box = NULL; - dom_exception err; - - err = dom_node_get_user_data(n, corestring_dom___ns_key_box_node_data, - (void *) &box); - if (err != DOM_NO_ERR) - return NULL; - - return box; -} - - -/* exported function documented in html/box_construct.h */ -bool -box_extract_link(const html_content *content, - const dom_string *dsrel, - nsurl *base, - nsurl **result) -{ - char *s, *s1, *apos0 = 0, *apos1 = 0, *quot0 = 0, *quot1 = 0; - unsigned int i, j, end; - nserror error; - const char *rel; - - rel = dom_string_data(dsrel); - - s1 = s = malloc(3 * strlen(rel) + 1); - if (!s) - return false; - - /* copy to s, removing white space and control characters */ - for (i = 0; rel[i] && ascii_is_space(rel[i]); i++) - ; - for (end = strlen(rel); - (end != i) && ascii_is_space(rel[end - 1]); - end--) - ; - for (j = 0; i != end; i++) { - if ((unsigned char) rel[i] < 0x20) { - ; /* skip control characters */ - } else if (rel[i] == ' ') { - s[j++] = '%'; - s[j++] = '2'; - s[j++] = '0'; - } else { - s[j++] = rel[i]; - } - } - s[j] = 0; - - if (content->enable_scripting == false) { - /* extract first quoted string out of "javascript:" link */ - if (strncmp(s, "javascript:", 11) == 0) { - apos0 = strchr(s, '\''); - if (apos0) - apos1 = strchr(apos0 + 1, '\''); - quot0 = strchr(s, '"'); - if (quot0) - quot1 = strchr(quot0 + 1, '"'); - if (apos0 && apos1 && - (!quot0 || !quot1 || apos0 < quot0)) { - *apos1 = 0; - s1 = apos0 + 1; - } else if (quot0 && quot1) { - *quot1 = 0; - s1 = quot0 + 1; - } - } - } - - /* construct absolute URL */ - error = nsurl_join(base, s1, result); - free(s); - if (error != NSERROR_OK) { - *result = NULL; - return false; - } - - return true; -} diff --git a/desktop/gui_internal.h b/content/handlers/html/box_special.h similarity index 62% copy from desktop/gui_internal.h copy to content/handlers/html/box_special.h index c54caa4..973ab97 100644 --- a/desktop/gui_internal.h +++ b/content/handlers/html/box_special.h @@ -1,5 +1,5 @@ /* - * Copyright 2014 Vincent Sanders <vince(a)netsurf-browser.org> + * Copyright 2020 Vincent Sanders <vince(a)netsurf-browser.org> * * This file is part of NetSurf, http://www.netsurf-browser.org/ * @@ -18,20 +18,18 @@ /** * \file - * - * Interface to core interface table. - * - * \note must not be used by frontends directly. + * HTML Box tree construction special element conversion interface. */ -#ifndef _NETSURF_DESKTOP_GUI_INTERNAL_H_ -#define _NETSURF_DESKTOP_GUI_INTERNAL_H_ +#ifndef NETSURF_HTML_BOX_SPECIAL_H +#define NETSURF_HTML_BOX_SPECIAL_H -#include "desktop/gui_table.h" /** - * The global operation table. + * call an elements special conversion handler + * + * \return true if box construction should continue else false on error. */ -extern struct netsurf_table *guit; +bool convert_special_elements(dom_node *node, html_content *content, struct box *box, bool *convert_children); #endif diff --git a/content/handlers/html/box_textarea.c b/content/handlers/html/box_textarea.c index e253e16..476773f 100644 --- a/content/handlers/html/box_textarea.c +++ b/content/handlers/html/box_textarea.c @@ -33,6 +33,7 @@ #include "html/html_internal.h" #include "html/box.h" +#include "html/box_inspect.h" #include "html/box_textarea.h" #include "html/font.h" #include "html/form_internal.h" diff --git a/content/handlers/html/form.c b/content/handlers/html/form.c index fd0f2fa..86c4196 100644 --- a/content/handlers/html/form.c +++ b/content/handlers/html/form.c @@ -53,6 +53,7 @@ #include "desktop/gui_internal.h" #include "html/box.h" +#include "html/box_inspect.h" #include "html/font.h" #include "html/form_internal.h" #include "html/html.h" diff --git a/content/handlers/html/html.c b/content/handlers/html/html.c index 9b47858..01244cc 100644 --- a/content/handlers/html/html.c +++ b/content/handlers/html/html.c @@ -61,6 +61,7 @@ #include "html/interaction.h" #include "html/box.h" #include "html/box_construct.h" +#include "html/box_inspect.h" #include "html/form_internal.h" #include "html/imagemap.h" #include "html/layout.h" diff --git a/content/handlers/html/html_object.c b/content/handlers/html/html_object.c index 3a60c47..587c487 100644 --- a/content/handlers/html/html_object.c +++ b/content/handlers/html/html_object.c @@ -42,6 +42,7 @@ #include "html/html.h" #include "html/box.h" +#include "html/box_inspect.h" #include "html/html_internal.h" /* break reference loop */ diff --git a/content/handlers/html/html_redraw.c b/content/handlers/html/html_redraw.c index a60f44e..ee6fab2 100644 --- a/content/handlers/html/html_redraw.c +++ b/content/handlers/html/html_redraw.c @@ -54,6 +54,8 @@ #include "desktop/gui_internal.h" #include "html/box.h" +#include "html/box_inspect.h" +#include "html/box_manipulate.h" #include "html/font.h" #include "html/form_internal.h" #include "html/html_internal.h" diff --git a/content/handlers/html/interaction.c b/content/handlers/html/interaction.c index 7c4d54f..e4ef2f1 100644 --- a/content/handlers/html/interaction.c +++ b/content/handlers/html/interaction.c @@ -50,6 +50,7 @@ #include "html/box.h" #include "html/box_textarea.h" +#include "html/box_inspect.h" #include "html/font.h" #include "html/form_internal.h" #include "html/html_internal.h" diff --git a/content/handlers/html/layout.c b/content/handlers/html/layout.c index 611c778..128b12c 100644 --- a/content/handlers/html/layout.c +++ b/content/handlers/html/layout.c @@ -60,6 +60,7 @@ #include "html/html_save.h" #include "html/html_internal.h" #include "html/box.h" +#include "html/box_inspect.h" #include "html/font.h" #include "html/form_internal.h" #include "html/layout.h" diff --git a/content/handlers/html/search.c b/content/handlers/html/search.c index 981c80b..864fac6 100644 --- a/content/handlers/html/search.c +++ b/content/handlers/html/search.c @@ -40,6 +40,7 @@ #include "text/textplain.h" #include "html/box.h" +#include "html/box_inspect.h" #include "html/html.h" #include "html/html_internal.h" #include "html/search.h" diff --git a/desktop/frames.c b/desktop/frames.c index 1ed1145..a03f86c 100644 --- a/desktop/frames.c +++ b/desktop/frames.c @@ -35,6 +35,7 @@ #include "content/hlcache.h" #include "html/html.h" #include "html/box.h" +#include "html/box_inspect.h" #include "desktop/browser_private.h" #include "desktop/frames.h" diff --git a/desktop/scrollbar.h b/desktop/scrollbar.h index fa5e167..7965207 100644 --- a/desktop/scrollbar.h +++ b/desktop/scrollbar.h @@ -38,6 +38,7 @@ #define SCROLL_BOTTOM INT_MAX struct scrollbar; +struct redraw_context; /** * scrollbar message types diff --git a/desktop/selection.c b/desktop/selection.c index c8edda7..6c8f5d7 100644 --- a/desktop/selection.c +++ b/desktop/selection.c @@ -33,6 +33,7 @@ #include "utils/utils.h" #include "netsurf/form.h" #include "html/box.h" +#include "html/box_inspect.h" #include "html/html_internal.h" #include "html/font.h" #include "text/textplain.h" -- NetSurf Browser

2 years, 10 months

1
0
0 / 0

netsurf: branch master updated. release/3.9-609-ga64261c

by NetSurf Browser Project

Gitweb links: ...log http://git.netsurf-browser.org/netsurf.git/shortlog/a64261c3bdde79d11c869... ...commit http://git.netsurf-browser.org/netsurf.git/commit/a64261c3bdde79d11c86960... ...tree http://git.netsurf-browser.org/netsurf.git/tree/a64261c3bdde79d11c8696018... The branch, master has been updated via a64261c3bdde79d11c86960181f7b8b5255539be (commit) via c0ef8ce645d6077831877b5a8499b89c18df7bf9 (commit) from f6883d6761975c6512455f0c854b683240c7cd48 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=a64261c3bdde79d11c8... commit a64261c3bdde79d11c86960181f7b8b5255539be Author: Vincent Sanders <vince(a)kyllikki.org> Commit: Vincent Sanders <vince(a)kyllikki.org> Initial special canvas handling to not show fallback diff --git a/content/handlers/html/box_construct.c b/content/handlers/html/box_construct.c index 039da74..a833302 100644 --- a/content/handlers/html/box_construct.c +++ b/content/handlers/html/box_construct.c @@ -880,6 +880,25 @@ box_button(dom_node *n, /** + * Canvas element + */ +static bool +box_canvas(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + /* If scripting is not enabled display the contents of canvas */ + if (!content->enable_scripting) { + return true; + } + *convert_children = false; + + return true; +} + + +/** * Embedded object (not in any HTML specification: * see http://wp.netscape.com/assist/net_sites/new_html3_prop.html ) */ @@ -2260,6 +2279,10 @@ convert_special_elements(dom_node *node, res = box_button(node, content, box, convert_children); break; + case DOM_HTML_ELEMENT_TYPE_CANVAS: + res = box_canvas(node, content, box, convert_children); + break; + case DOM_HTML_ELEMENT_TYPE_EMBED: res = box_embed(node, content, box, convert_children); break; @@ -2456,9 +2479,10 @@ box_construct_element(struct box_construct_ctx *ctx, bool *convert_children) box->styles->styles[CSS_PSEUDO_ELEMENT_BEFORE]); } - if (box->type == BOX_NONE || (ns_computed_display(box->style, - props.node_is_root) == CSS_DISPLAY_NONE && - props.node_is_root == false)) { + if (box->type == BOX_NONE || + (ns_computed_display(box->style, + props.node_is_root) == CSS_DISPLAY_NONE && + props.node_is_root == false)) { css_select_results_destroy(styles); box->styles = NULL; box->style = NULL; commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=c0ef8ce645d60778318... commit c0ef8ce645d6077831877b5a8499b89c18df7bf9 Author: Vincent Sanders <vince(a)kyllikki.org> Commit: Vincent Sanders <vince(a)kyllikki.org> clean up html box, no functionality change just cosmetic split up the html box headers tidy up the documentation comments avoid forward declarations in normalisation implementation diff --git a/content/handlers/html/box.c b/content/handlers/html/box.c index 94c7487..0ad1061 100644 --- a/content/handlers/html/box.c +++ b/content/handlers/html/box.c @@ -97,26 +97,17 @@ static int box_talloc_destructor(struct box *b) return 0; } -/** - * Create a box tree node. - * - * \param styles selection results for the box, or NULL - * \param style computed style for the box (not copied), or 0 - * \param style_owned whether style is owned by this box - * \param href href for the box (copied), or 0 - * \param target target for the box (not copied), or 0 - * \param title title for the box (not copied), or 0 - * \param id id for the box (not copied), or 0 - * \param context context for allocations - * \return allocated and initialised box, or 0 on memory exhaustion - * - * styles is always owned by the box, if it is set. - * style is only owned by the box in the case of implied boxes. - */ -struct box * box_create(css_select_results *styles, css_computed_style *style, - bool style_owned, nsurl *href, const char *target, - const char *title, lwc_string *id, void *context) +/* Exported function documented in html/box.h */ +struct box * +box_create(css_select_results *styles, + css_computed_style *style, + bool style_owned, + nsurl *href, + const char *target, + const char *title, + lwc_string *id, + void *context) { unsigned int i; struct box *box; @@ -177,13 +168,8 @@ struct box * box_create(css_select_results *styles, css_computed_style *style, return box; } -/** - * Add a child to a box tree node. - * - * \param parent box giving birth - * \param child box to link as last child of parent - */ +/* Exported function documented in html/box.h */ void box_add_child(struct box *parent, struct box *child) { assert(parent); @@ -202,13 +188,7 @@ void box_add_child(struct box *parent, struct box *child) } -/** - * Insert a new box as a sibling to a box in a tree. - * - * \param box box already in tree - * \param new_box box to link into tree as next sibling - */ - +/* Exported function documented in html/box.h */ void box_insert_sibling(struct box *box, struct box *new_box) { new_box->parent = box->parent; @@ -222,12 +202,7 @@ void box_insert_sibling(struct box *box, struct box *new_box) } -/** - * Unlink a box from the box tree and then free it recursively. - * - * \param box box to unlink and free recursively. - */ - +/* Exported function documented in html/box.h */ void box_unlink_and_free(struct box *box) { struct box *parent = box->parent; @@ -250,14 +225,7 @@ void box_unlink_and_free(struct box *box) } -/** - * Free a box tree recursively. - * - * \param box box to free recursively - * - * The box and all its children is freed. - */ - +/* Exported function documented in html/box.h */ void box_free(struct box *box) { struct box *child, *next; @@ -273,12 +241,7 @@ void box_free(struct box *box) } -/** - * Free the data in a single box structure. - * - * \param box box to free - */ - +/* Exported function documented in html/box.h */ void box_free_box(struct box *box) { if (!(box->flags & CLONE)) { @@ -296,14 +259,7 @@ void box_free_box(struct box *box) } -/** - * Find the absolute coordinates of a box. - * - * \param box the box to calculate coordinates of - * \param x updated to x coordinate - * \param y updated to y coordinate - */ - +/* Exported function documented in html/box.h */ void box_coords(struct box *box, int *x, int *y) { *x = box->x; @@ -321,13 +277,7 @@ void box_coords(struct box *box, int *x, int *y) } -/** - * Find the bounds of a box. - * - * \param box the box to calculate bounds of - * \param r receives bounds - */ - +/* Exported function documented in html/box.h */ void box_bounds(struct box *box, struct rect *r) { int width, height; @@ -359,7 +309,6 @@ void box_bounds(struct box *box, struct rect *r) * * This is a helper function for box_at_point(). */ - static bool box_contains_point( const nscss_len_ctx *len_ctx, const struct box *box, @@ -471,7 +420,9 @@ static bool box_contains_point( } -/** Direction to move in a box-tree walk */ +/** + * Direction to move in a box-tree walk + */ enum box_walk_dir { BOX_WALK_CHILDREN, BOX_WALK_PARENT, @@ -492,8 +443,8 @@ enum box_walk_dir { * * If no box can be found in given direction, NULL is returned. */ -static inline struct box *box_move_xy(struct box *b, enum box_walk_dir dir, - int *x, int *y) +static inline struct box * +box_move_xy(struct box *b, enum box_walk_dir dir, int *x, int *y) { struct box *rb = NULL; @@ -665,35 +616,12 @@ skip_children: } - -/** - * Find the boxes at a point. - * - * \param len_ctx CSS length conversion context for document. - * \param box box to search children of - * \param x point to find, in global document coordinates - * \param y point to find, in global document coordinates - * \param box_x position of box, in global document coordinates, updated - * to position of returned box, if any - * \param box_y position of box, in global document coordinates, updated - * to position of returned box, if any - * \return box at given point, or 0 if none found - * - * To find all the boxes in the hierarchy at a certain point, use code like - * this: - * \code - * struct box *box = top_of_document_to_search; - * int box_x = 0, box_y = 0; - * - * while ((box = box_at_point(len_ctx, box, x, y, &box_x, &box_y))) { - * // process box - * } - * \endcode - */ - -struct box *box_at_point(const nscss_len_ctx *len_ctx, - struct box *box, const int x, const int y, - int *box_x, int *box_y) +/* Exported function documented in html/box.h */ +struct box * +box_at_point(const nscss_len_ctx *len_ctx, + struct box *box, + const int x, const int y, + int *box_x, int *box_y) { bool skip_children; bool physically; @@ -742,10 +670,14 @@ struct box *box_at_point(const nscss_len_ctx *len_ctx, * updated if box is nearer than existing nearest * \return true if mouse point is inside box */ - -static bool box_nearer_text_box(struct box *box, int bx, int by, - int x, int y, int dir, struct box **nearest, int *tx, int *ty, - int *nr_xd, int *nr_yd) +static bool +box_nearer_text_box(struct box *box, + int bx, int by, + int x, int y, + int dir, + struct box **nearest, + int *tx, int *ty, + int *nr_xd, int *nr_yd) { int w = box->padding[LEFT] + box->width + box->padding[RIGHT]; int h = box->padding[TOP] + box->height + box->padding[BOTTOM]; @@ -814,7 +746,6 @@ static bool box_nearer_text_box(struct box *box, int bx, int by, * updated if a descendant of box is nearer than old nearest * \return true if mouse point is inside text_box */ - static bool box_nearest_text_box(struct box *box, int bx, int by, int fx, int fy, int x, int y, int dir, struct box **nearest, int *tx, int *ty, int *nr_xd, int *nr_yd) @@ -885,21 +816,12 @@ static bool box_nearest_text_box(struct box *box, int bx, int by, } -/** - * Peform pick text on browser window contents to locate the box under - * the mouse pointer, or nearest in the given direction if the pointer is - * not over a text box. - * - * \param html an HTML content - * \param x coordinate of mouse - * \param y coordinate of mouse - * \param dir direction to search (-1 = above-left, +1 = below-right) - * \param dx receives x ordinate of mouse relative to text box - * \param dy receives y ordinate of mouse relative to text box - */ - -struct box *box_pick_text_box(struct html_content *html, - int x, int y, int dir, int *dx, int *dy) +/* Exported function documented in html/box.h */ +struct box * +box_pick_text_box(struct html_content *html, + int x, int y, + int dir, + int *dx, int *dy) { struct box *text_box = NULL; struct box *box; @@ -947,14 +869,7 @@ struct box *box_pick_text_box(struct html_content *html, } -/** - * Find a box based upon its id attribute. - * - * \param box box tree to search - * \param id id to look for - * \return the box or 0 if not found - */ - +/* Exported function documented in html/box.h */ struct box *box_find_by_id(struct box *box, lwc_string *id) { struct box *a, *b; @@ -974,13 +889,7 @@ struct box *box_find_by_id(struct box *box, lwc_string *id) } -/** - * Determine if a box is visible when the tree is rendered. - * - * \param box box to check - * \return true iff the box is rendered - */ - +/* Exported function documented in html/box.h */ bool box_visible(struct box *box) { /* visibility: hidden */ @@ -992,10 +901,7 @@ bool box_visible(struct box *box) } -/** - * Print a box tree to a file. - */ - +/* Exported function documented in html/box.h */ void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style) { unsigned int i; @@ -1218,13 +1124,8 @@ box_handle_scrollbars(struct content *c, return NSERROR_OK; } -/** - * Determine if a box has a vertical scrollbar. - * - * \param box scrolling box - * \return the box has a vertical scrollbar - */ +/* exported interface documented in html/box.h */ bool box_vscrollbar_present(const struct box * const box) { return box->padding[TOP] + box->height + box->padding[BOTTOM] + @@ -1232,13 +1133,7 @@ bool box_vscrollbar_present(const struct box * const box) } -/** - * Determine if a box has a horizontal scrollbar. - * - * \param box scrolling box - * \return the box has a horizontal scrollbar - */ - +/* exported interface documented in html/box.h */ bool box_hscrollbar_present(const struct box * const box) { return box->padding[LEFT] + box->width + box->padding[RIGHT] + diff --git a/content/handlers/html/box.h b/content/handlers/html/box.h index efad90f..1781d13 100644 --- a/content/handlers/html/box.h +++ b/content/handlers/html/box.h @@ -19,7 +19,7 @@ /** * \file - * Box tree construction and manipulation (interface). + * Box tree construction and manipulation interface. * * This stage of rendering converts a tree of dom_nodes (produced by libdom) * to a tree of struct box. The box tree represents the structure of the @@ -97,9 +97,6 @@ struct content; struct box; struct browser_window; -struct column; -struct object_params; -struct object_param; struct html_content; struct nsurl; struct dom_node; @@ -109,20 +106,34 @@ struct rect; #define UNKNOWN_WIDTH INT_MAX #define UNKNOWN_MAX_WIDTH INT_MAX + typedef void (*box_construct_complete_cb)(struct html_content *c, bool success); -/** Type of a struct box. */ + +/** + * Type of a struct box. + */ typedef enum { - BOX_BLOCK, BOX_INLINE_CONTAINER, BOX_INLINE, - BOX_TABLE, BOX_TABLE_ROW, BOX_TABLE_CELL, + BOX_BLOCK, + BOX_INLINE_CONTAINER, + BOX_INLINE, + BOX_TABLE, + BOX_TABLE_ROW, + BOX_TABLE_CELL, BOX_TABLE_ROW_GROUP, - BOX_FLOAT_LEFT, BOX_FLOAT_RIGHT, - BOX_INLINE_BLOCK, BOX_BR, BOX_TEXT, - BOX_INLINE_END, BOX_NONE + BOX_FLOAT_LEFT, + BOX_FLOAT_RIGHT, + BOX_INLINE_BLOCK, + BOX_BR, + BOX_TEXT, + BOX_INLINE_END, + BOX_NONE } box_type; -/** Flags for a struct box. */ +/** + * Flags for a struct box. + */ typedef enum { NEW_LINE = 1 << 0, /* first inline on a new line */ STYLE_OWNED = 1 << 1, /* style is owned by this box */ @@ -139,9 +150,13 @@ typedef enum { IS_REPLACED = 1 << 12 /* box is a replaced element */ } box_flags; -/* Sides of a box */ + +/** + * Sides of a box + */ enum box_side { TOP, RIGHT, BOTTOM, LEFT }; + /** * Container for box border details */ @@ -151,31 +166,190 @@ struct box_border { int width; /**< border-width (pixels) */ }; -/** Node in box tree. All dimensions are in pixels. */ + +/** + * Table column data. + */ +struct column { + /** + * Type of column. + */ + enum { + COLUMN_WIDTH_UNKNOWN, + COLUMN_WIDTH_FIXED, + COLUMN_WIDTH_AUTO, + COLUMN_WIDTH_PERCENT, + COLUMN_WIDTH_RELATIVE + } type; + + /** + * Preferred width of column. Pixels for FIXED, percentage for + * PERCENT, relative units for RELATIVE, unused for AUTO. + */ + int width; + + /** + * Minimum width of content. + */ + int min; + + /** + * Maximum width of content. + */ + int max; + + /** + * Whether all of column's cells are css positioned. + */ + bool positioned; +}; + + +/** + * Linked list of object element parameters. + */ +struct object_param { + char *name; + char *value; + char *type; + char *valuetype; + struct object_param *next; +}; + + +/** + * Parameters for object element and similar elements. + */ +struct object_params { + struct nsurl *data; + char *type; + char *codetype; + struct nsurl *codebase; + struct nsurl *classid; + struct object_param *params; +}; + + +/** + * Node in box tree. All dimensions are in pixels. + */ struct box { - /** Type of box. */ + /** + * Type of box. + */ box_type type; - /** Box flags */ + /** + * Box flags + */ box_flags flags; - /** Computed styles for elements and their pseudo elements. NULL on - * non-element boxes. */ + /** + * DOM node that generated this box or NULL + */ + struct dom_node *node; + + /** + * Computed styles for elements and their pseudo elements. + * NULL on non-element boxes. + */ css_select_results *styles; - /** Style for this box. 0 for INLINE_CONTAINER and FLOAT_*. Pointer into - * a box's 'styles' select results, except for implied boxes, where it - * is a pointer to an owned computed style. */ + /** + * Style for this box. 0 for INLINE_CONTAINER and + * FLOAT_*. Pointer into a box's 'styles' select results, + * except for implied boxes, where it is a pointer to an + * owned computed style. + */ css_computed_style *style; - /** Coordinate of left padding edge relative to parent box, or relative - * to ancestor that contains this box in float_children for FLOAT_. */ + /** + * value of id attribute (or name for anchors) + */ + lwc_string *id; + + + /** + * Next sibling box, or NULL. + */ + struct box *next; + + /** + * Previous sibling box, or NULL. + */ + struct box *prev; + + /** + * First child box, or NULL. + */ + struct box *children; + + /** + * Last child box, or NULL. + */ + struct box *last; + + /** + * Parent box, or NULL. + */ + struct box *parent; + + /** + * INLINE_END box corresponding to this INLINE box, or INLINE + * box corresponding to this INLINE_END box. + */ + struct box *inline_end; + + + /** + * First float child box, or NULL. Float boxes are in the tree + * twice, in this list for the block box which defines the + * area for floats, and also in the standard tree given by + * children, next, prev, etc. + */ + struct box *float_children; + + /** + * Next sibling float box. + */ + struct box *next_float; + + /** + * If box is a float, points to box's containing block + */ + struct box *float_container; + + /** + * Level below which subsequent floats must be cleared. This + * is used only for boxes with float_children + */ + int clear_level; + + /** + * Level below which floats have been placed. + */ + int cached_place_below_level; + + + /** + * Coordinate of left padding edge relative to parent box, or + * relative to ancestor that contains this box in + * float_children for FLOAT_. + */ int x; - /** Coordinate of top padding edge, relative as for x. */ + /** + * Coordinate of top padding edge, relative as for x. + */ int y; - int width; /**< Width of content box (excluding padding etc.). */ - int height; /**< Height of content box (excluding padding etc.). */ + /** + * Width of content box (excluding padding etc.). + */ + int width; + /** + * Height of content box (excluding padding etc.). + */ + int height; /* These four variables determine the maximum extent of a box's * descendants. They are relative to the x,y coordinates of the box. @@ -196,123 +370,146 @@ struct box { int descendant_x1; /**< right edge of descendants */ int descendant_y1; /**< bottom edge of descendants */ - int margin[4]; /**< Margin: TOP, RIGHT, BOTTOM, LEFT. */ - int padding[4]; /**< Padding: TOP, RIGHT, BOTTOM, LEFT. */ - struct box_border border[4]; /**< Border: TOP, RIGHT, BOTTOM, LEFT. */ + /** + * Margin: TOP, RIGHT, BOTTOM, LEFT. + */ + int margin[4]; + + /** + * Padding: TOP, RIGHT, BOTTOM, LEFT. + */ + int padding[4]; + + /** + * Border: TOP, RIGHT, BOTTOM, LEFT. + */ + struct box_border border[4]; + + /** + * Horizontal scroll. + */ + struct scrollbar *scroll_x; - struct scrollbar *scroll_x; /**< Horizontal scroll. */ - struct scrollbar *scroll_y; /**< Vertical scroll. */ + /** + * Vertical scroll. + */ + struct scrollbar *scroll_y; - /** Width of box taking all line breaks (including margins etc). Must - * be non-negative. */ + /** + * Width of box taking all line breaks (including margins + * etc). Must be non-negative. + */ int min_width; - /** Width that would be taken with no line breaks. Must be - * non-negative. */ + + /** + * Width that would be taken with no line breaks. Must be + * non-negative. + */ int max_width; - /**< Byte offset within a textual representation of this content. */ - size_t byte_offset; - char *text; /**< Text, or 0 if none. Unterminated. */ - size_t length; /**< Length of text. */ + /** + * Text, or NULL if none. Unterminated. + */ + char *text; + + /** + * Length of text. + */ + size_t length; - /** Width of space after current text (depends on font and size). */ + /** + * Width of space after current text (depends on font and size). + */ int space; - struct nsurl *href; /**< Link, or 0. */ - const char *target; /**< Link target, or 0. */ - const char *title; /**< Title, or 0. */ - - unsigned int columns; /**< Number of columns for TABLE / TABLE_CELL. */ - unsigned int rows; /**< Number of rows for TABLE only. */ - unsigned int start_column; /**< Start column for TABLE_CELL only. */ - - struct box *next; /**< Next sibling box, or 0. */ - struct box *prev; /**< Previous sibling box, or 0. */ - struct box *children; /**< First child box, or 0. */ - struct box *last; /**< Last child box, or 0. */ - struct box *parent; /**< Parent box, or 0. */ - /** INLINE_END box corresponding to this INLINE box, or INLINE box - * corresponding to this INLINE_END box. */ - struct box *inline_end; + /** + * Byte offset within a textual representation of this content. + */ + size_t byte_offset; - /** First float child box, or 0. Float boxes are in the tree twice, in - * this list for the block box which defines the area for floats, and - * also in the standard tree given by children, next, prev, etc. */ - struct box *float_children; - /** Next sibling float box. */ - struct box *next_float; - /** If box is a float, points to box's containing block */ - struct box *float_container; - /** Level below which subsequent floats must be cleared. - * This is used only for boxes with float_children */ - int clear_level; - /* Level below which floats have been placed. */ - int cached_place_below_level; + /** + * Link, or NULL. + */ + struct nsurl *href; + + /** + * Link target, or NULL. + */ + const char *target; - /** List marker box if this is a list-item, or 0. */ + /** + * Title, or NULL. + */ + const char *title; + + + /** + * Number of columns for TABLE / TABLE_CELL. + */ + unsigned int columns; + + /** + * Number of rows for TABLE only. + */ + unsigned int rows; + + /** + * Start column for TABLE_CELL only. + */ + unsigned int start_column; + + /** + * Array of table column data for TABLE only. + */ + struct column *col; + + + /** + * List marker box if this is a list-item, or NULL. + */ struct box *list_marker; - struct column *col; /**< Array of table column data for TABLE only. */ - /** Form control data, or 0 if not a form control. */ + /** + * Form control data, or NULL if not a form control. + */ struct form_control* gadget; - char *usemap; /** (Image)map to use with this object, or 0 if none */ - lwc_string *id; /**< value of id attribute (or name for anchors) */ - /** Background image for this box, or 0 if none */ + /** + * (Image)map to use with this object, or NULL if none + */ + char *usemap; + + + /** + * Background image for this box, or NULL if none + */ struct hlcache_handle *background; - /** Object in this box (usually an image), or 0 if none. */ + + /** + * Object in this box (usually an image), or NULL if none. + */ struct hlcache_handle* object; - /** Parameters for the object, or 0. */ - struct object_params *object_params; - /** Iframe's browser_window, or NULL if none */ - struct browser_window *iframe; + /** + * Parameters for the object, or NULL. + */ + struct object_params *object_params; - struct dom_node *node; /**< DOM node that generated this box or NULL */ -}; -/** Table column data. */ -struct column { - /** Type of column. */ - enum { COLUMN_WIDTH_UNKNOWN, COLUMN_WIDTH_FIXED, - COLUMN_WIDTH_AUTO, COLUMN_WIDTH_PERCENT, - COLUMN_WIDTH_RELATIVE } type; - /** Preferred width of column. Pixels for FIXED, percentage for PERCENT, - * relative units for RELATIVE, unused for AUTO. */ - int width; - /** Minimum width of content. */ - int min; - /** Maximum width of content. */ - int max; - /** Whether all of column's cells are css positioned. */ - bool positioned; -}; + /** + * Iframe's browser_window, or NULL if none + */ + struct browser_window *iframe; -/** Parameters for object element and similar elements. */ -struct object_params { - struct nsurl *data; - char *type; - char *codetype; - struct nsurl *codebase; - struct nsurl *classid; - struct object_param *params; }; -/** Linked list of object element parameters. */ -struct object_param { - char *name; - char *value; - char *type; - char *valuetype; - struct object_param *next; -}; -/** Frame target names (constant pointers to save duplicating the strings many +/* Frame target names (constant pointers to save duplicating the strings many * times). We convert _blank to _top for user-friendliness. */ extern const char *TARGET_SELF; extern const char *TARGET_PARENT; @@ -320,38 +517,154 @@ extern const char *TARGET_TOP; extern const char *TARGET_BLANK; +/** + * Create a box tree node. + * + * \param styles selection results for the box, or NULL + * \param style computed style for the box (not copied), or 0 + * \param style_owned whether style is owned by this box + * \param href href for the box (copied), or 0 + * \param target target for the box (not copied), or 0 + * \param title title for the box (not copied), or 0 + * \param id id for the box (not copied), or 0 + * \param context context for allocations + * \return allocated and initialised box, or 0 on memory exhaustion + * + * styles is always owned by the box, if it is set. + * style is only owned by the box in the case of implied boxes. + */ +struct box * box_create(css_select_results *styles, css_computed_style *style, bool style_owned, struct nsurl *href, const char *target, const char *title, lwc_string *id, void *context); + -struct box * box_create(css_select_results *styles, css_computed_style *style, - bool style_owned, struct nsurl *href, const char *target, - const char *title, lwc_string *id, void *context); +/** + * Add a child to a box tree node. + * + * \param parent box giving birth + * \param child box to link as last child of parent + */ void box_add_child(struct box *parent, struct box *child); + + +/** + * Insert a new box as a sibling to a box in a tree. + * + * \param box box already in tree + * \param new_box box to link into tree as next sibling + */ void box_insert_sibling(struct box *box, struct box *new_box); + + +/** + * Unlink a box from the box tree and then free it recursively. + * + * \param box box to unlink and free recursively. + */ void box_unlink_and_free(struct box *box); + + +/** + * Free a box tree recursively. + * + * \param box box to free recursively + * + * The box and all its children is freed. + */ void box_free(struct box *box); + + +/** + * Free the data in a single box structure. + * + * \param box box to free + */ void box_free_box(struct box *box); -void box_bounds(struct box *box, struct rect *r); + + +/** + * Find the absolute coordinates of a box. + * + * \param box the box to calculate coordinates of + * \param x updated to x coordinate + * \param y updated to y coordinate + */ void box_coords(struct box *box, int *x, int *y); -struct box *box_at_point( - const nscss_len_ctx *len_ctx, - struct box *box, const int x, const int y, - int *box_x, int *box_y); -struct box *box_pick_text_box(struct html_content *html, - int x, int y, int dir, int *dx, int *dy); + + +/** + * Find the bounds of a box. + * + * \param box the box to calculate bounds of + * \param r receives bounds + */ +void box_bounds(struct box *box, struct rect *r); + + +/** + * Find the boxes at a point. + * + * \param len_ctx CSS length conversion context for document. + * \param box box to search children of + * \param x point to find, in global document coordinates + * \param y point to find, in global document coordinates + * \param box_x position of box, in global document coordinates, updated + * to position of returned box, if any + * \param box_y position of box, in global document coordinates, updated + * to position of returned box, if any + * \return box at given point, or 0 if none found + * + * To find all the boxes in the hierarchy at a certain point, use code like + * this: + * \code + * struct box *box = top_of_document_to_search; + * int box_x = 0, box_y = 0; + * + * while ((box = box_at_point(len_ctx, box, x, y, &box_x, &box_y))) { + * // process box + * } + * \endcode + */ +struct box *box_at_point(const nscss_len_ctx *len_ctx, struct box *box, const int x, const int y, int *box_x, int *box_y); + + +/** + * Peform pick text on browser window contents to locate the box under + * the mouse pointer, or nearest in the given direction if the pointer is + * not over a text box. + * + * \param html an HTML content + * \param x coordinate of mouse + * \param y coordinate of mouse + * \param dir direction to search (-1 = above-left, +1 = below-right) + * \param dx receives x ordinate of mouse relative to text box + * \param dy receives y ordinate of mouse relative to text box + */ +struct box *box_pick_text_box(struct html_content *html, int x, int y, int dir, int *dx, int *dy); + + +/** + * Find a box based upon its id attribute. + * + * \param box box tree to search + * \param id id to look for + * \return the box or 0 if not found + */ struct box *box_find_by_id(struct box *box, lwc_string *id); + + +/** + * Determine if a box is visible when the tree is rendered. + * + * \param box box to check + * \return true iff the box is rendered + */ bool box_visible(struct box *box); -void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style); + /** - * Extract a URL from a relative link, handling junk like whitespace and - * attempting to read a real URL from "javascript:" links. - * - * \param content html content - * \param dsrel relative URL text taken from page - * \param base base for relative URLs - * \param result updated to target URL on heap, unchanged if extract failed - * \return true on success, false on memory exhaustion + * Print a box tree to a file. */ -bool box_extract_link(const struct html_content *content, const struct dom_string *dsrel, struct nsurl *base, struct nsurl **result); +void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style); + /** * Applies the given scroll setup to a box. This includes scroll @@ -366,29 +679,24 @@ bool box_extract_link(const struct html_content *content, const struct dom_strin nserror box_handle_scrollbars(struct content *c, struct box *box, bool bottom, bool right); -bool box_vscrollbar_present(const struct box *box); -bool box_hscrollbar_present(const struct box *box); /** - * Construct a box tree from an xml tree and stylesheets. + * Determine if a box has a vertical scrollbar. * - * \param n xml tree - * \param c content of type CONTENT_HTML to construct box tree in - * \param cb callback to report conversion completion - * \return netsurf error code indicating status of call + * \param box scrolling box + * \return the box has a vertical scrollbar */ -nserror dom_to_box(struct dom_node *n, struct html_content *c, - box_construct_complete_cb cb, void **box_conversion_context); +bool box_vscrollbar_present(const struct box *box); + /** - * aborts any ongoing box construction + * Determine if a box has a horizontal scrollbar. + * + * \param box scrolling box + * \return the box has a horizontal scrollbar */ -nserror cancel_dom_to_box(void *box_conversion_context); +bool box_hscrollbar_present(const struct box *box); -bool box_normalise_block( - struct box *block, - const struct box *root, - struct html_content *c); /** * Check if layout box is a first child. @@ -401,12 +709,5 @@ static inline bool box_is_first_child(struct box *b) return (b->parent == NULL || b == b->parent->children); } -/** - * Retrieve the box for a dom node, if there is one - * - * \param node The DOM node - * \return The box if there is one - */ -struct box *box_for_node(struct dom_node *node); #endif diff --git a/content/handlers/html/box_construct.c b/content/handlers/html/box_construct.c index 16154cb..039da74 100644 --- a/content/handlers/html/box_construct.c +++ b/content/handlers/html/box_construct.c @@ -51,6 +51,8 @@ #include "html/html.h" #include "html/box.h" +#include "html/box_construct.h" +#include "html/box_normalise.h" #include "html/box_textarea.h" #include "html/form_internal.h" #include "html/html_internal.h" @@ -3139,7 +3141,7 @@ static void convert_xml_to_box(struct box_construct_ctx *ctx) } -/* Exported function, documented in box.h */ +/* exported function documented in html/box_construct.h */ nserror dom_to_box(dom_node *n, html_content *c, @@ -3175,7 +3177,7 @@ dom_to_box(dom_node *n, } -/* Exported function, see box.h */ +/* exported function documented in html/box_construct.h */ nserror cancel_dom_to_box(void *box_conversion_context) { struct box_construct_ctx *ctx = box_conversion_context; @@ -3193,7 +3195,7 @@ nserror cancel_dom_to_box(void *box_conversion_context) } -/* Exported function, see box.h */ +/* exported function documented in html/box_construct.h */ struct box *box_for_node(dom_node *n) { struct box *box = NULL; @@ -3208,59 +3210,7 @@ struct box *box_for_node(dom_node *n) } - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -/* exported function documented in html/box.h */ +/* exported function documented in html/box_construct.h */ bool box_extract_link(const html_content *content, const dom_string *dsrel, diff --git a/content/handlers/html/box_construct.h b/content/handlers/html/box_construct.h new file mode 100644 index 0000000..e93f515 --- /dev/null +++ b/content/handlers/html/box_construct.h @@ -0,0 +1,65 @@ +/* + * Copyright 2020 Vincent Sanders <vince(a)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 + * HTML Box tree construction interface. + */ + +#ifndef NETSURF_HTML_BOX_CONSTRUCT_H +#define NETSURF_HTML_BOX_CONSTRUCT_H + +/** + * Construct a box tree from a dom and html content + * + * \param n dom document + * \param c content of type CONTENT_HTML to construct box tree in + * \param cb callback to report conversion completion + * \param box_conversion_context pointer that recives the conversion context + * \return netsurf error code indicating status of call + */ +nserror dom_to_box(struct dom_node *n, struct html_content *c, box_construct_complete_cb cb, void **box_conversion_context); + + +/** + * aborts any ongoing box construction + */ +nserror cancel_dom_to_box(void *box_conversion_context); + + +/** + * Retrieve the box for a dom node, if there is one + * + * \param node The DOM node + * \return The box if there is one + */ +struct box *box_for_node(struct dom_node *node); + +/** + * Extract a URL from a relative link, handling junk like whitespace and + * attempting to read a real URL from "javascript:" links. + * + * \param content html content + * \param dsrel relative URL text taken from page + * \param base base for relative URLs + * \param result updated to target URL on heap, unchanged if extract failed + * \return true on success, false on memory exhaustion + */ +bool box_extract_link(const struct html_content *content, const struct dom_string *dsrel, struct nsurl *base, struct nsurl **result); + +#endif diff --git a/content/handlers/html/box_normalise.c b/content/handlers/html/box_normalise.c index 7155cb7..03fe731 100644 --- a/content/handlers/html/box_normalise.c +++ b/content/handlers/html/box_normalise.c @@ -21,7 +21,7 @@ /** * \file - * Box tree normalisation (implementation). + * Box tree normalisation implementation. */ #include <assert.h> @@ -33,6 +33,7 @@ #include "css/select.h" #include "html/box.h" +#include "html/box_normalise.h" #include "html/html_internal.h" #include "html/table.h" @@ -66,279 +67,310 @@ struct columns { }; -static bool box_normalise_table( - struct box *table, - const struct box *root, - html_content *c); -static bool box_normalise_table_spans( - struct box *table, - const struct box *root, - struct span_info *spans, - html_content *c); -static bool box_normalise_table_row_group( - struct box *row_group, - const struct box *root, - struct columns *col_info, - html_content *c); -static bool box_normalise_table_row( - struct box *row, - const struct box *root, - struct columns *col_info, - html_content *c); -static bool calculate_table_row(struct columns *col_info, - unsigned int col_span, unsigned int row_span, - unsigned int *start_column, struct box *cell); -static bool box_normalise_inline_container( - struct box *cont, - const struct box *root, - html_content *c); - /** - * Ensure the box tree is correctly nested by adding and removing nodes. - * - * \param block box of type BLOCK, INLINE_BLOCK, or TABLE_CELL - * \param root root box of document - * \param c content of boxes - * \return true on success, false on memory exhaustion + * Compute the column index at which the current cell begins. + * Additionally, update the column record to reflect row spanning. * - * The tree is modified to satisfy the following: - * \code - * parent permitted child nodes - * BLOCK, INLINE_BLOCK BLOCK, INLINE_CONTAINER, TABLE - * INLINE_CONTAINER INLINE, INLINE_BLOCK, FLOAT_LEFT, FLOAT_RIGHT, BR, TEXT - * INLINE, TEXT none - * TABLE at least 1 TABLE_ROW_GROUP - * TABLE_ROW_GROUP at least 1 TABLE_ROW - * TABLE_ROW at least 1 TABLE_CELL - * TABLE_CELL BLOCK, INLINE_CONTAINER, TABLE (same as BLOCK) - * FLOAT_(LEFT|RIGHT) exactly 1 BLOCK or TABLE - * \endcode + * \param col_info Column record + * \param col_span Number of columns that current cell spans + * \param row_span Number of rows that current cell spans + * \param start_column Pointer to location to receive column index + * \param cell Box for current table cell + * \return true on success, false on memory exhaustion */ +static bool +calculate_table_row(struct columns *col_info, + unsigned int col_span, + unsigned int row_span, + unsigned int *start_column, + struct box *cell) +{ + unsigned int cell_start_col = col_info->current_column; + unsigned int cell_end_col; + unsigned int i; + struct span_info *spans; + struct box *rg = cell->parent->parent; /* Cell's row group */ + + /* Skip columns with cells spanning from above */ + /* TODO: Need to ignore cells spanning from above that belong to + * different row group. We don't have that info here. */ + while (col_info->spans[cell_start_col].row_span != 0 && + col_info->spans[cell_start_col].rg == rg) { + cell_start_col++; + } + + /* Update current column with calculated start */ + col_info->current_column = cell_start_col; + + /* If this cell has a colspan of 0, then assume 1. + * No other browser supports colspan=0, anyway. */ + if (col_span == 0) + col_span = 1; + + cell_end_col = cell_start_col + col_span; + + if (col_info->num_columns < cell_end_col) { + /* It appears that this row has more columns than + * the maximum recorded for the table so far. + * Allocate more span records. */ + spans = realloc(col_info->spans, + sizeof *spans * (cell_end_col + 1)); + if (spans == NULL) + return false; + + col_info->spans = spans; + col_info->num_columns = cell_end_col; + + /* Mark new final column as sentinel */ + col_info->spans[cell_end_col].row_span = 0; + col_info->spans[cell_end_col].auto_row = false; + } + + /* This cell may span multiple columns. If it also wants to span + * multiple rows, temporarily assume it spans 1 row only. This will + * be fixed up in box_normalise_table_spans() */ + for (i = cell_start_col; i < cell_end_col; i++) { + col_info->spans[i].row_span = (row_span == 0) ? 1 : row_span; + col_info->spans[i].auto_row = (row_span == 0); + col_info->spans[i].rg = rg; + } + + /* Update current column with calculated end. */ + col_info->current_column = cell_end_col; + + *start_column = cell_start_col; -bool box_normalise_block( - struct box *block, - const struct box *root, - html_content *c) + return true; +} + + +static bool +box_normalise_table_row(struct box *row, + const struct box *root, + struct columns *col_info, + html_content * c) { struct box *child; struct box *next_child; - struct box *table; + struct box *cell = NULL; css_computed_style *style; + unsigned int i; nscss_select_ctx ctx; - assert(block != NULL); - assert(root != NULL); + assert(row != NULL); + assert(row->type == BOX_TABLE_ROW); ctx.root_style = root->style; #ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "block %p, block->type %u", block, block->type); -#endif - - assert(block->type == BOX_BLOCK || block->type == BOX_INLINE_BLOCK || - block->type == BOX_TABLE_CELL); - - for (child = block->children; child != NULL; child = next_child) { -#ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "child %p, child->type = %d", child, - child->type); + NSLOG(netsurf, INFO, "row %p", row); #endif - next_child = child->next; /* child may be destroyed */ + for (child = row->children; child != NULL; child = next_child) { + next_child = child->next; switch (child->type) { - case BOX_BLOCK: + case BOX_TABLE_CELL: /* ok */ if (box_normalise_block(child, root, c) == false) return false; + cell = child; break; + case BOX_BLOCK: case BOX_INLINE_CONTAINER: - if (box_normalise_inline_container(child, root, c) == false) - return false; - break; case BOX_TABLE: - if (box_normalise_table(child, root, c) == false) - return false; - break; - case BOX_INLINE: - case BOX_INLINE_END: - case BOX_INLINE_BLOCK: - case BOX_FLOAT_LEFT: - case BOX_FLOAT_RIGHT: - case BOX_BR: - case BOX_TEXT: - /* should have been wrapped in inline - container by convert_xml_to_box() */ - assert(0); - break; case BOX_TABLE_ROW_GROUP: case BOX_TABLE_ROW: - case BOX_TABLE_CELL: - /* insert implied table */ - assert(block->style != NULL); + /* insert implied table cell */ + assert(row->style != NULL); ctx.ctx = c->select_ctx; ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); ctx.base_url = c->base_url; ctx.universal = c->universal; - style = nscss_get_blank_style(&ctx, block->style); + style = nscss_get_blank_style(&ctx, row->style); if (style == NULL) return false; - table = box_create(NULL, style, true, block->href, - block->target, NULL, NULL, c->bctx); - if (table == NULL) { + cell = box_create(NULL, style, true, row->href, + row->target, NULL, NULL, c->bctx); + if (cell == NULL) { css_computed_style_destroy(style); return false; } - table->type = BOX_TABLE; + cell->type = BOX_TABLE_CELL; if (child->prev == NULL) - block->children = table; + row->children = cell; else - child->prev->next = table; + child->prev->next = cell; - table->prev = child->prev; + cell->prev = child->prev; while (child != NULL && ( + child->type == BOX_BLOCK || + child->type == BOX_INLINE_CONTAINER || + child->type == BOX_TABLE || child->type == BOX_TABLE_ROW_GROUP || - child->type == BOX_TABLE_ROW || - child->type == BOX_TABLE_CELL)) { - box_add_child(table, child); + child->type == BOX_TABLE_ROW)) { + box_add_child(cell, child); next_child = child->next; child->next = NULL; child = next_child; } - table->last->next = NULL; - table->next = next_child = child; - if (table->next != NULL) - table->next->prev = table; + assert(cell->last != NULL); + + cell->last->next = NULL; + cell->next = next_child = child; + if (cell->next != NULL) + cell->next->prev = cell; else - block->last = table; - table->parent = block; + row->last = cell; + cell->parent = row; - if (box_normalise_table(table, root, c) == false) + if (box_normalise_block(cell, root, c) == false) return false; break; + case BOX_INLINE: + case BOX_INLINE_END: + case BOX_INLINE_BLOCK: + case BOX_FLOAT_LEFT: + case BOX_FLOAT_RIGHT: + case BOX_BR: + case BOX_TEXT: + /* should have been wrapped in inline + container by convert_xml_to_box() */ + assert(0); + break; default: assert(0); } + + if (calculate_table_row(col_info, cell->columns, cell->rows, + &cell->start_column, cell) == false) + return false; + } + + + /* Update row spanning details for all columns */ + for (i = 0; i < col_info->num_columns; i++) { + if (col_info->spans[i].row_span != 0 && + col_info->spans[i].auto_row == false) { + /* This cell spans rows, and is not an auto row. + * Reduce number of rows left to span */ + col_info->spans[i].row_span--; + } } + /* Reset current column for next row */ + col_info->current_column = 0; + + /* Increment row counter */ + col_info->num_rows++; + +#ifdef BOX_NORMALISE_DEBUG + NSLOG(netsurf, INFO, "row %p done", row); +#endif + return true; } -bool box_normalise_table( - struct box *table, - const struct box *root, - html_content * c) +static bool +box_normalise_table_row_group(struct box *row_group, + const struct box *root, + struct columns *col_info, + html_content * c) { struct box *child; struct box *next_child; - struct box *row_group; + struct box *row; css_computed_style *style; - struct columns col_info; nscss_select_ctx ctx; + unsigned int group_row_count = 0; - assert(table != NULL); - assert(table->type == BOX_TABLE); + assert(row_group != 0); + assert(row_group->type == BOX_TABLE_ROW_GROUP); ctx.root_style = root->style; #ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "table %p", table); + NSLOG(netsurf, INFO, "row_group %p", row_group); #endif - col_info.num_columns = 1; - col_info.current_column = 0; - col_info.spans = malloc(2 * sizeof *col_info.spans); - if (col_info.spans == NULL) - return false; - - col_info.spans[0].row_span = col_info.spans[1].row_span = 0; - col_info.spans[0].auto_row = false; - col_info.spans[1].auto_row = false; - col_info.num_rows = 0; - - for (child = table->children; child != NULL; child = next_child) { + for (child = row_group->children; child != NULL; child = next_child) { next_child = child->next; + switch (child->type) { - case BOX_TABLE_ROW_GROUP: + case BOX_TABLE_ROW: /* ok */ - if (box_normalise_table_row_group(child, root, - &col_info, c) == false) { - free(col_info.spans); + group_row_count++; + if (box_normalise_table_row(child, root, col_info, + c) == false) return false; - } break; case BOX_BLOCK: case BOX_INLINE_CONTAINER: case BOX_TABLE: - case BOX_TABLE_ROW: + case BOX_TABLE_ROW_GROUP: case BOX_TABLE_CELL: - /* insert implied table row group */ - assert(table->style != NULL); + /* insert implied table row */ + assert(row_group->style != NULL); ctx.ctx = c->select_ctx; ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); ctx.base_url = c->base_url; ctx.universal = c->universal; - style = nscss_get_blank_style(&ctx, table->style); - if (style == NULL) { - free(col_info.spans); + style = nscss_get_blank_style(&ctx, row_group->style); + if (style == NULL) return false; - } - row_group = box_create(NULL, style, true, table->href, - table->target, NULL, NULL, c->bctx); - if (row_group == NULL) { + row = box_create(NULL, style, true, row_group->href, + row_group->target, NULL, NULL, c->bctx); + if (row == NULL) { css_computed_style_destroy(style); - free(col_info.spans); return false; } - - row_group->type = BOX_TABLE_ROW_GROUP; + row->type = BOX_TABLE_ROW; if (child->prev == NULL) - table->children = row_group; + row_group->children = row; else - child->prev->next = row_group; + child->prev->next = row; - row_group->prev = child->prev; + row->prev = child->prev; while (child != NULL && ( child->type == BOX_BLOCK || child->type == BOX_INLINE_CONTAINER || child->type == BOX_TABLE || - child->type == BOX_TABLE_ROW || + child->type == BOX_TABLE_ROW_GROUP || child->type == BOX_TABLE_CELL)) { - box_add_child(row_group, child); + box_add_child(row, child); next_child = child->next; child->next = NULL; child = next_child; } - assert(row_group->last != NULL); + assert(row->last != NULL); - row_group->last->next = NULL; - row_group->next = next_child = child; - if (row_group->next != NULL) - row_group->next->prev = row_group; + row->last->next = NULL; + row->next = next_child = child; + if (row->next != NULL) + row->next->prev = row; else - table->last = row_group; - row_group->parent = table; + row_group->last = row; + row->parent = row_group; - if (box_normalise_table_row_group(row_group, root, - &col_info, c) == false) { - free(col_info.spans); + group_row_count++; + if (box_normalise_table_row(row, root, col_info, + c) == false) return false; - } break; case BOX_INLINE: case BOX_INLINE_END: @@ -352,48 +384,25 @@ bool box_normalise_table( assert(0); break; default: - fprintf(stderr, "%i\n", child->type); assert(0); } } - table->columns = col_info.num_columns; - table->rows = col_info.num_rows; - - if (table->children == NULL) { - struct box *row; - + if (row_group->children == NULL) { #ifdef BOX_NORMALISE_DEBUG NSLOG(netsurf, INFO, - "table->children == 0, creating implied row"); + "row_group->children == 0, inserting implied row"); #endif - assert(table->style != NULL); + assert(row_group->style != NULL); ctx.ctx = c->select_ctx; ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); ctx.base_url = c->base_url; ctx.universal = c->universal; - style = nscss_get_blank_style(&ctx, table->style); - if (style == NULL) { - free(col_info.spans); - return false; - } - - row_group = box_create(NULL, style, true, table->href, - table->target, NULL, NULL, c->bctx); - if (row_group == NULL) { - css_computed_style_destroy(style); - free(col_info.spans); - return false; - } - row_group->type = BOX_TABLE_ROW_GROUP; - style = nscss_get_blank_style(&ctx, row_group->style); if (style == NULL) { - box_free(row_group); - free(col_info.spans); return false; } @@ -401,8 +410,6 @@ bool box_normalise_table( row_group->target, NULL, NULL, c->bctx); if (row == NULL) { css_computed_style_destroy(style); - box_free(row_group); - free(col_info.spans); return false; } row->type = BOX_TABLE_ROW; @@ -410,21 +417,16 @@ bool box_normalise_table( row->parent = row_group; row_group->children = row_group->last = row; - row_group->parent = table; - table->children = table->last = row_group; - - table->rows = 1; - } + group_row_count = 1; - if (box_normalise_table_spans(table, root, col_info.spans, c) == false) { - free(col_info.spans); - return false; + /* Keep table's row count in sync */ + col_info->num_rows++; } - free(col_info.spans); + row_group->rows = group_row_count; #ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "table %p done", table); + NSLOG(netsurf, INFO, "row_group %p done", row_group); #endif return true; @@ -441,12 +443,11 @@ bool box_normalise_table( * \param c Content containing table * \return True on success, false on memory exhaustion. */ - -bool box_normalise_table_spans( - struct box *table, - const struct box *root, - struct span_info *spans, - html_content *c) +static bool +box_normalise_table_spans(struct box *table, + const struct box *root, + struct span_info *spans, + html_content *c) { struct box *table_row_group; struct box *table_row; @@ -601,249 +602,111 @@ bool box_normalise_table_spans( } -bool box_normalise_table_row_group( - struct box *row_group, - const struct box *root, - struct columns *col_info, - html_content * c) +static bool +box_normalise_table(struct box *table, const struct box *root, html_content * c) { struct box *child; struct box *next_child; - struct box *row; + struct box *row_group; css_computed_style *style; + struct columns col_info; nscss_select_ctx ctx; - unsigned int group_row_count = 0; - assert(row_group != 0); - assert(row_group->type == BOX_TABLE_ROW_GROUP); + assert(table != NULL); + assert(table->type == BOX_TABLE); ctx.root_style = root->style; #ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "row_group %p", row_group); -#endif - - for (child = row_group->children; child != NULL; child = next_child) { - next_child = child->next; - - switch (child->type) { - case BOX_TABLE_ROW: - /* ok */ - group_row_count++; - if (box_normalise_table_row(child, root, col_info, - c) == false) - return false; - break; - case BOX_BLOCK: - case BOX_INLINE_CONTAINER: - case BOX_TABLE: - case BOX_TABLE_ROW_GROUP: - case BOX_TABLE_CELL: - /* insert implied table row */ - assert(row_group->style != NULL); - - ctx.ctx = c->select_ctx; - ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); - ctx.base_url = c->base_url; - ctx.universal = c->universal; - - style = nscss_get_blank_style(&ctx, row_group->style); - if (style == NULL) - return false; - - row = box_create(NULL, style, true, row_group->href, - row_group->target, NULL, NULL, c->bctx); - if (row == NULL) { - css_computed_style_destroy(style); - return false; - } - row->type = BOX_TABLE_ROW; - - if (child->prev == NULL) - row_group->children = row; - else - child->prev->next = row; - - row->prev = child->prev; - - while (child != NULL && ( - child->type == BOX_BLOCK || - child->type == BOX_INLINE_CONTAINER || - child->type == BOX_TABLE || - child->type == BOX_TABLE_ROW_GROUP || - child->type == BOX_TABLE_CELL)) { - box_add_child(row, child); - - next_child = child->next; - child->next = NULL; - child = next_child; - } - - assert(row->last != NULL); - - row->last->next = NULL; - row->next = next_child = child; - if (row->next != NULL) - row->next->prev = row; - else - row_group->last = row; - row->parent = row_group; - - group_row_count++; - if (box_normalise_table_row(row, root, col_info, - c) == false) - return false; - break; - case BOX_INLINE: - case BOX_INLINE_END: - case BOX_INLINE_BLOCK: - case BOX_FLOAT_LEFT: - case BOX_FLOAT_RIGHT: - case BOX_BR: - case BOX_TEXT: - /* should have been wrapped in inline - container by convert_xml_to_box() */ - assert(0); - break; - default: - assert(0); - } - } - - if (row_group->children == NULL) { -#ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, - "row_group->children == 0, inserting implied row"); -#endif - - assert(row_group->style != NULL); - - ctx.ctx = c->select_ctx; - ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); - ctx.base_url = c->base_url; - ctx.universal = c->universal; - - style = nscss_get_blank_style(&ctx, row_group->style); - if (style == NULL) { - return false; - } - - row = box_create(NULL, style, true, row_group->href, - row_group->target, NULL, NULL, c->bctx); - if (row == NULL) { - css_computed_style_destroy(style); - return false; - } - row->type = BOX_TABLE_ROW; - - row->parent = row_group; - row_group->children = row_group->last = row; - - group_row_count = 1; - - /* Keep table's row count in sync */ - col_info->num_rows++; - } - - row_group->rows = group_row_count; - -#ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "row_group %p done", row_group); + NSLOG(netsurf, INFO, "table %p", table); #endif - return true; -} - - -bool box_normalise_table_row( - struct box *row, - const struct box *root, - struct columns *col_info, - html_content * c) -{ - struct box *child; - struct box *next_child; - struct box *cell = NULL; - css_computed_style *style; - unsigned int i; - nscss_select_ctx ctx; - - assert(row != NULL); - assert(row->type == BOX_TABLE_ROW); - - ctx.root_style = root->style; + col_info.num_columns = 1; + col_info.current_column = 0; + col_info.spans = malloc(2 * sizeof *col_info.spans); + if (col_info.spans == NULL) + return false; -#ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "row %p", row); -#endif + col_info.spans[0].row_span = col_info.spans[1].row_span = 0; + col_info.spans[0].auto_row = false; + col_info.spans[1].auto_row = false; + col_info.num_rows = 0; - for (child = row->children; child != NULL; child = next_child) { + for (child = table->children; child != NULL; child = next_child) { next_child = child->next; - switch (child->type) { - case BOX_TABLE_CELL: + case BOX_TABLE_ROW_GROUP: /* ok */ - if (box_normalise_block(child, root, c) == false) + if (box_normalise_table_row_group(child, root, + &col_info, c) == false) { + free(col_info.spans); return false; - cell = child; + } break; case BOX_BLOCK: case BOX_INLINE_CONTAINER: case BOX_TABLE: - case BOX_TABLE_ROW_GROUP: case BOX_TABLE_ROW: - /* insert implied table cell */ - assert(row->style != NULL); + case BOX_TABLE_CELL: + /* insert implied table row group */ + assert(table->style != NULL); ctx.ctx = c->select_ctx; ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); ctx.base_url = c->base_url; ctx.universal = c->universal; - style = nscss_get_blank_style(&ctx, row->style); - if (style == NULL) + style = nscss_get_blank_style(&ctx, table->style); + if (style == NULL) { + free(col_info.spans); return false; + } - cell = box_create(NULL, style, true, row->href, - row->target, NULL, NULL, c->bctx); - if (cell == NULL) { + row_group = box_create(NULL, style, true, table->href, + table->target, NULL, NULL, c->bctx); + if (row_group == NULL) { css_computed_style_destroy(style); + free(col_info.spans); return false; } - cell->type = BOX_TABLE_CELL; + + row_group->type = BOX_TABLE_ROW_GROUP; if (child->prev == NULL) - row->children = cell; + table->children = row_group; else - child->prev->next = cell; + child->prev->next = row_group; - cell->prev = child->prev; + row_group->prev = child->prev; while (child != NULL && ( child->type == BOX_BLOCK || child->type == BOX_INLINE_CONTAINER || child->type == BOX_TABLE || - child->type == BOX_TABLE_ROW_GROUP || - child->type == BOX_TABLE_ROW)) { - box_add_child(cell, child); + child->type == BOX_TABLE_ROW || + child->type == BOX_TABLE_CELL)) { + box_add_child(row_group, child); next_child = child->next; child->next = NULL; child = next_child; } - assert(cell->last != NULL); + assert(row_group->last != NULL); - cell->last->next = NULL; - cell->next = next_child = child; - if (cell->next != NULL) - cell->next->prev = cell; + row_group->last->next = NULL; + row_group->next = next_child = child; + if (row_group->next != NULL) + row_group->next->prev = row_group; else - row->last = cell; - cell->parent = row; + table->last = row_group; + row_group->parent = table; - if (box_normalise_block(cell, root, c) == false) + if (box_normalise_table_row_group(row_group, root, + &col_info, c) == false) { + free(col_info.spans); return false; + } break; case BOX_INLINE: case BOX_INLINE_END: @@ -857,118 +720,89 @@ bool box_normalise_table_row( assert(0); break; default: + fprintf(stderr, "%i\n", child->type); assert(0); } - - if (calculate_table_row(col_info, cell->columns, cell->rows, - &cell->start_column, cell) == false) - return false; - } - - - /* Update row spanning details for all columns */ - for (i = 0; i < col_info->num_columns; i++) { - if (col_info->spans[i].row_span != 0 && - col_info->spans[i].auto_row == false) { - /* This cell spans rows, and is not an auto row. - * Reduce number of rows left to span */ - col_info->spans[i].row_span--; - } } - /* Reset current column for next row */ - col_info->current_column = 0; + table->columns = col_info.num_columns; + table->rows = col_info.num_rows; - /* Increment row counter */ - col_info->num_rows++; + if (table->children == NULL) { + struct box *row; #ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "row %p done", row); + NSLOG(netsurf, INFO, + "table->children == 0, creating implied row"); #endif - return true; -} - - -/** - * Compute the column index at which the current cell begins. - * Additionally, update the column record to reflect row spanning. - * - * \param col_info Column record - * \param col_span Number of columns that current cell spans - * \param row_span Number of rows that current cell spans - * \param start_column Pointer to location to receive column index - * \param cell Box for current table cell - * \return true on success, false on memory exhaustion - */ - -bool calculate_table_row(struct columns *col_info, - unsigned int col_span, unsigned int row_span, - unsigned int *start_column, struct box *cell) -{ - unsigned int cell_start_col = col_info->current_column; - unsigned int cell_end_col; - unsigned int i; - struct span_info *spans; - struct box *rg = cell->parent->parent; /* Cell's row group */ + assert(table->style != NULL); - /* Skip columns with cells spanning from above */ - /* TODO: Need to ignore cells spanning from above that belong to - * different row group. We don't have that info here. */ - while (col_info->spans[cell_start_col].row_span != 0 && - col_info->spans[cell_start_col].rg == rg) { - cell_start_col++; - } + ctx.ctx = c->select_ctx; + ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); + ctx.base_url = c->base_url; + ctx.universal = c->universal; - /* Update current column with calculated start */ - col_info->current_column = cell_start_col; + style = nscss_get_blank_style(&ctx, table->style); + if (style == NULL) { + free(col_info.spans); + return false; + } - /* If this cell has a colspan of 0, then assume 1. - * No other browser supports colspan=0, anyway. */ - if (col_span == 0) - col_span = 1; + row_group = box_create(NULL, style, true, table->href, + table->target, NULL, NULL, c->bctx); + if (row_group == NULL) { + css_computed_style_destroy(style); + free(col_info.spans); + return false; + } + row_group->type = BOX_TABLE_ROW_GROUP; - cell_end_col = cell_start_col + col_span; + style = nscss_get_blank_style(&ctx, row_group->style); + if (style == NULL) { + box_free(row_group); + free(col_info.spans); + return false; + } - if (col_info->num_columns < cell_end_col) { - /* It appears that this row has more columns than - * the maximum recorded for the table so far. - * Allocate more span records. */ - spans = realloc(col_info->spans, - sizeof *spans * (cell_end_col + 1)); - if (spans == NULL) + row = box_create(NULL, style, true, row_group->href, + row_group->target, NULL, NULL, c->bctx); + if (row == NULL) { + css_computed_style_destroy(style); + box_free(row_group); + free(col_info.spans); return false; + } + row->type = BOX_TABLE_ROW; - col_info->spans = spans; - col_info->num_columns = cell_end_col; + row->parent = row_group; + row_group->children = row_group->last = row; - /* Mark new final column as sentinel */ - col_info->spans[cell_end_col].row_span = 0; - col_info->spans[cell_end_col].auto_row = false; + row_group->parent = table; + table->children = table->last = row_group; + + table->rows = 1; } - /* This cell may span multiple columns. If it also wants to span - * multiple rows, temporarily assume it spans 1 row only. This will - * be fixed up in box_normalise_table_spans() */ - for (i = cell_start_col; i < cell_end_col; i++) { - col_info->spans[i].row_span = (row_span == 0) ? 1 : row_span; - col_info->spans[i].auto_row = (row_span == 0); - col_info->spans[i].rg = rg; + if (box_normalise_table_spans(table, root, col_info.spans, c) == false) { + free(col_info.spans); + return false; } - /* Update current column with calculated end. */ - col_info->current_column = cell_end_col; + free(col_info.spans); - *start_column = cell_start_col; +#ifdef BOX_NORMALISE_DEBUG + NSLOG(netsurf, INFO, "table %p done", table); +#endif return true; } -bool box_normalise_inline_container( - struct box *cont, - const struct box *root, - html_content * c) +static bool +box_normalise_inline_container(struct box *cont, + const struct box *root, + html_content * c) { struct box *child; struct box *next_child; @@ -1045,3 +879,119 @@ bool box_normalise_inline_container( return true; } + + +/* Exported function documented in html/box_normalise.h */ +bool +box_normalise_block(struct box *block, const struct box *root, html_content *c) +{ + struct box *child; + struct box *next_child; + struct box *table; + css_computed_style *style; + nscss_select_ctx ctx; + + assert(block != NULL); + assert(root != NULL); + + ctx.root_style = root->style; + +#ifdef BOX_NORMALISE_DEBUG + NSLOG(netsurf, INFO, "block %p, block->type %u", block, block->type); +#endif + + assert(block->type == BOX_BLOCK || block->type == BOX_INLINE_BLOCK || + block->type == BOX_TABLE_CELL); + + for (child = block->children; child != NULL; child = next_child) { +#ifdef BOX_NORMALISE_DEBUG + NSLOG(netsurf, INFO, "child %p, child->type = %d", child, + child->type); +#endif + + next_child = child->next; /* child may be destroyed */ + + switch (child->type) { + case BOX_BLOCK: + /* ok */ + if (box_normalise_block(child, root, c) == false) + return false; + break; + case BOX_INLINE_CONTAINER: + if (box_normalise_inline_container(child, root, c) == false) + return false; + break; + case BOX_TABLE: + if (box_normalise_table(child, root, c) == false) + return false; + break; + case BOX_INLINE: + case BOX_INLINE_END: + case BOX_INLINE_BLOCK: + case BOX_FLOAT_LEFT: + case BOX_FLOAT_RIGHT: + case BOX_BR: + case BOX_TEXT: + /* should have been wrapped in inline + container by convert_xml_to_box() */ + assert(0); + break; + case BOX_TABLE_ROW_GROUP: + case BOX_TABLE_ROW: + case BOX_TABLE_CELL: + /* insert implied table */ + assert(block->style != NULL); + + ctx.ctx = c->select_ctx; + ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); + ctx.base_url = c->base_url; + ctx.universal = c->universal; + + style = nscss_get_blank_style(&ctx, block->style); + if (style == NULL) + return false; + + table = box_create(NULL, style, true, block->href, + block->target, NULL, NULL, c->bctx); + if (table == NULL) { + css_computed_style_destroy(style); + return false; + } + table->type = BOX_TABLE; + + if (child->prev == NULL) + block->children = table; + else + child->prev->next = table; + + table->prev = child->prev; + + while (child != NULL && ( + child->type == BOX_TABLE_ROW_GROUP || + child->type == BOX_TABLE_ROW || + child->type == BOX_TABLE_CELL)) { + box_add_child(table, child); + + next_child = child->next; + child->next = NULL; + child = next_child; + } + + table->last->next = NULL; + table->next = next_child = child; + if (table->next != NULL) + table->next->prev = table; + else + block->last = table; + table->parent = block; + + if (box_normalise_table(table, root, c) == false) + return false; + break; + default: + assert(0); + } + } + + return true; +} diff --git a/content/handlers/html/box_normalise.h b/content/handlers/html/box_normalise.h new file mode 100644 index 0000000..60f2591 --- /dev/null +++ b/content/handlers/html/box_normalise.h @@ -0,0 +1,50 @@ +/* + * Copyright 2020 Vincent Sanders <vince(a)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 + * HTML Box tree normalise interface. + */ + +#ifndef NETSURF_HTML_BOX_NORMALISE_H +#define NETSURF_HTML_BOX_NORMALISE_H + +/** + * Ensure the box tree is correctly nested by adding and removing nodes. + * + * \param block box of type BLOCK, INLINE_BLOCK, or TABLE_CELL + * \param root root box of document + * \param c content of boxes + * \return true on success, false on memory exhaustion + * + * The tree is modified to satisfy the following: + * \code + * parent permitted child nodes + * BLOCK, INLINE_BLOCK BLOCK, INLINE_CONTAINER, TABLE + * INLINE_CONTAINER INLINE, INLINE_BLOCK, FLOAT_LEFT, FLOAT_RIGHT, BR, TEXT + * INLINE, TEXT none + * TABLE at least 1 TABLE_ROW_GROUP + * TABLE_ROW_GROUP at least 1 TABLE_ROW + * TABLE_ROW at least 1 TABLE_CELL + * TABLE_CELL BLOCK, INLINE_CONTAINER, TABLE (same as BLOCK) + * FLOAT_(LEFT|RIGHT) exactly 1 BLOCK or TABLE + * \endcode + */ +bool box_normalise_block(struct box *block, const struct box *root, struct html_content *c); + +#endif diff --git a/content/handlers/html/html.c b/content/handlers/html/html.c index e445457..9b47858 100644 --- a/content/handlers/html/html.c +++ b/content/handlers/html/html.c @@ -60,6 +60,7 @@ #include "html/html_internal.h" #include "html/interaction.h" #include "html/box.h" +#include "html/box_construct.h" #include "html/form_internal.h" #include "html/imagemap.h" #include "html/layout.h" @@ -212,7 +213,7 @@ static void html_box_convert_done(html_content *c, bool success) dom_exception exc; /* returned by libdom functions */ dom_node *html; - NSLOG(netsurf, INFO, "Done XML to box (%p)", c); + NSLOG(netsurf, INFO, "DOM to box conversion complete (content %p)", c); c->box_conversion_context = NULL; diff --git a/content/handlers/html/imagemap.c b/content/handlers/html/imagemap.c index 0c35768..37095e2 100644 --- a/content/handlers/html/imagemap.c +++ b/content/handlers/html/imagemap.c @@ -36,6 +36,7 @@ #include "content/hlcache.h" #include "html/box.h" +#include "html/box_construct.h" #include "html/html_internal.h" #include "html/imagemap.h" ----------------------------------------------------------------------- Summary of changes: content/handlers/html/box.c | 199 ++------ content/handlers/html/box.h | 613 ++++++++++++++++------ content/handlers/html/box_construct.c | 92 ++-- content/handlers/html/box_construct.h | 65 +++ content/handlers/html/box_normalise.c | 904 ++++++++++++++++----------------- content/handlers/html/box_normalise.h | 50 ++ content/handlers/html/html.c | 3 +- content/handlers/html/imagemap.c | 1 + 8 files changed, 1082 insertions(+), 845 deletions(-) create mode 100644 content/handlers/html/box_construct.h create mode 100644 content/handlers/html/box_normalise.h diff --git a/content/handlers/html/box.c b/content/handlers/html/box.c index 94c7487..0ad1061 100644 --- a/content/handlers/html/box.c +++ b/content/handlers/html/box.c @@ -97,26 +97,17 @@ static int box_talloc_destructor(struct box *b) return 0; } -/** - * Create a box tree node. - * - * \param styles selection results for the box, or NULL - * \param style computed style for the box (not copied), or 0 - * \param style_owned whether style is owned by this box - * \param href href for the box (copied), or 0 - * \param target target for the box (not copied), or 0 - * \param title title for the box (not copied), or 0 - * \param id id for the box (not copied), or 0 - * \param context context for allocations - * \return allocated and initialised box, or 0 on memory exhaustion - * - * styles is always owned by the box, if it is set. - * style is only owned by the box in the case of implied boxes. - */ -struct box * box_create(css_select_results *styles, css_computed_style *style, - bool style_owned, nsurl *href, const char *target, - const char *title, lwc_string *id, void *context) +/* Exported function documented in html/box.h */ +struct box * +box_create(css_select_results *styles, + css_computed_style *style, + bool style_owned, + nsurl *href, + const char *target, + const char *title, + lwc_string *id, + void *context) { unsigned int i; struct box *box; @@ -177,13 +168,8 @@ struct box * box_create(css_select_results *styles, css_computed_style *style, return box; } -/** - * Add a child to a box tree node. - * - * \param parent box giving birth - * \param child box to link as last child of parent - */ +/* Exported function documented in html/box.h */ void box_add_child(struct box *parent, struct box *child) { assert(parent); @@ -202,13 +188,7 @@ void box_add_child(struct box *parent, struct box *child) } -/** - * Insert a new box as a sibling to a box in a tree. - * - * \param box box already in tree - * \param new_box box to link into tree as next sibling - */ - +/* Exported function documented in html/box.h */ void box_insert_sibling(struct box *box, struct box *new_box) { new_box->parent = box->parent; @@ -222,12 +202,7 @@ void box_insert_sibling(struct box *box, struct box *new_box) } -/** - * Unlink a box from the box tree and then free it recursively. - * - * \param box box to unlink and free recursively. - */ - +/* Exported function documented in html/box.h */ void box_unlink_and_free(struct box *box) { struct box *parent = box->parent; @@ -250,14 +225,7 @@ void box_unlink_and_free(struct box *box) } -/** - * Free a box tree recursively. - * - * \param box box to free recursively - * - * The box and all its children is freed. - */ - +/* Exported function documented in html/box.h */ void box_free(struct box *box) { struct box *child, *next; @@ -273,12 +241,7 @@ void box_free(struct box *box) } -/** - * Free the data in a single box structure. - * - * \param box box to free - */ - +/* Exported function documented in html/box.h */ void box_free_box(struct box *box) { if (!(box->flags & CLONE)) { @@ -296,14 +259,7 @@ void box_free_box(struct box *box) } -/** - * Find the absolute coordinates of a box. - * - * \param box the box to calculate coordinates of - * \param x updated to x coordinate - * \param y updated to y coordinate - */ - +/* Exported function documented in html/box.h */ void box_coords(struct box *box, int *x, int *y) { *x = box->x; @@ -321,13 +277,7 @@ void box_coords(struct box *box, int *x, int *y) } -/** - * Find the bounds of a box. - * - * \param box the box to calculate bounds of - * \param r receives bounds - */ - +/* Exported function documented in html/box.h */ void box_bounds(struct box *box, struct rect *r) { int width, height; @@ -359,7 +309,6 @@ void box_bounds(struct box *box, struct rect *r) * * This is a helper function for box_at_point(). */ - static bool box_contains_point( const nscss_len_ctx *len_ctx, const struct box *box, @@ -471,7 +420,9 @@ static bool box_contains_point( } -/** Direction to move in a box-tree walk */ +/** + * Direction to move in a box-tree walk + */ enum box_walk_dir { BOX_WALK_CHILDREN, BOX_WALK_PARENT, @@ -492,8 +443,8 @@ enum box_walk_dir { * * If no box can be found in given direction, NULL is returned. */ -static inline struct box *box_move_xy(struct box *b, enum box_walk_dir dir, - int *x, int *y) +static inline struct box * +box_move_xy(struct box *b, enum box_walk_dir dir, int *x, int *y) { struct box *rb = NULL; @@ -665,35 +616,12 @@ skip_children: } - -/** - * Find the boxes at a point. - * - * \param len_ctx CSS length conversion context for document. - * \param box box to search children of - * \param x point to find, in global document coordinates - * \param y point to find, in global document coordinates - * \param box_x position of box, in global document coordinates, updated - * to position of returned box, if any - * \param box_y position of box, in global document coordinates, updated - * to position of returned box, if any - * \return box at given point, or 0 if none found - * - * To find all the boxes in the hierarchy at a certain point, use code like - * this: - * \code - * struct box *box = top_of_document_to_search; - * int box_x = 0, box_y = 0; - * - * while ((box = box_at_point(len_ctx, box, x, y, &box_x, &box_y))) { - * // process box - * } - * \endcode - */ - -struct box *box_at_point(const nscss_len_ctx *len_ctx, - struct box *box, const int x, const int y, - int *box_x, int *box_y) +/* Exported function documented in html/box.h */ +struct box * +box_at_point(const nscss_len_ctx *len_ctx, + struct box *box, + const int x, const int y, + int *box_x, int *box_y) { bool skip_children; bool physically; @@ -742,10 +670,14 @@ struct box *box_at_point(const nscss_len_ctx *len_ctx, * updated if box is nearer than existing nearest * \return true if mouse point is inside box */ - -static bool box_nearer_text_box(struct box *box, int bx, int by, - int x, int y, int dir, struct box **nearest, int *tx, int *ty, - int *nr_xd, int *nr_yd) +static bool +box_nearer_text_box(struct box *box, + int bx, int by, + int x, int y, + int dir, + struct box **nearest, + int *tx, int *ty, + int *nr_xd, int *nr_yd) { int w = box->padding[LEFT] + box->width + box->padding[RIGHT]; int h = box->padding[TOP] + box->height + box->padding[BOTTOM]; @@ -814,7 +746,6 @@ static bool box_nearer_text_box(struct box *box, int bx, int by, * updated if a descendant of box is nearer than old nearest * \return true if mouse point is inside text_box */ - static bool box_nearest_text_box(struct box *box, int bx, int by, int fx, int fy, int x, int y, int dir, struct box **nearest, int *tx, int *ty, int *nr_xd, int *nr_yd) @@ -885,21 +816,12 @@ static bool box_nearest_text_box(struct box *box, int bx, int by, } -/** - * Peform pick text on browser window contents to locate the box under - * the mouse pointer, or nearest in the given direction if the pointer is - * not over a text box. - * - * \param html an HTML content - * \param x coordinate of mouse - * \param y coordinate of mouse - * \param dir direction to search (-1 = above-left, +1 = below-right) - * \param dx receives x ordinate of mouse relative to text box - * \param dy receives y ordinate of mouse relative to text box - */ - -struct box *box_pick_text_box(struct html_content *html, - int x, int y, int dir, int *dx, int *dy) +/* Exported function documented in html/box.h */ +struct box * +box_pick_text_box(struct html_content *html, + int x, int y, + int dir, + int *dx, int *dy) { struct box *text_box = NULL; struct box *box; @@ -947,14 +869,7 @@ struct box *box_pick_text_box(struct html_content *html, } -/** - * Find a box based upon its id attribute. - * - * \param box box tree to search - * \param id id to look for - * \return the box or 0 if not found - */ - +/* Exported function documented in html/box.h */ struct box *box_find_by_id(struct box *box, lwc_string *id) { struct box *a, *b; @@ -974,13 +889,7 @@ struct box *box_find_by_id(struct box *box, lwc_string *id) } -/** - * Determine if a box is visible when the tree is rendered. - * - * \param box box to check - * \return true iff the box is rendered - */ - +/* Exported function documented in html/box.h */ bool box_visible(struct box *box) { /* visibility: hidden */ @@ -992,10 +901,7 @@ bool box_visible(struct box *box) } -/** - * Print a box tree to a file. - */ - +/* Exported function documented in html/box.h */ void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style) { unsigned int i; @@ -1218,13 +1124,8 @@ box_handle_scrollbars(struct content *c, return NSERROR_OK; } -/** - * Determine if a box has a vertical scrollbar. - * - * \param box scrolling box - * \return the box has a vertical scrollbar - */ +/* exported interface documented in html/box.h */ bool box_vscrollbar_present(const struct box * const box) { return box->padding[TOP] + box->height + box->padding[BOTTOM] + @@ -1232,13 +1133,7 @@ bool box_vscrollbar_present(const struct box * const box) } -/** - * Determine if a box has a horizontal scrollbar. - * - * \param box scrolling box - * \return the box has a horizontal scrollbar - */ - +/* exported interface documented in html/box.h */ bool box_hscrollbar_present(const struct box * const box) { return box->padding[LEFT] + box->width + box->padding[RIGHT] + diff --git a/content/handlers/html/box.h b/content/handlers/html/box.h index efad90f..1781d13 100644 --- a/content/handlers/html/box.h +++ b/content/handlers/html/box.h @@ -19,7 +19,7 @@ /** * \file - * Box tree construction and manipulation (interface). + * Box tree construction and manipulation interface. * * This stage of rendering converts a tree of dom_nodes (produced by libdom) * to a tree of struct box. The box tree represents the structure of the @@ -97,9 +97,6 @@ struct content; struct box; struct browser_window; -struct column; -struct object_params; -struct object_param; struct html_content; struct nsurl; struct dom_node; @@ -109,20 +106,34 @@ struct rect; #define UNKNOWN_WIDTH INT_MAX #define UNKNOWN_MAX_WIDTH INT_MAX + typedef void (*box_construct_complete_cb)(struct html_content *c, bool success); -/** Type of a struct box. */ + +/** + * Type of a struct box. + */ typedef enum { - BOX_BLOCK, BOX_INLINE_CONTAINER, BOX_INLINE, - BOX_TABLE, BOX_TABLE_ROW, BOX_TABLE_CELL, + BOX_BLOCK, + BOX_INLINE_CONTAINER, + BOX_INLINE, + BOX_TABLE, + BOX_TABLE_ROW, + BOX_TABLE_CELL, BOX_TABLE_ROW_GROUP, - BOX_FLOAT_LEFT, BOX_FLOAT_RIGHT, - BOX_INLINE_BLOCK, BOX_BR, BOX_TEXT, - BOX_INLINE_END, BOX_NONE + BOX_FLOAT_LEFT, + BOX_FLOAT_RIGHT, + BOX_INLINE_BLOCK, + BOX_BR, + BOX_TEXT, + BOX_INLINE_END, + BOX_NONE } box_type; -/** Flags for a struct box. */ +/** + * Flags for a struct box. + */ typedef enum { NEW_LINE = 1 << 0, /* first inline on a new line */ STYLE_OWNED = 1 << 1, /* style is owned by this box */ @@ -139,9 +150,13 @@ typedef enum { IS_REPLACED = 1 << 12 /* box is a replaced element */ } box_flags; -/* Sides of a box */ + +/** + * Sides of a box + */ enum box_side { TOP, RIGHT, BOTTOM, LEFT }; + /** * Container for box border details */ @@ -151,31 +166,190 @@ struct box_border { int width; /**< border-width (pixels) */ }; -/** Node in box tree. All dimensions are in pixels. */ + +/** + * Table column data. + */ +struct column { + /** + * Type of column. + */ + enum { + COLUMN_WIDTH_UNKNOWN, + COLUMN_WIDTH_FIXED, + COLUMN_WIDTH_AUTO, + COLUMN_WIDTH_PERCENT, + COLUMN_WIDTH_RELATIVE + } type; + + /** + * Preferred width of column. Pixels for FIXED, percentage for + * PERCENT, relative units for RELATIVE, unused for AUTO. + */ + int width; + + /** + * Minimum width of content. + */ + int min; + + /** + * Maximum width of content. + */ + int max; + + /** + * Whether all of column's cells are css positioned. + */ + bool positioned; +}; + + +/** + * Linked list of object element parameters. + */ +struct object_param { + char *name; + char *value; + char *type; + char *valuetype; + struct object_param *next; +}; + + +/** + * Parameters for object element and similar elements. + */ +struct object_params { + struct nsurl *data; + char *type; + char *codetype; + struct nsurl *codebase; + struct nsurl *classid; + struct object_param *params; +}; + + +/** + * Node in box tree. All dimensions are in pixels. + */ struct box { - /** Type of box. */ + /** + * Type of box. + */ box_type type; - /** Box flags */ + /** + * Box flags + */ box_flags flags; - /** Computed styles for elements and their pseudo elements. NULL on - * non-element boxes. */ + /** + * DOM node that generated this box or NULL + */ + struct dom_node *node; + + /** + * Computed styles for elements and their pseudo elements. + * NULL on non-element boxes. + */ css_select_results *styles; - /** Style for this box. 0 for INLINE_CONTAINER and FLOAT_*. Pointer into - * a box's 'styles' select results, except for implied boxes, where it - * is a pointer to an owned computed style. */ + /** + * Style for this box. 0 for INLINE_CONTAINER and + * FLOAT_*. Pointer into a box's 'styles' select results, + * except for implied boxes, where it is a pointer to an + * owned computed style. + */ css_computed_style *style; - /** Coordinate of left padding edge relative to parent box, or relative - * to ancestor that contains this box in float_children for FLOAT_. */ + /** + * value of id attribute (or name for anchors) + */ + lwc_string *id; + + + /** + * Next sibling box, or NULL. + */ + struct box *next; + + /** + * Previous sibling box, or NULL. + */ + struct box *prev; + + /** + * First child box, or NULL. + */ + struct box *children; + + /** + * Last child box, or NULL. + */ + struct box *last; + + /** + * Parent box, or NULL. + */ + struct box *parent; + + /** + * INLINE_END box corresponding to this INLINE box, or INLINE + * box corresponding to this INLINE_END box. + */ + struct box *inline_end; + + + /** + * First float child box, or NULL. Float boxes are in the tree + * twice, in this list for the block box which defines the + * area for floats, and also in the standard tree given by + * children, next, prev, etc. + */ + struct box *float_children; + + /** + * Next sibling float box. + */ + struct box *next_float; + + /** + * If box is a float, points to box's containing block + */ + struct box *float_container; + + /** + * Level below which subsequent floats must be cleared. This + * is used only for boxes with float_children + */ + int clear_level; + + /** + * Level below which floats have been placed. + */ + int cached_place_below_level; + + + /** + * Coordinate of left padding edge relative to parent box, or + * relative to ancestor that contains this box in + * float_children for FLOAT_. + */ int x; - /** Coordinate of top padding edge, relative as for x. */ + /** + * Coordinate of top padding edge, relative as for x. + */ int y; - int width; /**< Width of content box (excluding padding etc.). */ - int height; /**< Height of content box (excluding padding etc.). */ + /** + * Width of content box (excluding padding etc.). + */ + int width; + /** + * Height of content box (excluding padding etc.). + */ + int height; /* These four variables determine the maximum extent of a box's * descendants. They are relative to the x,y coordinates of the box. @@ -196,123 +370,146 @@ struct box { int descendant_x1; /**< right edge of descendants */ int descendant_y1; /**< bottom edge of descendants */ - int margin[4]; /**< Margin: TOP, RIGHT, BOTTOM, LEFT. */ - int padding[4]; /**< Padding: TOP, RIGHT, BOTTOM, LEFT. */ - struct box_border border[4]; /**< Border: TOP, RIGHT, BOTTOM, LEFT. */ + /** + * Margin: TOP, RIGHT, BOTTOM, LEFT. + */ + int margin[4]; + + /** + * Padding: TOP, RIGHT, BOTTOM, LEFT. + */ + int padding[4]; + + /** + * Border: TOP, RIGHT, BOTTOM, LEFT. + */ + struct box_border border[4]; + + /** + * Horizontal scroll. + */ + struct scrollbar *scroll_x; - struct scrollbar *scroll_x; /**< Horizontal scroll. */ - struct scrollbar *scroll_y; /**< Vertical scroll. */ + /** + * Vertical scroll. + */ + struct scrollbar *scroll_y; - /** Width of box taking all line breaks (including margins etc). Must - * be non-negative. */ + /** + * Width of box taking all line breaks (including margins + * etc). Must be non-negative. + */ int min_width; - /** Width that would be taken with no line breaks. Must be - * non-negative. */ + + /** + * Width that would be taken with no line breaks. Must be + * non-negative. + */ int max_width; - /**< Byte offset within a textual representation of this content. */ - size_t byte_offset; - char *text; /**< Text, or 0 if none. Unterminated. */ - size_t length; /**< Length of text. */ + /** + * Text, or NULL if none. Unterminated. + */ + char *text; + + /** + * Length of text. + */ + size_t length; - /** Width of space after current text (depends on font and size). */ + /** + * Width of space after current text (depends on font and size). + */ int space; - struct nsurl *href; /**< Link, or 0. */ - const char *target; /**< Link target, or 0. */ - const char *title; /**< Title, or 0. */ - - unsigned int columns; /**< Number of columns for TABLE / TABLE_CELL. */ - unsigned int rows; /**< Number of rows for TABLE only. */ - unsigned int start_column; /**< Start column for TABLE_CELL only. */ - - struct box *next; /**< Next sibling box, or 0. */ - struct box *prev; /**< Previous sibling box, or 0. */ - struct box *children; /**< First child box, or 0. */ - struct box *last; /**< Last child box, or 0. */ - struct box *parent; /**< Parent box, or 0. */ - /** INLINE_END box corresponding to this INLINE box, or INLINE box - * corresponding to this INLINE_END box. */ - struct box *inline_end; + /** + * Byte offset within a textual representation of this content. + */ + size_t byte_offset; - /** First float child box, or 0. Float boxes are in the tree twice, in - * this list for the block box which defines the area for floats, and - * also in the standard tree given by children, next, prev, etc. */ - struct box *float_children; - /** Next sibling float box. */ - struct box *next_float; - /** If box is a float, points to box's containing block */ - struct box *float_container; - /** Level below which subsequent floats must be cleared. - * This is used only for boxes with float_children */ - int clear_level; - /* Level below which floats have been placed. */ - int cached_place_below_level; + /** + * Link, or NULL. + */ + struct nsurl *href; + + /** + * Link target, or NULL. + */ + const char *target; - /** List marker box if this is a list-item, or 0. */ + /** + * Title, or NULL. + */ + const char *title; + + + /** + * Number of columns for TABLE / TABLE_CELL. + */ + unsigned int columns; + + /** + * Number of rows for TABLE only. + */ + unsigned int rows; + + /** + * Start column for TABLE_CELL only. + */ + unsigned int start_column; + + /** + * Array of table column data for TABLE only. + */ + struct column *col; + + + /** + * List marker box if this is a list-item, or NULL. + */ struct box *list_marker; - struct column *col; /**< Array of table column data for TABLE only. */ - /** Form control data, or 0 if not a form control. */ + /** + * Form control data, or NULL if not a form control. + */ struct form_control* gadget; - char *usemap; /** (Image)map to use with this object, or 0 if none */ - lwc_string *id; /**< value of id attribute (or name for anchors) */ - /** Background image for this box, or 0 if none */ + /** + * (Image)map to use with this object, or NULL if none + */ + char *usemap; + + + /** + * Background image for this box, or NULL if none + */ struct hlcache_handle *background; - /** Object in this box (usually an image), or 0 if none. */ + + /** + * Object in this box (usually an image), or NULL if none. + */ struct hlcache_handle* object; - /** Parameters for the object, or 0. */ - struct object_params *object_params; - /** Iframe's browser_window, or NULL if none */ - struct browser_window *iframe; + /** + * Parameters for the object, or NULL. + */ + struct object_params *object_params; - struct dom_node *node; /**< DOM node that generated this box or NULL */ -}; -/** Table column data. */ -struct column { - /** Type of column. */ - enum { COLUMN_WIDTH_UNKNOWN, COLUMN_WIDTH_FIXED, - COLUMN_WIDTH_AUTO, COLUMN_WIDTH_PERCENT, - COLUMN_WIDTH_RELATIVE } type; - /** Preferred width of column. Pixels for FIXED, percentage for PERCENT, - * relative units for RELATIVE, unused for AUTO. */ - int width; - /** Minimum width of content. */ - int min; - /** Maximum width of content. */ - int max; - /** Whether all of column's cells are css positioned. */ - bool positioned; -}; + /** + * Iframe's browser_window, or NULL if none + */ + struct browser_window *iframe; -/** Parameters for object element and similar elements. */ -struct object_params { - struct nsurl *data; - char *type; - char *codetype; - struct nsurl *codebase; - struct nsurl *classid; - struct object_param *params; }; -/** Linked list of object element parameters. */ -struct object_param { - char *name; - char *value; - char *type; - char *valuetype; - struct object_param *next; -}; -/** Frame target names (constant pointers to save duplicating the strings many +/* Frame target names (constant pointers to save duplicating the strings many * times). We convert _blank to _top for user-friendliness. */ extern const char *TARGET_SELF; extern const char *TARGET_PARENT; @@ -320,38 +517,154 @@ extern const char *TARGET_TOP; extern const char *TARGET_BLANK; +/** + * Create a box tree node. + * + * \param styles selection results for the box, or NULL + * \param style computed style for the box (not copied), or 0 + * \param style_owned whether style is owned by this box + * \param href href for the box (copied), or 0 + * \param target target for the box (not copied), or 0 + * \param title title for the box (not copied), or 0 + * \param id id for the box (not copied), or 0 + * \param context context for allocations + * \return allocated and initialised box, or 0 on memory exhaustion + * + * styles is always owned by the box, if it is set. + * style is only owned by the box in the case of implied boxes. + */ +struct box * box_create(css_select_results *styles, css_computed_style *style, bool style_owned, struct nsurl *href, const char *target, const char *title, lwc_string *id, void *context); + -struct box * box_create(css_select_results *styles, css_computed_style *style, - bool style_owned, struct nsurl *href, const char *target, - const char *title, lwc_string *id, void *context); +/** + * Add a child to a box tree node. + * + * \param parent box giving birth + * \param child box to link as last child of parent + */ void box_add_child(struct box *parent, struct box *child); + + +/** + * Insert a new box as a sibling to a box in a tree. + * + * \param box box already in tree + * \param new_box box to link into tree as next sibling + */ void box_insert_sibling(struct box *box, struct box *new_box); + + +/** + * Unlink a box from the box tree and then free it recursively. + * + * \param box box to unlink and free recursively. + */ void box_unlink_and_free(struct box *box); + + +/** + * Free a box tree recursively. + * + * \param box box to free recursively + * + * The box and all its children is freed. + */ void box_free(struct box *box); + + +/** + * Free the data in a single box structure. + * + * \param box box to free + */ void box_free_box(struct box *box); -void box_bounds(struct box *box, struct rect *r); + + +/** + * Find the absolute coordinates of a box. + * + * \param box the box to calculate coordinates of + * \param x updated to x coordinate + * \param y updated to y coordinate + */ void box_coords(struct box *box, int *x, int *y); -struct box *box_at_point( - const nscss_len_ctx *len_ctx, - struct box *box, const int x, const int y, - int *box_x, int *box_y); -struct box *box_pick_text_box(struct html_content *html, - int x, int y, int dir, int *dx, int *dy); + + +/** + * Find the bounds of a box. + * + * \param box the box to calculate bounds of + * \param r receives bounds + */ +void box_bounds(struct box *box, struct rect *r); + + +/** + * Find the boxes at a point. + * + * \param len_ctx CSS length conversion context for document. + * \param box box to search children of + * \param x point to find, in global document coordinates + * \param y point to find, in global document coordinates + * \param box_x position of box, in global document coordinates, updated + * to position of returned box, if any + * \param box_y position of box, in global document coordinates, updated + * to position of returned box, if any + * \return box at given point, or 0 if none found + * + * To find all the boxes in the hierarchy at a certain point, use code like + * this: + * \code + * struct box *box = top_of_document_to_search; + * int box_x = 0, box_y = 0; + * + * while ((box = box_at_point(len_ctx, box, x, y, &box_x, &box_y))) { + * // process box + * } + * \endcode + */ +struct box *box_at_point(const nscss_len_ctx *len_ctx, struct box *box, const int x, const int y, int *box_x, int *box_y); + + +/** + * Peform pick text on browser window contents to locate the box under + * the mouse pointer, or nearest in the given direction if the pointer is + * not over a text box. + * + * \param html an HTML content + * \param x coordinate of mouse + * \param y coordinate of mouse + * \param dir direction to search (-1 = above-left, +1 = below-right) + * \param dx receives x ordinate of mouse relative to text box + * \param dy receives y ordinate of mouse relative to text box + */ +struct box *box_pick_text_box(struct html_content *html, int x, int y, int dir, int *dx, int *dy); + + +/** + * Find a box based upon its id attribute. + * + * \param box box tree to search + * \param id id to look for + * \return the box or 0 if not found + */ struct box *box_find_by_id(struct box *box, lwc_string *id); + + +/** + * Determine if a box is visible when the tree is rendered. + * + * \param box box to check + * \return true iff the box is rendered + */ bool box_visible(struct box *box); -void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style); + /** - * Extract a URL from a relative link, handling junk like whitespace and - * attempting to read a real URL from "javascript:" links. - * - * \param content html content - * \param dsrel relative URL text taken from page - * \param base base for relative URLs - * \param result updated to target URL on heap, unchanged if extract failed - * \return true on success, false on memory exhaustion + * Print a box tree to a file. */ -bool box_extract_link(const struct html_content *content, const struct dom_string *dsrel, struct nsurl *base, struct nsurl **result); +void box_dump(FILE *stream, struct box *box, unsigned int depth, bool style); + /** * Applies the given scroll setup to a box. This includes scroll @@ -366,29 +679,24 @@ bool box_extract_link(const struct html_content *content, const struct dom_strin nserror box_handle_scrollbars(struct content *c, struct box *box, bool bottom, bool right); -bool box_vscrollbar_present(const struct box *box); -bool box_hscrollbar_present(const struct box *box); /** - * Construct a box tree from an xml tree and stylesheets. + * Determine if a box has a vertical scrollbar. * - * \param n xml tree - * \param c content of type CONTENT_HTML to construct box tree in - * \param cb callback to report conversion completion - * \return netsurf error code indicating status of call + * \param box scrolling box + * \return the box has a vertical scrollbar */ -nserror dom_to_box(struct dom_node *n, struct html_content *c, - box_construct_complete_cb cb, void **box_conversion_context); +bool box_vscrollbar_present(const struct box *box); + /** - * aborts any ongoing box construction + * Determine if a box has a horizontal scrollbar. + * + * \param box scrolling box + * \return the box has a horizontal scrollbar */ -nserror cancel_dom_to_box(void *box_conversion_context); +bool box_hscrollbar_present(const struct box *box); -bool box_normalise_block( - struct box *block, - const struct box *root, - struct html_content *c); /** * Check if layout box is a first child. @@ -401,12 +709,5 @@ static inline bool box_is_first_child(struct box *b) return (b->parent == NULL || b == b->parent->children); } -/** - * Retrieve the box for a dom node, if there is one - * - * \param node The DOM node - * \return The box if there is one - */ -struct box *box_for_node(struct dom_node *node); #endif diff --git a/content/handlers/html/box_construct.c b/content/handlers/html/box_construct.c index 16154cb..a833302 100644 --- a/content/handlers/html/box_construct.c +++ b/content/handlers/html/box_construct.c @@ -51,6 +51,8 @@ #include "html/html.h" #include "html/box.h" +#include "html/box_construct.h" +#include "html/box_normalise.h" #include "html/box_textarea.h" #include "html/form_internal.h" #include "html/html_internal.h" @@ -878,6 +880,25 @@ box_button(dom_node *n, /** + * Canvas element + */ +static bool +box_canvas(dom_node *n, + html_content *content, + struct box *box, + bool *convert_children) +{ + /* If scripting is not enabled display the contents of canvas */ + if (!content->enable_scripting) { + return true; + } + *convert_children = false; + + return true; +} + + +/** * Embedded object (not in any HTML specification: * see http://wp.netscape.com/assist/net_sites/new_html3_prop.html ) */ @@ -2258,6 +2279,10 @@ convert_special_elements(dom_node *node, res = box_button(node, content, box, convert_children); break; + case DOM_HTML_ELEMENT_TYPE_CANVAS: + res = box_canvas(node, content, box, convert_children); + break; + case DOM_HTML_ELEMENT_TYPE_EMBED: res = box_embed(node, content, box, convert_children); break; @@ -2454,9 +2479,10 @@ box_construct_element(struct box_construct_ctx *ctx, bool *convert_children) box->styles->styles[CSS_PSEUDO_ELEMENT_BEFORE]); } - if (box->type == BOX_NONE || (ns_computed_display(box->style, - props.node_is_root) == CSS_DISPLAY_NONE && - props.node_is_root == false)) { + if (box->type == BOX_NONE || + (ns_computed_display(box->style, + props.node_is_root) == CSS_DISPLAY_NONE && + props.node_is_root == false)) { css_select_results_destroy(styles); box->styles = NULL; box->style = NULL; @@ -3139,7 +3165,7 @@ static void convert_xml_to_box(struct box_construct_ctx *ctx) } -/* Exported function, documented in box.h */ +/* exported function documented in html/box_construct.h */ nserror dom_to_box(dom_node *n, html_content *c, @@ -3175,7 +3201,7 @@ dom_to_box(dom_node *n, } -/* Exported function, see box.h */ +/* exported function documented in html/box_construct.h */ nserror cancel_dom_to_box(void *box_conversion_context) { struct box_construct_ctx *ctx = box_conversion_context; @@ -3193,7 +3219,7 @@ nserror cancel_dom_to_box(void *box_conversion_context) } -/* Exported function, see box.h */ +/* exported function documented in html/box_construct.h */ struct box *box_for_node(dom_node *n) { struct box *box = NULL; @@ -3208,59 +3234,7 @@ struct box *box_for_node(dom_node *n) } - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -/* exported function documented in html/box.h */ +/* exported function documented in html/box_construct.h */ bool box_extract_link(const html_content *content, const dom_string *dsrel, diff --git a/content/handlers/html/box_construct.h b/content/handlers/html/box_construct.h new file mode 100644 index 0000000..e93f515 --- /dev/null +++ b/content/handlers/html/box_construct.h @@ -0,0 +1,65 @@ +/* + * Copyright 2020 Vincent Sanders <vince(a)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 + * HTML Box tree construction interface. + */ + +#ifndef NETSURF_HTML_BOX_CONSTRUCT_H +#define NETSURF_HTML_BOX_CONSTRUCT_H + +/** + * Construct a box tree from a dom and html content + * + * \param n dom document + * \param c content of type CONTENT_HTML to construct box tree in + * \param cb callback to report conversion completion + * \param box_conversion_context pointer that recives the conversion context + * \return netsurf error code indicating status of call + */ +nserror dom_to_box(struct dom_node *n, struct html_content *c, box_construct_complete_cb cb, void **box_conversion_context); + + +/** + * aborts any ongoing box construction + */ +nserror cancel_dom_to_box(void *box_conversion_context); + + +/** + * Retrieve the box for a dom node, if there is one + * + * \param node The DOM node + * \return The box if there is one + */ +struct box *box_for_node(struct dom_node *node); + +/** + * Extract a URL from a relative link, handling junk like whitespace and + * attempting to read a real URL from "javascript:" links. + * + * \param content html content + * \param dsrel relative URL text taken from page + * \param base base for relative URLs + * \param result updated to target URL on heap, unchanged if extract failed + * \return true on success, false on memory exhaustion + */ +bool box_extract_link(const struct html_content *content, const struct dom_string *dsrel, struct nsurl *base, struct nsurl **result); + +#endif diff --git a/content/handlers/html/box_normalise.c b/content/handlers/html/box_normalise.c index 7155cb7..03fe731 100644 --- a/content/handlers/html/box_normalise.c +++ b/content/handlers/html/box_normalise.c @@ -21,7 +21,7 @@ /** * \file - * Box tree normalisation (implementation). + * Box tree normalisation implementation. */ #include <assert.h> @@ -33,6 +33,7 @@ #include "css/select.h" #include "html/box.h" +#include "html/box_normalise.h" #include "html/html_internal.h" #include "html/table.h" @@ -66,279 +67,310 @@ struct columns { }; -static bool box_normalise_table( - struct box *table, - const struct box *root, - html_content *c); -static bool box_normalise_table_spans( - struct box *table, - const struct box *root, - struct span_info *spans, - html_content *c); -static bool box_normalise_table_row_group( - struct box *row_group, - const struct box *root, - struct columns *col_info, - html_content *c); -static bool box_normalise_table_row( - struct box *row, - const struct box *root, - struct columns *col_info, - html_content *c); -static bool calculate_table_row(struct columns *col_info, - unsigned int col_span, unsigned int row_span, - unsigned int *start_column, struct box *cell); -static bool box_normalise_inline_container( - struct box *cont, - const struct box *root, - html_content *c); - /** - * Ensure the box tree is correctly nested by adding and removing nodes. - * - * \param block box of type BLOCK, INLINE_BLOCK, or TABLE_CELL - * \param root root box of document - * \param c content of boxes - * \return true on success, false on memory exhaustion + * Compute the column index at which the current cell begins. + * Additionally, update the column record to reflect row spanning. * - * The tree is modified to satisfy the following: - * \code - * parent permitted child nodes - * BLOCK, INLINE_BLOCK BLOCK, INLINE_CONTAINER, TABLE - * INLINE_CONTAINER INLINE, INLINE_BLOCK, FLOAT_LEFT, FLOAT_RIGHT, BR, TEXT - * INLINE, TEXT none - * TABLE at least 1 TABLE_ROW_GROUP - * TABLE_ROW_GROUP at least 1 TABLE_ROW - * TABLE_ROW at least 1 TABLE_CELL - * TABLE_CELL BLOCK, INLINE_CONTAINER, TABLE (same as BLOCK) - * FLOAT_(LEFT|RIGHT) exactly 1 BLOCK or TABLE - * \endcode + * \param col_info Column record + * \param col_span Number of columns that current cell spans + * \param row_span Number of rows that current cell spans + * \param start_column Pointer to location to receive column index + * \param cell Box for current table cell + * \return true on success, false on memory exhaustion */ +static bool +calculate_table_row(struct columns *col_info, + unsigned int col_span, + unsigned int row_span, + unsigned int *start_column, + struct box *cell) +{ + unsigned int cell_start_col = col_info->current_column; + unsigned int cell_end_col; + unsigned int i; + struct span_info *spans; + struct box *rg = cell->parent->parent; /* Cell's row group */ + + /* Skip columns with cells spanning from above */ + /* TODO: Need to ignore cells spanning from above that belong to + * different row group. We don't have that info here. */ + while (col_info->spans[cell_start_col].row_span != 0 && + col_info->spans[cell_start_col].rg == rg) { + cell_start_col++; + } + + /* Update current column with calculated start */ + col_info->current_column = cell_start_col; + + /* If this cell has a colspan of 0, then assume 1. + * No other browser supports colspan=0, anyway. */ + if (col_span == 0) + col_span = 1; + + cell_end_col = cell_start_col + col_span; + + if (col_info->num_columns < cell_end_col) { + /* It appears that this row has more columns than + * the maximum recorded for the table so far. + * Allocate more span records. */ + spans = realloc(col_info->spans, + sizeof *spans * (cell_end_col + 1)); + if (spans == NULL) + return false; + + col_info->spans = spans; + col_info->num_columns = cell_end_col; + + /* Mark new final column as sentinel */ + col_info->spans[cell_end_col].row_span = 0; + col_info->spans[cell_end_col].auto_row = false; + } + + /* This cell may span multiple columns. If it also wants to span + * multiple rows, temporarily assume it spans 1 row only. This will + * be fixed up in box_normalise_table_spans() */ + for (i = cell_start_col; i < cell_end_col; i++) { + col_info->spans[i].row_span = (row_span == 0) ? 1 : row_span; + col_info->spans[i].auto_row = (row_span == 0); + col_info->spans[i].rg = rg; + } + + /* Update current column with calculated end. */ + col_info->current_column = cell_end_col; + + *start_column = cell_start_col; -bool box_normalise_block( - struct box *block, - const struct box *root, - html_content *c) + return true; +} + + +static bool +box_normalise_table_row(struct box *row, + const struct box *root, + struct columns *col_info, + html_content * c) { struct box *child; struct box *next_child; - struct box *table; + struct box *cell = NULL; css_computed_style *style; + unsigned int i; nscss_select_ctx ctx; - assert(block != NULL); - assert(root != NULL); + assert(row != NULL); + assert(row->type == BOX_TABLE_ROW); ctx.root_style = root->style; #ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "block %p, block->type %u", block, block->type); -#endif - - assert(block->type == BOX_BLOCK || block->type == BOX_INLINE_BLOCK || - block->type == BOX_TABLE_CELL); - - for (child = block->children; child != NULL; child = next_child) { -#ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "child %p, child->type = %d", child, - child->type); + NSLOG(netsurf, INFO, "row %p", row); #endif - next_child = child->next; /* child may be destroyed */ + for (child = row->children; child != NULL; child = next_child) { + next_child = child->next; switch (child->type) { - case BOX_BLOCK: + case BOX_TABLE_CELL: /* ok */ if (box_normalise_block(child, root, c) == false) return false; + cell = child; break; + case BOX_BLOCK: case BOX_INLINE_CONTAINER: - if (box_normalise_inline_container(child, root, c) == false) - return false; - break; case BOX_TABLE: - if (box_normalise_table(child, root, c) == false) - return false; - break; - case BOX_INLINE: - case BOX_INLINE_END: - case BOX_INLINE_BLOCK: - case BOX_FLOAT_LEFT: - case BOX_FLOAT_RIGHT: - case BOX_BR: - case BOX_TEXT: - /* should have been wrapped in inline - container by convert_xml_to_box() */ - assert(0); - break; case BOX_TABLE_ROW_GROUP: case BOX_TABLE_ROW: - case BOX_TABLE_CELL: - /* insert implied table */ - assert(block->style != NULL); + /* insert implied table cell */ + assert(row->style != NULL); ctx.ctx = c->select_ctx; ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); ctx.base_url = c->base_url; ctx.universal = c->universal; - style = nscss_get_blank_style(&ctx, block->style); + style = nscss_get_blank_style(&ctx, row->style); if (style == NULL) return false; - table = box_create(NULL, style, true, block->href, - block->target, NULL, NULL, c->bctx); - if (table == NULL) { + cell = box_create(NULL, style, true, row->href, + row->target, NULL, NULL, c->bctx); + if (cell == NULL) { css_computed_style_destroy(style); return false; } - table->type = BOX_TABLE; + cell->type = BOX_TABLE_CELL; if (child->prev == NULL) - block->children = table; + row->children = cell; else - child->prev->next = table; + child->prev->next = cell; - table->prev = child->prev; + cell->prev = child->prev; while (child != NULL && ( + child->type == BOX_BLOCK || + child->type == BOX_INLINE_CONTAINER || + child->type == BOX_TABLE || child->type == BOX_TABLE_ROW_GROUP || - child->type == BOX_TABLE_ROW || - child->type == BOX_TABLE_CELL)) { - box_add_child(table, child); + child->type == BOX_TABLE_ROW)) { + box_add_child(cell, child); next_child = child->next; child->next = NULL; child = next_child; } - table->last->next = NULL; - table->next = next_child = child; - if (table->next != NULL) - table->next->prev = table; + assert(cell->last != NULL); + + cell->last->next = NULL; + cell->next = next_child = child; + if (cell->next != NULL) + cell->next->prev = cell; else - block->last = table; - table->parent = block; + row->last = cell; + cell->parent = row; - if (box_normalise_table(table, root, c) == false) + if (box_normalise_block(cell, root, c) == false) return false; break; + case BOX_INLINE: + case BOX_INLINE_END: + case BOX_INLINE_BLOCK: + case BOX_FLOAT_LEFT: + case BOX_FLOAT_RIGHT: + case BOX_BR: + case BOX_TEXT: + /* should have been wrapped in inline + container by convert_xml_to_box() */ + assert(0); + break; default: assert(0); } + + if (calculate_table_row(col_info, cell->columns, cell->rows, + &cell->start_column, cell) == false) + return false; + } + + + /* Update row spanning details for all columns */ + for (i = 0; i < col_info->num_columns; i++) { + if (col_info->spans[i].row_span != 0 && + col_info->spans[i].auto_row == false) { + /* This cell spans rows, and is not an auto row. + * Reduce number of rows left to span */ + col_info->spans[i].row_span--; + } } + /* Reset current column for next row */ + col_info->current_column = 0; + + /* Increment row counter */ + col_info->num_rows++; + +#ifdef BOX_NORMALISE_DEBUG + NSLOG(netsurf, INFO, "row %p done", row); +#endif + return true; } -bool box_normalise_table( - struct box *table, - const struct box *root, - html_content * c) +static bool +box_normalise_table_row_group(struct box *row_group, + const struct box *root, + struct columns *col_info, + html_content * c) { struct box *child; struct box *next_child; - struct box *row_group; + struct box *row; css_computed_style *style; - struct columns col_info; nscss_select_ctx ctx; + unsigned int group_row_count = 0; - assert(table != NULL); - assert(table->type == BOX_TABLE); + assert(row_group != 0); + assert(row_group->type == BOX_TABLE_ROW_GROUP); ctx.root_style = root->style; #ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "table %p", table); + NSLOG(netsurf, INFO, "row_group %p", row_group); #endif - col_info.num_columns = 1; - col_info.current_column = 0; - col_info.spans = malloc(2 * sizeof *col_info.spans); - if (col_info.spans == NULL) - return false; - - col_info.spans[0].row_span = col_info.spans[1].row_span = 0; - col_info.spans[0].auto_row = false; - col_info.spans[1].auto_row = false; - col_info.num_rows = 0; - - for (child = table->children; child != NULL; child = next_child) { + for (child = row_group->children; child != NULL; child = next_child) { next_child = child->next; + switch (child->type) { - case BOX_TABLE_ROW_GROUP: + case BOX_TABLE_ROW: /* ok */ - if (box_normalise_table_row_group(child, root, - &col_info, c) == false) { - free(col_info.spans); + group_row_count++; + if (box_normalise_table_row(child, root, col_info, + c) == false) return false; - } break; case BOX_BLOCK: case BOX_INLINE_CONTAINER: case BOX_TABLE: - case BOX_TABLE_ROW: + case BOX_TABLE_ROW_GROUP: case BOX_TABLE_CELL: - /* insert implied table row group */ - assert(table->style != NULL); + /* insert implied table row */ + assert(row_group->style != NULL); ctx.ctx = c->select_ctx; ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); ctx.base_url = c->base_url; ctx.universal = c->universal; - style = nscss_get_blank_style(&ctx, table->style); - if (style == NULL) { - free(col_info.spans); + style = nscss_get_blank_style(&ctx, row_group->style); + if (style == NULL) return false; - } - row_group = box_create(NULL, style, true, table->href, - table->target, NULL, NULL, c->bctx); - if (row_group == NULL) { + row = box_create(NULL, style, true, row_group->href, + row_group->target, NULL, NULL, c->bctx); + if (row == NULL) { css_computed_style_destroy(style); - free(col_info.spans); return false; } - - row_group->type = BOX_TABLE_ROW_GROUP; + row->type = BOX_TABLE_ROW; if (child->prev == NULL) - table->children = row_group; + row_group->children = row; else - child->prev->next = row_group; + child->prev->next = row; - row_group->prev = child->prev; + row->prev = child->prev; while (child != NULL && ( child->type == BOX_BLOCK || child->type == BOX_INLINE_CONTAINER || child->type == BOX_TABLE || - child->type == BOX_TABLE_ROW || + child->type == BOX_TABLE_ROW_GROUP || child->type == BOX_TABLE_CELL)) { - box_add_child(row_group, child); + box_add_child(row, child); next_child = child->next; child->next = NULL; child = next_child; } - assert(row_group->last != NULL); + assert(row->last != NULL); - row_group->last->next = NULL; - row_group->next = next_child = child; - if (row_group->next != NULL) - row_group->next->prev = row_group; + row->last->next = NULL; + row->next = next_child = child; + if (row->next != NULL) + row->next->prev = row; else - table->last = row_group; - row_group->parent = table; + row_group->last = row; + row->parent = row_group; - if (box_normalise_table_row_group(row_group, root, - &col_info, c) == false) { - free(col_info.spans); + group_row_count++; + if (box_normalise_table_row(row, root, col_info, + c) == false) return false; - } break; case BOX_INLINE: case BOX_INLINE_END: @@ -352,48 +384,25 @@ bool box_normalise_table( assert(0); break; default: - fprintf(stderr, "%i\n", child->type); assert(0); } } - table->columns = col_info.num_columns; - table->rows = col_info.num_rows; - - if (table->children == NULL) { - struct box *row; - + if (row_group->children == NULL) { #ifdef BOX_NORMALISE_DEBUG NSLOG(netsurf, INFO, - "table->children == 0, creating implied row"); + "row_group->children == 0, inserting implied row"); #endif - assert(table->style != NULL); + assert(row_group->style != NULL); ctx.ctx = c->select_ctx; ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); ctx.base_url = c->base_url; ctx.universal = c->universal; - style = nscss_get_blank_style(&ctx, table->style); - if (style == NULL) { - free(col_info.spans); - return false; - } - - row_group = box_create(NULL, style, true, table->href, - table->target, NULL, NULL, c->bctx); - if (row_group == NULL) { - css_computed_style_destroy(style); - free(col_info.spans); - return false; - } - row_group->type = BOX_TABLE_ROW_GROUP; - style = nscss_get_blank_style(&ctx, row_group->style); if (style == NULL) { - box_free(row_group); - free(col_info.spans); return false; } @@ -401,8 +410,6 @@ bool box_normalise_table( row_group->target, NULL, NULL, c->bctx); if (row == NULL) { css_computed_style_destroy(style); - box_free(row_group); - free(col_info.spans); return false; } row->type = BOX_TABLE_ROW; @@ -410,21 +417,16 @@ bool box_normalise_table( row->parent = row_group; row_group->children = row_group->last = row; - row_group->parent = table; - table->children = table->last = row_group; - - table->rows = 1; - } + group_row_count = 1; - if (box_normalise_table_spans(table, root, col_info.spans, c) == false) { - free(col_info.spans); - return false; + /* Keep table's row count in sync */ + col_info->num_rows++; } - free(col_info.spans); + row_group->rows = group_row_count; #ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "table %p done", table); + NSLOG(netsurf, INFO, "row_group %p done", row_group); #endif return true; @@ -441,12 +443,11 @@ bool box_normalise_table( * \param c Content containing table * \return True on success, false on memory exhaustion. */ - -bool box_normalise_table_spans( - struct box *table, - const struct box *root, - struct span_info *spans, - html_content *c) +static bool +box_normalise_table_spans(struct box *table, + const struct box *root, + struct span_info *spans, + html_content *c) { struct box *table_row_group; struct box *table_row; @@ -601,249 +602,111 @@ bool box_normalise_table_spans( } -bool box_normalise_table_row_group( - struct box *row_group, - const struct box *root, - struct columns *col_info, - html_content * c) +static bool +box_normalise_table(struct box *table, const struct box *root, html_content * c) { struct box *child; struct box *next_child; - struct box *row; + struct box *row_group; css_computed_style *style; + struct columns col_info; nscss_select_ctx ctx; - unsigned int group_row_count = 0; - assert(row_group != 0); - assert(row_group->type == BOX_TABLE_ROW_GROUP); + assert(table != NULL); + assert(table->type == BOX_TABLE); ctx.root_style = root->style; #ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "row_group %p", row_group); -#endif - - for (child = row_group->children; child != NULL; child = next_child) { - next_child = child->next; - - switch (child->type) { - case BOX_TABLE_ROW: - /* ok */ - group_row_count++; - if (box_normalise_table_row(child, root, col_info, - c) == false) - return false; - break; - case BOX_BLOCK: - case BOX_INLINE_CONTAINER: - case BOX_TABLE: - case BOX_TABLE_ROW_GROUP: - case BOX_TABLE_CELL: - /* insert implied table row */ - assert(row_group->style != NULL); - - ctx.ctx = c->select_ctx; - ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); - ctx.base_url = c->base_url; - ctx.universal = c->universal; - - style = nscss_get_blank_style(&ctx, row_group->style); - if (style == NULL) - return false; - - row = box_create(NULL, style, true, row_group->href, - row_group->target, NULL, NULL, c->bctx); - if (row == NULL) { - css_computed_style_destroy(style); - return false; - } - row->type = BOX_TABLE_ROW; - - if (child->prev == NULL) - row_group->children = row; - else - child->prev->next = row; - - row->prev = child->prev; - - while (child != NULL && ( - child->type == BOX_BLOCK || - child->type == BOX_INLINE_CONTAINER || - child->type == BOX_TABLE || - child->type == BOX_TABLE_ROW_GROUP || - child->type == BOX_TABLE_CELL)) { - box_add_child(row, child); - - next_child = child->next; - child->next = NULL; - child = next_child; - } - - assert(row->last != NULL); - - row->last->next = NULL; - row->next = next_child = child; - if (row->next != NULL) - row->next->prev = row; - else - row_group->last = row; - row->parent = row_group; - - group_row_count++; - if (box_normalise_table_row(row, root, col_info, - c) == false) - return false; - break; - case BOX_INLINE: - case BOX_INLINE_END: - case BOX_INLINE_BLOCK: - case BOX_FLOAT_LEFT: - case BOX_FLOAT_RIGHT: - case BOX_BR: - case BOX_TEXT: - /* should have been wrapped in inline - container by convert_xml_to_box() */ - assert(0); - break; - default: - assert(0); - } - } - - if (row_group->children == NULL) { -#ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, - "row_group->children == 0, inserting implied row"); -#endif - - assert(row_group->style != NULL); - - ctx.ctx = c->select_ctx; - ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); - ctx.base_url = c->base_url; - ctx.universal = c->universal; - - style = nscss_get_blank_style(&ctx, row_group->style); - if (style == NULL) { - return false; - } - - row = box_create(NULL, style, true, row_group->href, - row_group->target, NULL, NULL, c->bctx); - if (row == NULL) { - css_computed_style_destroy(style); - return false; - } - row->type = BOX_TABLE_ROW; - - row->parent = row_group; - row_group->children = row_group->last = row; - - group_row_count = 1; - - /* Keep table's row count in sync */ - col_info->num_rows++; - } - - row_group->rows = group_row_count; - -#ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "row_group %p done", row_group); + NSLOG(netsurf, INFO, "table %p", table); #endif - return true; -} - - -bool box_normalise_table_row( - struct box *row, - const struct box *root, - struct columns *col_info, - html_content * c) -{ - struct box *child; - struct box *next_child; - struct box *cell = NULL; - css_computed_style *style; - unsigned int i; - nscss_select_ctx ctx; - - assert(row != NULL); - assert(row->type == BOX_TABLE_ROW); - - ctx.root_style = root->style; + col_info.num_columns = 1; + col_info.current_column = 0; + col_info.spans = malloc(2 * sizeof *col_info.spans); + if (col_info.spans == NULL) + return false; -#ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "row %p", row); -#endif + col_info.spans[0].row_span = col_info.spans[1].row_span = 0; + col_info.spans[0].auto_row = false; + col_info.spans[1].auto_row = false; + col_info.num_rows = 0; - for (child = row->children; child != NULL; child = next_child) { + for (child = table->children; child != NULL; child = next_child) { next_child = child->next; - switch (child->type) { - case BOX_TABLE_CELL: + case BOX_TABLE_ROW_GROUP: /* ok */ - if (box_normalise_block(child, root, c) == false) + if (box_normalise_table_row_group(child, root, + &col_info, c) == false) { + free(col_info.spans); return false; - cell = child; + } break; case BOX_BLOCK: case BOX_INLINE_CONTAINER: case BOX_TABLE: - case BOX_TABLE_ROW_GROUP: case BOX_TABLE_ROW: - /* insert implied table cell */ - assert(row->style != NULL); + case BOX_TABLE_CELL: + /* insert implied table row group */ + assert(table->style != NULL); ctx.ctx = c->select_ctx; ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); ctx.base_url = c->base_url; ctx.universal = c->universal; - style = nscss_get_blank_style(&ctx, row->style); - if (style == NULL) + style = nscss_get_blank_style(&ctx, table->style); + if (style == NULL) { + free(col_info.spans); return false; + } - cell = box_create(NULL, style, true, row->href, - row->target, NULL, NULL, c->bctx); - if (cell == NULL) { + row_group = box_create(NULL, style, true, table->href, + table->target, NULL, NULL, c->bctx); + if (row_group == NULL) { css_computed_style_destroy(style); + free(col_info.spans); return false; } - cell->type = BOX_TABLE_CELL; + + row_group->type = BOX_TABLE_ROW_GROUP; if (child->prev == NULL) - row->children = cell; + table->children = row_group; else - child->prev->next = cell; + child->prev->next = row_group; - cell->prev = child->prev; + row_group->prev = child->prev; while (child != NULL && ( child->type == BOX_BLOCK || child->type == BOX_INLINE_CONTAINER || child->type == BOX_TABLE || - child->type == BOX_TABLE_ROW_GROUP || - child->type == BOX_TABLE_ROW)) { - box_add_child(cell, child); + child->type == BOX_TABLE_ROW || + child->type == BOX_TABLE_CELL)) { + box_add_child(row_group, child); next_child = child->next; child->next = NULL; child = next_child; } - assert(cell->last != NULL); + assert(row_group->last != NULL); - cell->last->next = NULL; - cell->next = next_child = child; - if (cell->next != NULL) - cell->next->prev = cell; + row_group->last->next = NULL; + row_group->next = next_child = child; + if (row_group->next != NULL) + row_group->next->prev = row_group; else - row->last = cell; - cell->parent = row; + table->last = row_group; + row_group->parent = table; - if (box_normalise_block(cell, root, c) == false) + if (box_normalise_table_row_group(row_group, root, + &col_info, c) == false) { + free(col_info.spans); return false; + } break; case BOX_INLINE: case BOX_INLINE_END: @@ -857,118 +720,89 @@ bool box_normalise_table_row( assert(0); break; default: + fprintf(stderr, "%i\n", child->type); assert(0); } - - if (calculate_table_row(col_info, cell->columns, cell->rows, - &cell->start_column, cell) == false) - return false; - } - - - /* Update row spanning details for all columns */ - for (i = 0; i < col_info->num_columns; i++) { - if (col_info->spans[i].row_span != 0 && - col_info->spans[i].auto_row == false) { - /* This cell spans rows, and is not an auto row. - * Reduce number of rows left to span */ - col_info->spans[i].row_span--; - } } - /* Reset current column for next row */ - col_info->current_column = 0; + table->columns = col_info.num_columns; + table->rows = col_info.num_rows; - /* Increment row counter */ - col_info->num_rows++; + if (table->children == NULL) { + struct box *row; #ifdef BOX_NORMALISE_DEBUG - NSLOG(netsurf, INFO, "row %p done", row); + NSLOG(netsurf, INFO, + "table->children == 0, creating implied row"); #endif - return true; -} - - -/** - * Compute the column index at which the current cell begins. - * Additionally, update the column record to reflect row spanning. - * - * \param col_info Column record - * \param col_span Number of columns that current cell spans - * \param row_span Number of rows that current cell spans - * \param start_column Pointer to location to receive column index - * \param cell Box for current table cell - * \return true on success, false on memory exhaustion - */ - -bool calculate_table_row(struct columns *col_info, - unsigned int col_span, unsigned int row_span, - unsigned int *start_column, struct box *cell) -{ - unsigned int cell_start_col = col_info->current_column; - unsigned int cell_end_col; - unsigned int i; - struct span_info *spans; - struct box *rg = cell->parent->parent; /* Cell's row group */ + assert(table->style != NULL); - /* Skip columns with cells spanning from above */ - /* TODO: Need to ignore cells spanning from above that belong to - * different row group. We don't have that info here. */ - while (col_info->spans[cell_start_col].row_span != 0 && - col_info->spans[cell_start_col].rg == rg) { - cell_start_col++; - } + ctx.ctx = c->select_ctx; + ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); + ctx.base_url = c->base_url; + ctx.universal = c->universal; - /* Update current column with calculated start */ - col_info->current_column = cell_start_col; + style = nscss_get_blank_style(&ctx, table->style); + if (style == NULL) { + free(col_info.spans); + return false; + } - /* If this cell has a colspan of 0, then assume 1. - * No other browser supports colspan=0, anyway. */ - if (col_span == 0) - col_span = 1; + row_group = box_create(NULL, style, true, table->href, + table->target, NULL, NULL, c->bctx); + if (row_group == NULL) { + css_computed_style_destroy(style); + free(col_info.spans); + return false; + } + row_group->type = BOX_TABLE_ROW_GROUP; - cell_end_col = cell_start_col + col_span; + style = nscss_get_blank_style(&ctx, row_group->style); + if (style == NULL) { + box_free(row_group); + free(col_info.spans); + return false; + } - if (col_info->num_columns < cell_end_col) { - /* It appears that this row has more columns than - * the maximum recorded for the table so far. - * Allocate more span records. */ - spans = realloc(col_info->spans, - sizeof *spans * (cell_end_col + 1)); - if (spans == NULL) + row = box_create(NULL, style, true, row_group->href, + row_group->target, NULL, NULL, c->bctx); + if (row == NULL) { + css_computed_style_destroy(style); + box_free(row_group); + free(col_info.spans); return false; + } + row->type = BOX_TABLE_ROW; - col_info->spans = spans; - col_info->num_columns = cell_end_col; + row->parent = row_group; + row_group->children = row_group->last = row; - /* Mark new final column as sentinel */ - col_info->spans[cell_end_col].row_span = 0; - col_info->spans[cell_end_col].auto_row = false; + row_group->parent = table; + table->children = table->last = row_group; + + table->rows = 1; } - /* This cell may span multiple columns. If it also wants to span - * multiple rows, temporarily assume it spans 1 row only. This will - * be fixed up in box_normalise_table_spans() */ - for (i = cell_start_col; i < cell_end_col; i++) { - col_info->spans[i].row_span = (row_span == 0) ? 1 : row_span; - col_info->spans[i].auto_row = (row_span == 0); - col_info->spans[i].rg = rg; + if (box_normalise_table_spans(table, root, col_info.spans, c) == false) { + free(col_info.spans); + return false; } - /* Update current column with calculated end. */ - col_info->current_column = cell_end_col; + free(col_info.spans); - *start_column = cell_start_col; +#ifdef BOX_NORMALISE_DEBUG + NSLOG(netsurf, INFO, "table %p done", table); +#endif return true; } -bool box_normalise_inline_container( - struct box *cont, - const struct box *root, - html_content * c) +static bool +box_normalise_inline_container(struct box *cont, + const struct box *root, + html_content * c) { struct box *child; struct box *next_child; @@ -1045,3 +879,119 @@ bool box_normalise_inline_container( return true; } + + +/* Exported function documented in html/box_normalise.h */ +bool +box_normalise_block(struct box *block, const struct box *root, html_content *c) +{ + struct box *child; + struct box *next_child; + struct box *table; + css_computed_style *style; + nscss_select_ctx ctx; + + assert(block != NULL); + assert(root != NULL); + + ctx.root_style = root->style; + +#ifdef BOX_NORMALISE_DEBUG + NSLOG(netsurf, INFO, "block %p, block->type %u", block, block->type); +#endif + + assert(block->type == BOX_BLOCK || block->type == BOX_INLINE_BLOCK || + block->type == BOX_TABLE_CELL); + + for (child = block->children; child != NULL; child = next_child) { +#ifdef BOX_NORMALISE_DEBUG + NSLOG(netsurf, INFO, "child %p, child->type = %d", child, + child->type); +#endif + + next_child = child->next; /* child may be destroyed */ + + switch (child->type) { + case BOX_BLOCK: + /* ok */ + if (box_normalise_block(child, root, c) == false) + return false; + break; + case BOX_INLINE_CONTAINER: + if (box_normalise_inline_container(child, root, c) == false) + return false; + break; + case BOX_TABLE: + if (box_normalise_table(child, root, c) == false) + return false; + break; + case BOX_INLINE: + case BOX_INLINE_END: + case BOX_INLINE_BLOCK: + case BOX_FLOAT_LEFT: + case BOX_FLOAT_RIGHT: + case BOX_BR: + case BOX_TEXT: + /* should have been wrapped in inline + container by convert_xml_to_box() */ + assert(0); + break; + case BOX_TABLE_ROW_GROUP: + case BOX_TABLE_ROW: + case BOX_TABLE_CELL: + /* insert implied table */ + assert(block->style != NULL); + + ctx.ctx = c->select_ctx; + ctx.quirks = (c->quirks == DOM_DOCUMENT_QUIRKS_MODE_FULL); + ctx.base_url = c->base_url; + ctx.universal = c->universal; + + style = nscss_get_blank_style(&ctx, block->style); + if (style == NULL) + return false; + + table = box_create(NULL, style, true, block->href, + block->target, NULL, NULL, c->bctx); + if (table == NULL) { + css_computed_style_destroy(style); + return false; + } + table->type = BOX_TABLE; + + if (child->prev == NULL) + block->children = table; + else + child->prev->next = table; + + table->prev = child->prev; + + while (child != NULL && ( + child->type == BOX_TABLE_ROW_GROUP || + child->type == BOX_TABLE_ROW || + child->type == BOX_TABLE_CELL)) { + box_add_child(table, child); + + next_child = child->next; + child->next = NULL; + child = next_child; + } + + table->last->next = NULL; + table->next = next_child = child; + if (table->next != NULL) + table->next->prev = table; + else + block->last = table; + table->parent = block; + + if (box_normalise_table(table, root, c) == false) + return false; + break; + default: + assert(0); + } + } + + return true; +} diff --git a/content/handlers/html/box_normalise.h b/content/handlers/html/box_normalise.h new file mode 100644 index 0000000..60f2591 --- /dev/null +++ b/content/handlers/html/box_normalise.h @@ -0,0 +1,50 @@ +/* + * Copyright 2020 Vincent Sanders <vince(a)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 + * HTML Box tree normalise interface. + */ + +#ifndef NETSURF_HTML_BOX_NORMALISE_H +#define NETSURF_HTML_BOX_NORMALISE_H + +/** + * Ensure the box tree is correctly nested by adding and removing nodes. + * + * \param block box of type BLOCK, INLINE_BLOCK, or TABLE_CELL + * \param root root box of document + * \param c content of boxes + * \return true on success, false on memory exhaustion + * + * The tree is modified to satisfy the following: + * \code + * parent permitted child nodes + * BLOCK, INLINE_BLOCK BLOCK, INLINE_CONTAINER, TABLE + * INLINE_CONTAINER INLINE, INLINE_BLOCK, FLOAT_LEFT, FLOAT_RIGHT, BR, TEXT + * INLINE, TEXT none + * TABLE at least 1 TABLE_ROW_GROUP + * TABLE_ROW_GROUP at least 1 TABLE_ROW + * TABLE_ROW at least 1 TABLE_CELL + * TABLE_CELL BLOCK, INLINE_CONTAINER, TABLE (same as BLOCK) + * FLOAT_(LEFT|RIGHT) exactly 1 BLOCK or TABLE + * \endcode + */ +bool box_normalise_block(struct box *block, const struct box *root, struct html_content *c); + +#endif diff --git a/content/handlers/html/html.c b/content/handlers/html/html.c index e445457..9b47858 100644 --- a/content/handlers/html/html.c +++ b/content/handlers/html/html.c @@ -60,6 +60,7 @@ #include "html/html_internal.h" #include "html/interaction.h" #include "html/box.h" +#include "html/box_construct.h" #include "html/form_internal.h" #include "html/imagemap.h" #include "html/layout.h" @@ -212,7 +213,7 @@ static void html_box_convert_done(html_content *c, bool success) dom_exception exc; /* returned by libdom functions */ dom_node *html; - NSLOG(netsurf, INFO, "Done XML to box (%p)", c); + NSLOG(netsurf, INFO, "DOM to box conversion complete (content %p)", c); c->box_conversion_context = NULL; diff --git a/content/handlers/html/imagemap.c b/content/handlers/html/imagemap.c index 0c35768..37095e2 100644 --- a/content/handlers/html/imagemap.c +++ b/content/handlers/html/imagemap.c @@ -36,6 +36,7 @@ #include "content/hlcache.h" #include "html/box.h" +#include "html/box_construct.h" #include "html/html_internal.h" #include "html/imagemap.h" -- NetSurf Browser

2 years, 10 months

1
0
0 / 0

netsurf: branch master updated. release/3.9-607-gf6883d6

by NetSurf Browser Project

Gitweb links: ...log http://git.netsurf-browser.org/netsurf.git/shortlog/f6883d6761975c6512455... ...commit http://git.netsurf-browser.org/netsurf.git/commit/f6883d6761975c6512455f0... ...tree http://git.netsurf-browser.org/netsurf.git/tree/f6883d6761975c6512455f0c8... The branch, master has been updated via f6883d6761975c6512455f0c854b683240c7cd48 (commit) from d3d17ded9c3d7707ac8a69fde424385465422be0 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=f6883d6761975c65124... commit f6883d6761975c6512455f0c854b683240c7cd48 Author: Vincent Sanders <vince(a)kyllikki.org> Commit: Vincent Sanders <vince(a)kyllikki.org> use dom type interface instead of strcasecmp diff --git a/content/handlers/html/box_construct.c b/content/handlers/html/box_construct.c index b1f3461..16154cb 100644 --- a/content/handlers/html/box_construct.c +++ b/content/handlers/html/box_construct.c @@ -1884,42 +1884,6 @@ static bool box_textarea(dom_node *n, /** - * special element table entry - */ -struct element_entry { - char name[10]; /* element type */ - bool (*convert)(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children); -}; - - -/** - * special element handler table - * - * \note the table must be sorted ascending alphabeticaly by name - */ -static const struct element_entry element_table[] = { - {"a", box_a}, - {"body", box_body}, - {"br", box_br}, - {"button", box_button}, - {"embed", box_embed}, - {"frameset", box_frameset}, - {"iframe", box_iframe}, - {"img", box_image}, - {"input", box_input}, - {"noscript", box_noscript}, - {"object", box_object}, - {"pre", box_pre}, - {"select", box_select}, - {"textarea", box_textarea} -}; -#define ELEMENT_TABLE_COUNT (sizeof(element_table) / sizeof(element_table[0])) - - -/** * Extract transient construction properties * * \param n Current DOM node to convert @@ -2260,6 +2224,89 @@ box_construct_marker(struct box *box, /** + * call an elements special handler + */ +static bool +convert_special_elements(dom_node *node, + html_content *content, + struct box *box, + bool *convert_children) +{ + dom_exception exc; + dom_html_element_type tag_type; + bool res; + + exc = dom_html_element_get_tag_type(node, &tag_type); + if (exc != DOM_NO_ERR) { + tag_type = DOM_HTML_ELEMENT_TYPE__UNKNOWN; + } + + switch (tag_type) { + case DOM_HTML_ELEMENT_TYPE_A: + res = box_a(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_BODY: + res = box_body(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_BR: + res = box_br(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_BUTTON: + res = box_button(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_EMBED: + res = box_embed(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_FRAMESET: + res = box_frameset(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_IFRAME: + res = box_iframe(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_IMG: + res = box_image(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_INPUT: + res = box_input(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_NOSCRIPT: + res = box_noscript(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_OBJECT: + res = box_object(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_PRE: + res = box_pre(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_SELECT: + res = box_select(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_TEXTAREA: + res = box_textarea(node, content, box, convert_children); + break; + + default: + res = true; + } + + return res; +} + + +/** * Construct the box tree for an XML element. * * \param ctx Tree construction context @@ -2273,7 +2320,6 @@ box_construct_element(struct box_construct_ctx *ctx, bool *convert_children) lwc_string *id = NULL; struct box *box = NULL, *old_box; css_select_results *styles = NULL; - struct element_entry *element; lwc_string *bgimage_uri; dom_exception err; struct box_construct_props props; @@ -2395,22 +2441,11 @@ box_construct_element(struct box_construct_ctx *ctx, bool *convert_children) props.node_is_root)]; } - err = dom_node_get_node_name(ctx->n, &s); - if (err != DOM_NO_ERR || s == NULL) + if (convert_special_elements(ctx->n, + ctx->content, + box, + convert_children) == false) { return false; - - /* Special elements */ - element = bsearch(dom_string_data(s), element_table, - ELEMENT_TABLE_COUNT, sizeof(element_table[0]), - (int (*)(const void *, const void *)) strcasecmp); - - dom_string_unref(s); - - if (element != NULL) { - /* A special convert function exists for this element */ - if (element->convert(ctx->n, ctx->content, box, - convert_children) == false) - return false; } /* Handle the :before pseudo element */ ----------------------------------------------------------------------- Summary of changes: content/handlers/html/box_construct.c | 139 +++++++++++++++++++++------------ 1 file changed, 87 insertions(+), 52 deletions(-) diff --git a/content/handlers/html/box_construct.c b/content/handlers/html/box_construct.c index b1f3461..16154cb 100644 --- a/content/handlers/html/box_construct.c +++ b/content/handlers/html/box_construct.c @@ -1884,42 +1884,6 @@ static bool box_textarea(dom_node *n, /** - * special element table entry - */ -struct element_entry { - char name[10]; /* element type */ - bool (*convert)(dom_node *n, - html_content *content, - struct box *box, - bool *convert_children); -}; - - -/** - * special element handler table - * - * \note the table must be sorted ascending alphabeticaly by name - */ -static const struct element_entry element_table[] = { - {"a", box_a}, - {"body", box_body}, - {"br", box_br}, - {"button", box_button}, - {"embed", box_embed}, - {"frameset", box_frameset}, - {"iframe", box_iframe}, - {"img", box_image}, - {"input", box_input}, - {"noscript", box_noscript}, - {"object", box_object}, - {"pre", box_pre}, - {"select", box_select}, - {"textarea", box_textarea} -}; -#define ELEMENT_TABLE_COUNT (sizeof(element_table) / sizeof(element_table[0])) - - -/** * Extract transient construction properties * * \param n Current DOM node to convert @@ -2260,6 +2224,89 @@ box_construct_marker(struct box *box, /** + * call an elements special handler + */ +static bool +convert_special_elements(dom_node *node, + html_content *content, + struct box *box, + bool *convert_children) +{ + dom_exception exc; + dom_html_element_type tag_type; + bool res; + + exc = dom_html_element_get_tag_type(node, &tag_type); + if (exc != DOM_NO_ERR) { + tag_type = DOM_HTML_ELEMENT_TYPE__UNKNOWN; + } + + switch (tag_type) { + case DOM_HTML_ELEMENT_TYPE_A: + res = box_a(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_BODY: + res = box_body(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_BR: + res = box_br(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_BUTTON: + res = box_button(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_EMBED: + res = box_embed(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_FRAMESET: + res = box_frameset(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_IFRAME: + res = box_iframe(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_IMG: + res = box_image(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_INPUT: + res = box_input(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_NOSCRIPT: + res = box_noscript(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_OBJECT: + res = box_object(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_PRE: + res = box_pre(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_SELECT: + res = box_select(node, content, box, convert_children); + break; + + case DOM_HTML_ELEMENT_TYPE_TEXTAREA: + res = box_textarea(node, content, box, convert_children); + break; + + default: + res = true; + } + + return res; +} + + +/** * Construct the box tree for an XML element. * * \param ctx Tree construction context @@ -2273,7 +2320,6 @@ box_construct_element(struct box_construct_ctx *ctx, bool *convert_children) lwc_string *id = NULL; struct box *box = NULL, *old_box; css_select_results *styles = NULL; - struct element_entry *element; lwc_string *bgimage_uri; dom_exception err; struct box_construct_props props; @@ -2395,22 +2441,11 @@ box_construct_element(struct box_construct_ctx *ctx, bool *convert_children) props.node_is_root)]; } - err = dom_node_get_node_name(ctx->n, &s); - if (err != DOM_NO_ERR || s == NULL) + if (convert_special_elements(ctx->n, + ctx->content, + box, + convert_children) == false) { return false; - - /* Special elements */ - element = bsearch(dom_string_data(s), element_table, - ELEMENT_TABLE_COUNT, sizeof(element_table[0]), - (int (*)(const void *, const void *)) strcasecmp); - - dom_string_unref(s); - - if (element != NULL) { - /* A special convert function exists for this element */ - if (element->convert(ctx->n, ctx->content, box, - convert_children) == false) - return false; } /* Handle the :before pseudo element */ -- NetSurf Browser

2 years, 10 months

1
0
0 / 0

netsurf: branch master updated. release/3.9-606-gd3d17de

by NetSurf Browser Project

Gitweb links: ...log http://git.netsurf-browser.org/netsurf.git/shortlog/d3d17ded9c3d7707ac8a6... ...commit http://git.netsurf-browser.org/netsurf.git/commit/d3d17ded9c3d7707ac8a69f... ...tree http://git.netsurf-browser.org/netsurf.git/tree/d3d17ded9c3d7707ac8a69fde... The branch, master has been updated via d3d17ded9c3d7707ac8a69fde424385465422be0 (commit) via 2cb33b0c334f0b389b8cbbf26a2a3f1af3bccd6d (commit) from b577de7c5bbba6c2f9a0b4ede3f814ea3023ded6 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=d3d17ded9c3d7707ac8... commit d3d17ded9c3d7707ac8a69fde424385465422be0 Author: Daniel Silverstone <dsilvers(a)digital-scurf.org> Commit: Daniel Silverstone <dsilvers(a)digital-scurf.org> dukky: Don't allow js_exec on a thread pending destruction Signed-off-by: Daniel Silverstone <dsilvers(a)digital-scurf.org> diff --git a/content/handlers/javascript/duktape/dukky.c b/content/handlers/javascript/duktape/dukky.c index 7357863..6d87712 100644 --- a/content/handlers/javascript/duktape/dukky.c +++ b/content/handlers/javascript/duktape/dukky.c @@ -925,6 +925,11 @@ js_exec(jsthread *thread, const uint8_t *txt, size_t txtlen, const char *name) return false; } + if (thread->pending_destroy) { + NSLOG(dukky, DEEPDEBUG, "Skipping exec call because thread is dead"); + return false; + } + dukky_enter_thread(thread); duk_set_top(CTX, 0); commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=2cb33b0c334f0b389b8... commit 2cb33b0c334f0b389b8cbbf26a2a3f1af3bccd6d Author: Daniel Silverstone <dsilvers(a)digital-scurf.org> Commit: Daniel Silverstone <dsilvers(a)digital-scurf.org> dukky: Various checks for win being NULL Signed-off-by: Daniel Silverstone <dsilvers(a)digital-scurf.org> diff --git a/content/handlers/javascript/duktape/Console.bnd b/content/handlers/javascript/duktape/Console.bnd index 3de875a..fcf6ee8 100644 --- a/content/handlers/javascript/duktape/Console.bnd +++ b/content/handlers/javascript/duktape/Console.bnd @@ -51,7 +51,7 @@ write_log_entry(duk_context *ctx, unsigned int group, browser_window_console_fla duk_size_t msglen; const char *msg = duk_safe_to_lstring(ctx, 0, &msglen); - if (priv_win == NULL || + if (priv_win == NULL || priv_win->win == NULL || browser_window_console_log(priv_win->win, BW_CS_SCRIPT_CONSOLE, msg, msglen, flags) != NSERROR_OK) { diff --git a/content/handlers/javascript/duktape/Window.bnd b/content/handlers/javascript/duktape/Window.bnd index 175f4ac..2c26f1d 100644 --- a/content/handlers/javascript/duktape/Window.bnd +++ b/content/handlers/javascript/duktape/Window.bnd @@ -277,6 +277,9 @@ static duk_ret_t dukky_window_closedown_thread(duk_context *ctx) init Window(struct browser_window *win, struct html_content *htmlc) %{ + /* It makes no sense if win or htmlc are NULL */ + assert(win != NULL); + assert(htmlc != NULL); /* element window */ priv->win = win; priv->htmlc = htmlc; ----------------------------------------------------------------------- Summary of changes: content/handlers/javascript/duktape/Console.bnd | 2 +- content/handlers/javascript/duktape/Window.bnd | 3 +++ content/handlers/javascript/duktape/dukky.c | 5 +++++ 3 files changed, 9 insertions(+), 1 deletion(-) diff --git a/content/handlers/javascript/duktape/Console.bnd b/content/handlers/javascript/duktape/Console.bnd index 3de875a..fcf6ee8 100644 --- a/content/handlers/javascript/duktape/Console.bnd +++ b/content/handlers/javascript/duktape/Console.bnd @@ -51,7 +51,7 @@ write_log_entry(duk_context *ctx, unsigned int group, browser_window_console_fla duk_size_t msglen; const char *msg = duk_safe_to_lstring(ctx, 0, &msglen); - if (priv_win == NULL || + if (priv_win == NULL || priv_win->win == NULL || browser_window_console_log(priv_win->win, BW_CS_SCRIPT_CONSOLE, msg, msglen, flags) != NSERROR_OK) { diff --git a/content/handlers/javascript/duktape/Window.bnd b/content/handlers/javascript/duktape/Window.bnd index 175f4ac..2c26f1d 100644 --- a/content/handlers/javascript/duktape/Window.bnd +++ b/content/handlers/javascript/duktape/Window.bnd @@ -277,6 +277,9 @@ static duk_ret_t dukky_window_closedown_thread(duk_context *ctx) init Window(struct browser_window *win, struct html_content *htmlc) %{ + /* It makes no sense if win or htmlc are NULL */ + assert(win != NULL); + assert(htmlc != NULL); /* element window */ priv->win = win; priv->htmlc = htmlc; diff --git a/content/handlers/javascript/duktape/dukky.c b/content/handlers/javascript/duktape/dukky.c index 7357863..6d87712 100644 --- a/content/handlers/javascript/duktape/dukky.c +++ b/content/handlers/javascript/duktape/dukky.c @@ -925,6 +925,11 @@ js_exec(jsthread *thread, const uint8_t *txt, size_t txtlen, const char *name) return false; } + if (thread->pending_destroy) { + NSLOG(dukky, DEEPDEBUG, "Skipping exec call because thread is dead"); + return false; + } + dukky_enter_thread(thread); duk_set_top(CTX, 0); -- NetSurf Browser

2 years, 10 months

1
0
0 / 0

netsurf: branch master updated. release/3.9-604-gb577de7

by NetSurf Browser Project

Gitweb links: ...log http://git.netsurf-browser.org/netsurf.git/shortlog/b577de7c5bbba6c2f9a0b... ...commit http://git.netsurf-browser.org/netsurf.git/commit/b577de7c5bbba6c2f9a0b4e... ...tree http://git.netsurf-browser.org/netsurf.git/tree/b577de7c5bbba6c2f9a0b4ede... The branch, master has been updated via b577de7c5bbba6c2f9a0b4ede3f814ea3023ded6 (commit) from 309fcd6d428b2f552fd27bf93154a09d5836eed4 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commitdiff http://git.netsurf-browser.org/netsurf.git/commit/?id=b577de7c5bbba6c2f9a... commit b577de7c5bbba6c2f9a0b4ede3f814ea3023ded6 Author: Vincent Sanders <vince(a)kyllikki.org> Commit: Vincent Sanders <vince(a)kyllikki.org> remove forward declarations reorder module to remove need for forward function declarations. remove unecessary and confusing parameter macros diff --git a/content/handlers/html/box.h b/content/handlers/html/box.h index 8ab2875..efad90f 100644 --- a/content/handlers/html/box.h +++ b/content/handlers/html/box.h @@ -369,8 +369,20 @@ nserror box_handle_scrollbars(struct content *c, struct box *box, bool box_vscrollbar_present(const struct box *box); bool box_hscrollbar_present(const struct box *box); +/** + * Construct a box tree from an xml tree and stylesheets. + * + * \param n xml tree + * \param c content of type CONTENT_HTML to construct box tree in + * \param cb callback to report conversion completion + * \return netsurf error code indicating status of call + */ nserror dom_to_box(struct dom_node *n, struct html_content *c, box_construct_complete_cb cb, void **box_conversion_context); + +/** + * aborts any ongoing box construction + */ nserror cancel_dom_to_box(void *box_conversion_context); bool box_normalise_block( diff --git a/content/handlers/html/box_construct.c b/content/handlers/html/box_construct.c index 6271405..b1f3461 100644 --- a/content/handlers/html/box_construct.c +++ b/content/handlers/html/box_construct.c @@ -99,153 +99,37 @@ const char *TARGET_PARENT = "_parent"; const char *TARGET_TOP = "_top"; const char *TARGET_BLANK = "_blank"; -static void convert_xml_to_box(struct box_construct_ctx *ctx); -static bool box_construct_element(struct box_construct_ctx *ctx, - bool *convert_children); -static void box_construct_element_after(dom_node *n, html_content *content); -static bool box_construct_text(struct box_construct_ctx *ctx); -static css_select_results * box_get_style(html_content *c, - const css_computed_style *parent_style, - const css_computed_style *root_style, dom_node *n); -static void box_text_transform(char *s, unsigned int len, - enum css_text_transform_e tt); -#define BOX_SPECIAL_PARAMS dom_node *n, html_content *content, \ - struct box *box, bool *convert_children -static bool box_a(BOX_SPECIAL_PARAMS); -static bool box_body(BOX_SPECIAL_PARAMS); -static bool box_br(BOX_SPECIAL_PARAMS); -static bool box_image(BOX_SPECIAL_PARAMS); -static bool box_textarea(BOX_SPECIAL_PARAMS); -static bool box_select(BOX_SPECIAL_PARAMS); -static bool box_input(BOX_SPECIAL_PARAMS); -static bool box_button(BOX_SPECIAL_PARAMS); -static bool box_frameset(BOX_SPECIAL_PARAMS); -static bool box_create_frameset(struct content_html_frames *f, dom_node *n, - html_content *content); -static bool box_select_add_option(struct form_control *control, dom_node *n); -static bool box_noscript(BOX_SPECIAL_PARAMS); -static bool box_object(BOX_SPECIAL_PARAMS); -static bool box_embed(BOX_SPECIAL_PARAMS); -static bool box_pre(BOX_SPECIAL_PARAMS); -static bool box_iframe(BOX_SPECIAL_PARAMS); -static bool box_get_attribute(dom_node *n, const char *attribute, - void *context, char **value); - -/* element_table must be sorted by name */ -struct element_entry { - char name[10]; /* element type */ - bool (*convert)(BOX_SPECIAL_PARAMS); -}; -static const struct element_entry element_table[] = { - {"a", box_a}, - {"body", box_body}, - {"br", box_br}, - {"button", box_button}, - {"embed", box_embed}, - {"frameset", box_frameset}, - {"iframe", box_iframe}, - {"img", box_image}, - {"input", box_input}, - {"noscript", box_noscript}, - {"object", box_object}, - {"pre", box_pre}, - {"select", box_select}, - {"textarea", box_textarea} -}; -#define ELEMENT_TABLE_COUNT (sizeof(element_table) / sizeof(element_table[0])) - /** - * Construct a box tree from an xml tree and stylesheets. - * - * \param n xml tree - * \param c content of type CONTENT_HTML to construct box tree in - * \param cb callback to report conversion completion - * \return netsurf error code indicating status of call + * mapping from CSS display to box type this table must be in sync + * with libcss' css_display enum */ - -nserror dom_to_box(dom_node *n, html_content *c, box_construct_complete_cb cb, void **box_conversion_context) -{ - struct box_construct_ctx *ctx; - - assert(box_conversion_context != NULL); - - if (c->bctx == NULL) { - /* create a context allocation for this box tree */ - c->bctx = talloc_zero(0, int); - if (c->bctx == NULL) { - return NSERROR_NOMEM; - } - } - - ctx = malloc(sizeof(*ctx)); - if (ctx == NULL) { - return NSERROR_NOMEM; - } - - ctx->content = c; - ctx->n = dom_node_ref(n); - ctx->root_box = NULL; - ctx->cb = cb; - ctx->bctx = c->bctx; - - *box_conversion_context = ctx; - - return guit->misc->schedule(0, (void *)convert_xml_to_box, ctx); -} - -nserror cancel_dom_to_box(void *box_conversion_context) -{ - struct box_construct_ctx *ctx = box_conversion_context; - nserror err; - - err = guit->misc->schedule(-1, (void *)convert_xml_to_box, ctx); - if (err != NSERROR_OK) { - return err; - } - - dom_node_unref(ctx->n); - free(ctx); - - return NSERROR_OK; -} - - -/* mapping from CSS display to box type - * this table must be in sync with libcss' css_display enum */ static const box_type box_map[] = { - 0, /*CSS_DISPLAY_INHERIT,*/ - BOX_INLINE, /*CSS_DISPLAY_INLINE,*/ - BOX_BLOCK, /*CSS_DISPLAY_BLOCK,*/ - BOX_BLOCK, /*CSS_DISPLAY_LIST_ITEM,*/ - BOX_INLINE, /*CSS_DISPLAY_RUN_IN,*/ - BOX_INLINE_BLOCK, /*CSS_DISPLAY_INLINE_BLOCK,*/ - BOX_TABLE, /*CSS_DISPLAY_TABLE,*/ - BOX_TABLE, /*CSS_DISPLAY_INLINE_TABLE,*/ - BOX_TABLE_ROW_GROUP, /*CSS_DISPLAY_TABLE_ROW_GROUP,*/ - BOX_TABLE_ROW_GROUP, /*CSS_DISPLAY_TABLE_HEADER_GROUP,*/ - BOX_TABLE_ROW_GROUP, /*CSS_DISPLAY_TABLE_FOOTER_GROUP,*/ - BOX_TABLE_ROW, /*CSS_DISPLAY_TABLE_ROW,*/ - BOX_NONE, /*CSS_DISPLAY_TABLE_COLUMN_GROUP,*/ - BOX_NONE, /*CSS_DISPLAY_TABLE_COLUMN,*/ - BOX_TABLE_CELL, /*CSS_DISPLAY_TABLE_CELL,*/ - BOX_INLINE, /*CSS_DISPLAY_TABLE_CAPTION,*/ - BOX_NONE /*CSS_DISPLAY_NONE*/ + 0, /* CSS_DISPLAY_INHERIT, */ + BOX_INLINE, /* CSS_DISPLAY_INLINE, */ + BOX_BLOCK, /* CSS_DISPLAY_BLOCK, */ + BOX_BLOCK, /* CSS_DISPLAY_LIST_ITEM, */ + BOX_INLINE, /* CSS_DISPLAY_RUN_IN, */ + BOX_INLINE_BLOCK, /* CSS_DISPLAY_INLINE_BLOCK, */ + BOX_TABLE, /* CSS_DISPLAY_TABLE, */ + BOX_TABLE, /* CSS_DISPLAY_INLINE_TABLE, */ + BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_ROW_GROUP, */ + BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_HEADER_GROUP, */ + BOX_TABLE_ROW_GROUP, /* CSS_DISPLAY_TABLE_FOOTER_GROUP, */ + BOX_TABLE_ROW, /* CSS_DISPLAY_TABLE_ROW, */ + BOX_NONE, /* CSS_DISPLAY_TABLE_COLUMN_GROUP, */ + BOX_NONE, /* CSS_DISPLAY_TABLE_COLUMN, */ + BOX_TABLE_CELL, /* CSS_DISPLAY_TABLE_CELL, */ + BOX_INLINE, /* CSS_DISPLAY_TABLE_CAPTION, */ + BOX_NONE /* CSS_DISPLAY_NONE */ }; -/* Exported function, see box.h */ -struct box *box_for_node(dom_node *n) -{ - struct box *box = NULL; - dom_exception err; - - err = dom_node_get_user_data(n, corestring_dom___ns_key_box_node_data, - (void *) &box); - if (err != DOM_NO_ERR) - return NULL; - - return box; -} +/** + * determine if a box is the root node + * + * \param n node to check + * \return true if node is root else false. + */ static inline bool box_is_root(dom_node *n) { dom_node *parent; @@ -271,2844 +155,3074 @@ static inline bool box_is_root(dom_node *n) return true; } + /** - * Find the next node in the DOM tree, completing - * element construction where appropriate. - * - * \param n Current node - * \param content Containing content - * \param convert_children Whether to consider children of \a n - * \return Next node to process, or NULL if complete + * Destructor for object_params, for <object> elements * - * \note \a n will be unreferenced + * \param o The object params being destroyed. + * \return 0 to allow talloc to continue destroying the tree. */ -static dom_node *next_node(dom_node *n, html_content *content, - bool convert_children) +static int box_object_talloc_destructor(struct object_params *o) { - dom_node *next = NULL; - bool has_children; - dom_exception err; - - err = dom_node_has_child_nodes(n, &has_children); - if (err != DOM_NO_ERR) { - dom_node_unref(n); - return NULL; - } - - if (convert_children && has_children) { - err = dom_node_get_first_child(n, &next); - if (err != DOM_NO_ERR) { - dom_node_unref(n); - return NULL; - } - dom_node_unref(n); - } else { - err = dom_node_get_next_sibling(n, &next); - if (err != DOM_NO_ERR) { - dom_node_unref(n); - return NULL; - } - - if (next != NULL) { - if (box_for_node(n) != NULL) - box_construct_element_after(n, content); - dom_node_unref(n); - } else { - if (box_for_node(n) != NULL) - box_construct_element_after(n, content); - - while (box_is_root(n) == false) { - dom_node *parent = NULL; - dom_node *parent_next = NULL; - - err = dom_node_get_parent_node(n, &parent); - if (err != DOM_NO_ERR) { - dom_node_unref(n); - return NULL; - } - - assert(parent != NULL); - - err = dom_node_get_next_sibling(parent, - &parent_next); - if (err != DOM_NO_ERR) { - dom_node_unref(parent); - dom_node_unref(n); - return NULL; - } - - if (parent_next != NULL) { - dom_node_unref(parent_next); - dom_node_unref(parent); - break; - } - - dom_node_unref(n); - n = parent; - parent = NULL; - - if (box_for_node(n) != NULL) { - box_construct_element_after( - n, content); - } - } + if (o->codebase != NULL) + nsurl_unref(o->codebase); + if (o->classid != NULL) + nsurl_unref(o->classid); + if (o->data != NULL) + nsurl_unref(o->data); - if (box_is_root(n) == false) { - dom_node *parent = NULL; + return 0; +} - err = dom_node_get_parent_node(n, &parent); - if (err != DOM_NO_ERR) { - dom_node_unref(n); - return NULL; - } - assert(parent != NULL); +/** + * Parse a multi-length-list, as defined by HTML 4.01. + * + * \param ds dom string to parse + * \param count updated to number of entries + * \return array of struct box_multi_length, or 0 on memory exhaustion + */ +static struct frame_dimension * +box_parse_multi_lengths(const dom_string *ds, unsigned int *count) +{ + char *end; + unsigned int i, n; + struct frame_dimension *length; + const char *s; - err = dom_node_get_next_sibling(parent, &next); - if (err != DOM_NO_ERR) { - dom_node_unref(parent); - dom_node_unref(n); - return NULL; - } + s = dom_string_data(ds); - if (box_for_node(parent) != NULL) { - box_construct_element_after(parent, - content); - } + for (i = 0, n = 1; s[i]; i++) + if (s[i] == ',') + n++; - dom_node_unref(parent); - } + length = calloc(n, sizeof(struct frame_dimension)); + if (!length) + return NULL; - dom_node_unref(n); + for (i = 0; i != n; i++) { + while (ascii_is_space(*s)) { + s++; + } + length[i].value = strtof(s, &end); + if (length[i].value <= 0) { + length[i].value = 1; + } + s = end; + switch (*s) { + case '%': + length[i].unit = FRAME_DIMENSION_PERCENT; + break; + case '*': + length[i].unit = FRAME_DIMENSION_RELATIVE; + break; + default: + length[i].unit = FRAME_DIMENSION_PIXELS; + break; + } + while (*s && *s != ',') { + s++; + } + if (*s == ',') { + s++; } } - return next; + *count = n; + return length; } + /** - * Convert an ELEMENT node to a box tree fragment, - * then schedule conversion of the next ELEMENT node + * Destructor for content_html_frames, for frame elements + * + * \param f The frame params being destroyed. + * \return 0 to allow talloc to continue destroying the tree. */ -void convert_xml_to_box(struct box_construct_ctx *ctx) +static int box_frames_talloc_destructor(struct content_html_frames *f) { - dom_node *next; - bool convert_children; - uint32_t num_processed = 0; - const uint32_t max_processed_before_yield = 10; - - do { - convert_children = true; + if (f->url != NULL) { + nsurl_unref(f->url); + f->url = NULL; + } - assert(ctx->n != NULL); + return 0; +} - if (box_construct_element(ctx, &convert_children) == false) { - ctx->cb(ctx->content, false); - dom_node_unref(ctx->n); - free(ctx); - retur

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

netsurf-commits April 2020