/* * Copyright 2007 James Bursa * Copyright 2010 Michael Drake * * 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 . */ /** \file * Content for text/html (implementation). */ #include #include #include #include #include #include #include "utils/config.h" #include "content/content_protected.h" #include "content/fetch.h" #include "content/hlcache.h" #include "desktop/browser.h" #include "desktop/gui.h" #include "desktop/options.h" #include "desktop/selection.h" #include "image/bitmap.h" #include "render/box.h" #include "render/font.h" #include "render/form.h" #include "render/html_internal.h" #include "render/imagemap.h" #include "render/layout.h" #include "render/search.h" #include "utils/http.h" #include "utils/log.h" #include "utils/messages.h" #include "utils/schedule.h" #include "utils/talloc.h" #include "utils/url.h" #include "utils/utils.h" #define CHUNK 4096 /* Change these to 1 to cause a dump to stderr of the frameset or box * when the trees have been built. */ #define ALWAYS_DUMP_FRAMESET 0 #define ALWAYS_DUMP_BOX 0 static nserror html_create(const content_handler *handler, lwc_string *imime_type, const http_parameter *params, llcache_handle *llcache, const char *fallback_charset, bool quirks, struct content **c); static nserror html_create_html_data(html_content *c, const http_parameter *params); static bool html_process_data(struct content *c, const char *data, unsigned int size); static bool html_convert(struct content *c); static void html_reformat(struct content *c, int width, int height); static void html_destroy(struct content *c); static void html_stop(struct content *c); static void html_open(struct content *c, struct browser_window *bw, struct content *page, struct box *box, struct object_params *params); static void html_close(struct content *c); struct selection *html_get_selection(struct content *c); struct search_context *html_get_search(struct content *c); static nserror html_clone(const struct content *old, struct content **newc); static content_type html_content_type(void); static void html_finish_conversion(html_content *c); static nserror html_convert_css_callback(hlcache_handle *css, const hlcache_event *event, void *pw); static bool html_meta_refresh(html_content *c, xmlNode *head); static bool html_head(html_content *c, xmlNode *head); static bool html_find_stylesheets(html_content *c, xmlNode *html); static bool html_process_style_element(html_content *c, unsigned int *index, xmlNode *style); static void html_inline_style_done(struct content_css_data *css, void *pw); static bool html_replace_object(struct content_html_object *object, const char *url); static nserror html_object_callback(hlcache_handle *object, const hlcache_event *event, void *pw); static void html_object_done(struct box *box, hlcache_handle *object, bool background); static void html_object_failed(struct box *box, html_content *content, bool background); static void html_object_refresh(void *p); static void html_destroy_objects(html_content *html); static void html_destroy_frameset(struct content_html_frames *frameset); static void html_destroy_iframe(struct content_html_iframe *iframe); #if ALWAYS_DUMP_FRAMESET static void html_dump_frameset(struct content_html_frames *frame, unsigned int depth); #endif static const content_handler html_content_handler = { .create = html_create, .process_data = html_process_data, .data_complete = html_convert, .reformat = html_reformat, .destroy = html_destroy, .stop = html_stop, .mouse_track = html_mouse_track, .mouse_action = html_mouse_action, .redraw = html_redraw, .open = html_open, .close = html_close, .get_selection = html_get_selection, .clone = html_clone, .type = html_content_type, .no_share = true, }; static const char empty_document[] = "" "" "" "Empty document" "" "" "

Empty document

" "

The document sent by the server is empty.

" "" ""; static const char *html_types[] = { "application/xhtml+xml", "text/html" }; static lwc_string *html_mime_types[NOF_ELEMENTS(html_types)]; static lwc_string *html_charset; nserror html_init(void) { uint32_t i; lwc_error lerror; nserror error; lerror = lwc_intern_string("charset", SLEN("charset"), &html_charset); if (lerror != lwc_error_ok) { error = NSERROR_NOMEM; goto error; } for (i = 0; i < NOF_ELEMENTS(html_mime_types); i++) { lerror = lwc_intern_string(html_types[i], strlen(html_types[i]), &html_mime_types[i]); if (lerror != lwc_error_ok) { error = NSERROR_NOMEM; goto error; } error = content_factory_register_handler(html_mime_types[i], &html_content_handler); if (error != NSERROR_OK) goto error; } return NSERROR_OK; error: html_fini(); return error; } void html_fini(void) { uint32_t i; for (i = 0; i < NOF_ELEMENTS(html_mime_types); i++) { if (html_mime_types[i] != NULL) lwc_string_unref(html_mime_types[i]); } if (html_charset != NULL) lwc_string_unref(html_charset); } /** * Create a CONTENT_HTML. * * The content_html_data structure is initialized and the HTML parser is * created. */ nserror html_create(const content_handler *handler, lwc_string *imime_type, const http_parameter *params, llcache_handle *llcache, const char *fallback_charset, bool quirks, struct content **c) { html_content *html; nserror error; html = talloc_zero(0, html_content); if (html == NULL) return NSERROR_NOMEM; error = content__init(&html->base, handler, imime_type, params, llcache, fallback_charset, quirks); if (error != NSERROR_OK) { talloc_free(html); return error; } error = html_create_html_data(html, params); if (error != NSERROR_OK) { talloc_free(html); return error; } *c = (struct content *) html; return NSERROR_OK; } nserror html_create_html_data(html_content *c, const http_parameter *params) { lwc_string *charset; union content_msg_data msg_data; binding_error error; nserror nerror; c->parser_binding = NULL; c->document = NULL; c->quirks = BINDING_QUIRKS_MODE_NONE; c->encoding = NULL; c->base_url = (char *) content__get_url(&c->base); c->base_target = NULL; c->aborted = false; c->layout = NULL; c->background_colour = NS_TRANSPARENT; c->stylesheet_count = 0; c->stylesheets = NULL; c->select_ctx = NULL; c->num_objects = 0; c->object_list = NULL; c->forms = NULL; c->imagemaps = NULL; c->bw = NULL; c->frameset = NULL; c->iframe = NULL; c->page = NULL; c->box = NULL; c->font_func = &nsfont; c->scrollbar = NULL; selection_prepare(&c->sel, (struct content *)c, true); nerror = http_parameter_list_find_item(params, html_charset, &charset); if (nerror == NSERROR_OK) { c->encoding = talloc_strdup(c, lwc_string_data(charset)); lwc_string_unref(charset); if (c->encoding == NULL) { error = BINDING_NOMEM; goto error; } c->encoding_source = ENCODING_SOURCE_HEADER; } /* Create the parser binding */ error = binding_create_tree(c, c->encoding, &c->parser_binding); if (error == BINDING_BADENCODING && c->encoding != NULL) { /* Ok, we don't support the declared encoding. Bailing out * isn't exactly user-friendly, so fall back to autodetect */ talloc_free(c->encoding); c->encoding = NULL; error = binding_create_tree(c, c->encoding, &c->parser_binding); } if (error != BINDING_OK) goto error; return NSERROR_OK; error: if (error == BINDING_BADENCODING) { LOG(("Bad encoding: %s", c->encoding ? c->encoding : "")); msg_data.error = messages_get("ParsingFail"); nerror = NSERROR_BAD_ENCODING; } else { msg_data.error = messages_get("NoMemory"); nerror = NSERROR_NOMEM; } content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); return nerror; } /** * Process data for CONTENT_HTML. * * The data is parsed in chunks of size CHUNK, multitasking in between. */ bool html_process_data(struct content *c, const char *data, unsigned int size) { html_content *html = (html_content *) c; unsigned long x; binding_error err; const char *encoding; for (x = 0; x + CHUNK <= size; x += CHUNK) { err = binding_parse_chunk(html->parser_binding, (const uint8_t *) data + x, CHUNK); if (err == BINDING_ENCODINGCHANGE) { goto encoding_change; } else if (err != BINDING_OK) { union content_msg_data msg_data; msg_data.error = messages_get("NoMemory"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } gui_multitask(); } err = binding_parse_chunk(html->parser_binding, (const uint8_t *) data + x, (size - x)); if (err == BINDING_ENCODINGCHANGE) { goto encoding_change; } else if (err != BINDING_OK) { union content_msg_data msg_data; msg_data.error = messages_get("NoMemory"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } return true; encoding_change: /* Retrieve new encoding */ encoding = binding_get_encoding( html->parser_binding, &html->encoding_source); if (html->encoding != NULL) talloc_free(html->encoding); html->encoding = talloc_strdup(c, encoding); if (html->encoding == NULL) { union content_msg_data msg_data; msg_data.error = messages_get("NoMemory"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } /* Destroy binding */ binding_destroy_tree(html->parser_binding); /* Create new binding, using the new encoding */ err = binding_create_tree(html, html->encoding, &html->parser_binding); if (err == BINDING_BADENCODING) { /* Ok, we don't support the declared encoding. Bailing out * isn't exactly user-friendly, so fall back to Windows-1252 */ talloc_free(html->encoding); html->encoding = talloc_strdup(c, "Windows-1252"); if (html->encoding == NULL) { union content_msg_data msg_data; msg_data.error = messages_get("NoMemory"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } err = binding_create_tree(html, html->encoding, &html->parser_binding); } if (err != BINDING_OK) { union content_msg_data msg_data; if (err == BINDING_BADENCODING) { LOG(("Bad encoding: %s", html->encoding ? html->encoding : "")); msg_data.error = messages_get("ParsingFail"); } else msg_data.error = messages_get("NoMemory"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } { const char *source_data; unsigned long source_size; source_data = content__get_source_data(c, &source_size); /* Recurse to reprocess all that data. This is safe because * the encoding is now specified at parser-start which means * it cannot be changed again. */ return html_process_data(c, source_data, source_size); } } /** * Convert a CONTENT_HTML for display. * * The following steps are carried out in order: * * - parsing to an XML tree is completed * - stylesheets are fetched * - the XML tree is converted to a box tree and object fetches are started * * On exit, the content status will be either CONTENT_STATUS_DONE if the * document is completely loaded or CONTENT_STATUS_READY if objects are still * being fetched. */ bool html_convert(struct content *c) { html_content *htmlc = (html_content *) c; binding_error err; xmlNode *html, *head; union content_msg_data msg_data; unsigned long size; struct form *f; /* finish parsing */ content__get_source_data(c, &size); if (size == 0) { /* Destroy current binding */ binding_destroy_tree(htmlc->parser_binding); /* Also, any existing encoding information, * as it's not guaranteed to match the error page. */ talloc_free(htmlc->encoding); htmlc->encoding = NULL; /* Create new binding, using default charset */ err = binding_create_tree(c, NULL, &htmlc->parser_binding); if (err != BINDING_OK) { union content_msg_data msg_data; if (err == BINDING_BADENCODING) { LOG(("Bad encoding: %s", htmlc->encoding ? htmlc->encoding : "")); msg_data.error = messages_get("ParsingFail"); } else msg_data.error = messages_get("NoMemory"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } /* Process the error page */ if (html_process_data(c, (char *) empty_document, SLEN(empty_document)) == false) return false; } err = binding_parse_completed(htmlc->parser_binding); if (err != BINDING_OK) { union content_msg_data msg_data; msg_data.error = messages_get("NoMemory"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } htmlc->document = binding_get_document(htmlc->parser_binding, &htmlc->quirks); /*xmlDebugDumpDocument(stderr, htmlc->document);*/ if (htmlc->document == NULL) { LOG(("Parsing failed")); msg_data.error = messages_get("ParsingFail"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } if (htmlc->encoding == NULL) { const char *encoding = binding_get_encoding( htmlc->parser_binding, &htmlc->encoding_source); htmlc->encoding = talloc_strdup(c, encoding); if (htmlc->encoding == NULL) { msg_data.error = messages_get("NoMemory"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } } /* Give up processing if we've been aborted */ if (htmlc->aborted) { msg_data.error = messages_get("Stopped"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } /* locate html and head elements */ html = xmlDocGetRootElement(htmlc->document); if (html == NULL || strcmp((const char *) html->name, "html") != 0) { LOG(("html element not found")); msg_data.error = messages_get("ParsingFail"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } for (head = html->children; head != NULL && head->type != XML_ELEMENT_NODE; head = head->next) ; if (head && strcmp((const char *) head->name, "head") != 0) { head = NULL; LOG(("head element not found")); } if (head != NULL) { if (html_head(htmlc, head) == false) { msg_data.error = messages_get("NoMemory"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } /* handle meta refresh */ if (html_meta_refresh(htmlc, head) == false) return false; } /* Retrieve forms from parser */ htmlc->forms = binding_get_forms(htmlc->parser_binding); for (f = htmlc->forms; f != NULL; f = f->prev) { char *action; url_func_result res; /* Make all actions absolute */ if (f->action == NULL || f->action[0] == '\0') { /* HTML5 4.10.22.3 step 11 */ res = url_join(content__get_url(c), htmlc->base_url, &action); } else { res = url_join(f->action, htmlc->base_url, &action); } if (res != URL_FUNC_OK) { msg_data.error = messages_get("NoMemory"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } free(f->action); f->action = action; /* Ensure each form has a document encoding */ if (f->document_charset == NULL) { f->document_charset = strdup(htmlc->encoding); if (f->document_charset == NULL) { msg_data.error = messages_get("NoMemory"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } } } /* get stylesheets */ if (html_find_stylesheets(htmlc, html) == false) return false; return true; } /** * Complete conversion of an HTML document * * \param c Content to convert */ void html_finish_conversion(html_content *c) { union content_msg_data msg_data; xmlNode *html; uint32_t i; css_error error; /* Bail out if we've been aborted */ if (c->aborted) { msg_data.error = messages_get("Stopped"); content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); content_set_error(&c->base); return; } html = xmlDocGetRootElement(c->document); assert(html != NULL); /* check that the base stylesheet loaded; layout fails without it */ if (c->stylesheets[STYLESHEET_BASE].data.external == NULL) { msg_data.error = "Base stylesheet failed to load"; content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); content_set_error(&c->base); return; } /* Create selection context */ error = css_select_ctx_create(ns_realloc, c, &c->select_ctx); if (error != CSS_OK) { msg_data.error = messages_get("NoMemory"); content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); content_set_error(&c->base); return; } /* Add sheets to it */ for (i = STYLESHEET_BASE; i != c->stylesheet_count; i++) { const struct html_stylesheet *hsheet = &c->stylesheets[i]; css_stylesheet *sheet; css_origin origin = CSS_ORIGIN_AUTHOR; if (i < STYLESHEET_START) origin = CSS_ORIGIN_UA; if (hsheet->type == HTML_STYLESHEET_EXTERNAL && hsheet->data.external != NULL) { sheet = nscss_get_stylesheet(hsheet->data.external); } else if (hsheet->type == HTML_STYLESHEET_INTERNAL) { sheet = hsheet->data.internal->sheet; } else { sheet = NULL; } if (sheet != NULL) { error = css_select_ctx_append_sheet( c->select_ctx, sheet, origin, CSS_MEDIA_SCREEN); if (error != CSS_OK) { msg_data.error = messages_get("NoMemory"); content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); content_set_error(&c->base); return; } } } /* convert xml tree to box tree */ LOG(("XML to box")); content_set_status(&c->base, messages_get("Processing")); content_broadcast(&c->base, CONTENT_MSG_STATUS, msg_data); if (xml_to_box(html, c) == false) { html_destroy_objects(c); msg_data.error = messages_get("NoMemory"); content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); content_set_error(&c->base); return; } #if ALWAYS_DUMP_BOX box_dump(stderr, c->layout->children, 0); #endif #if ALWAYS_DUMP_FRAMESET if (c->frameset) html_dump_frameset(c->frameset, 0); #endif /* extract image maps - can't do this sensibly in xml_to_box */ if (imagemap_extract(html, c) == false) { LOG(("imagemap extraction failed")); html_destroy_objects(c); msg_data.error = messages_get("NoMemory"); content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); content_set_error(&c->base); return; } /*imagemap_dump(c);*/ /* Destroy the parser binding */ binding_destroy_tree(c->parser_binding); c->parser_binding = NULL; content_set_ready(&c->base); if (c->base.active == 0) content_set_done(&c->base); html_set_status(c, ""); } /** * Process elements in . * * \param c content structure * \param head xml node of head element * \return true on success, false on memory exhaustion * * The title and base href are extracted if present. */ bool html_head(html_content *c, xmlNode *head) { xmlNode *node; xmlChar *s; for (node = head->children; node != 0; node = node->next) { if (node->type != XML_ELEMENT_NODE) continue; if (c->base.title == NULL && strcmp((const char *) node->name, "title") == 0) { xmlChar *title = xmlNodeGetContent(node); char *title2; if (!title) return false; title2 = squash_whitespace((const char *) title); xmlFree(title); if (!title2) return false; if (content__set_title(&c->base, title2) == false) { free(title2); return false; } free(title2); } else if (strcmp((const char *) node->name, "base") == 0) { char *href = (char *) xmlGetProp(node, (const xmlChar *) "href"); if (href) { char *url; url_func_result res; res = url_normalize(href, &url); if (res == URL_FUNC_OK) { c->base_url = talloc_strdup(c, url); free(url); } xmlFree(href); } /* don't use the central values to ease freeing later on */ if ((s = xmlGetProp(node, (const xmlChar *) "target"))) { if ((!strcasecmp((const char *) s, "_blank")) || (!strcasecmp((const char *) s, "_top")) || (!strcasecmp((const char *) s, "_parent")) || (!strcasecmp((const char *) s, "_self")) || ('a' <= s[0] && s[0] <= 'z') || ('A' <= s[0] && s[0] <= 'Z')) { /* [6.16] */ c->base_target = talloc_strdup(c, (const char *) s); if (!c->base_target) { xmlFree(s); return false; } } xmlFree(s); } } } return true; } /** * Search for meta refresh * * http://wp.netscape.com/assist/net_sites/pushpull.html * * \param c content structure * \param head xml node of head element * \return true on success, false otherwise (error reported) */ bool html_meta_refresh(html_content *c, xmlNode *head) { xmlNode *n; xmlChar *equiv, *content; union content_msg_data msg_data; char *url, *end, *refresh = NULL, quote = 0; url_func_result res; for (n = head == 0 ? 0 : head->children; n; n = n->next) { if (n->type != XML_ELEMENT_NODE) continue; /* Recurse into noscript elements */ if (strcmp((const char *) n->name, "noscript") == 0) { if (!html_meta_refresh(c, n)) { /* Some error occurred */ return false; } else if (c->base.refresh) { /* Meta refresh found - stop */ return true; } } if (strcmp((const char *) n->name, "meta")) { continue; } equiv = xmlGetProp(n, (const xmlChar *) "http-equiv"); if (!equiv) continue; if (strcasecmp((const char *) equiv, "refresh")) { xmlFree(equiv); continue; } xmlFree(equiv); content = xmlGetProp(n, (const xmlChar *) "content"); if (!content) continue; end = (char *) content + strlen((const char *) content); /* content := *LWS intpart fracpart? *LWS [';' *LWS *1url *LWS] * intpart := 1*DIGIT * fracpart := 1*('.' | DIGIT) * url := "url" *LWS '=' *LWS (url-nq | url-sq | url-dq) * url-nq := *urlchar * url-sq := "'" *(urlchar | '"') "'" * url-dq := '"' *(urlchar | "'") '"' * urlchar := [#x9#x21#x23-#x26#x28-#x7E] | nonascii * nonascii := [#x80-#xD7FF#xE000-#xFFFD#x10000-#x10FFFF] */ /* *LWS intpart */ msg_data.delay = (int)strtol((char *) content, &url, 10); /* a very small delay and self-referencing URL can cause a loop * that grinds machines to a halt. To prevent this we set a * minimum refresh delay of 1s. */ if (msg_data.delay < 1) msg_data.delay = 1; /* fracpart? (ignored, as delay is integer only) */ while (url < end && (('0' <= *url && *url <= '9') || *url == '.')) { url++; } /* *LWS */ while (url < end && isspace(*url)) { url++; } /* ';' */ if (url < end && *url == ';') url++; /* *LWS */ while (url < end && isspace(*url)) { url++; } if (url == end) { /* Just delay specified, so refresh current page */ xmlFree(content); c->base.refresh = talloc_strdup(c, content__get_url(&c->base)); if (!c->base.refresh) { msg_data.error = messages_get("NoMemory"); content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); return false; } content_broadcast(&c->base, CONTENT_MSG_REFRESH, msg_data); break; } /* "url" */ if (url <= end - 3) { if (strncasecmp(url, "url", 3) == 0) { url += 3; } else { /* Unexpected input, ignore this header */ continue; } } else { /* Insufficient input, ignore this header */ continue; } /* *LWS */ while (url < end && isspace(*url)) { url++; } /* '=' */ if (url < end) { if (*url == '=') { url++; } else { /* Unexpected input, ignore this header */ continue; } } else { /* Insufficient input, ignore this header */ continue; } /* *LWS */ while (url < end && isspace(*url)) { url++; } /* '"' or "'" */ if (url < end && (*url == '"' || *url == '\'')) { quote = *url; url++; } /* Start of URL */ refresh = url; if (quote != 0) { /* url-sq | url-dq */ while (url < end && *url != quote) url++; } else { /* url-nq */ while (url < end && !isspace(*url)) url++; } /* '"' or "'" or *LWS (we don't care) */ if (url < end) *url = '\0'; res = url_join(refresh, c->base_url, &refresh); xmlFree(content); if (res == URL_FUNC_NOMEM) { msg_data.error = messages_get("NoMemory"); content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); return false; } else if (res == URL_FUNC_FAILED) { /* This isn't fatal so carry on looking */ continue; } c->base.refresh = talloc_strdup(c, refresh); free(refresh); if (!c->base.refresh) { msg_data.error = messages_get("NoMemory"); content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); return false; } content_broadcast(&c->base, CONTENT_MSG_REFRESH, msg_data); } return true; } /** * Process inline stylesheets and fetch linked stylesheets. * * Uses STYLE and LINK elements inside and outside HEAD * * \param c content structure * \param html xml node of html element * \return true on success, false if an error occurred */ bool html_find_stylesheets(html_content *c, xmlNode *html) { content_type accept = CONTENT_CSS; xmlNode *node; char *rel, *type, *media, *href, *url, *url2; unsigned int i = STYLESHEET_START; union content_msg_data msg_data; url_func_result res; struct html_stylesheet *stylesheets; hlcache_child_context child; nserror ns_error; child.charset = c->encoding; child.quirks = c->base.quirks; /* stylesheet 0 is the base style sheet, * stylesheet 1 is the quirks mode style sheet, * stylesheet 2 is the adblocking stylesheet */ c->stylesheets = talloc_array(c, struct html_stylesheet, STYLESHEET_START); if (c->stylesheets == NULL) goto no_memory; c->stylesheets[STYLESHEET_BASE].type = HTML_STYLESHEET_EXTERNAL; c->stylesheets[STYLESHEET_BASE].data.external = NULL; c->stylesheets[STYLESHEET_QUIRKS].type = HTML_STYLESHEET_EXTERNAL; c->stylesheets[STYLESHEET_QUIRKS].data.external = NULL; c->stylesheets[STYLESHEET_ADBLOCK].type = HTML_STYLESHEET_EXTERNAL; c->stylesheets[STYLESHEET_ADBLOCK].data.external = NULL; c->stylesheet_count = STYLESHEET_START; c->base.active = 0; ns_error = hlcache_handle_retrieve(default_stylesheet_url, 0, content__get_url(&c->base), NULL, html_convert_css_callback, c, &child, accept, &c->stylesheets[STYLESHEET_BASE].data.external); if (ns_error != NSERROR_OK) goto no_memory; c->base.active++; if (c->quirks == BINDING_QUIRKS_MODE_FULL) { ns_error = hlcache_handle_retrieve(quirks_stylesheet_url, 0, content__get_url(&c->base), NULL, html_convert_css_callback, c, &child, accept, &c->stylesheets[STYLESHEET_QUIRKS]. data.external); if (ns_error != NSERROR_OK) goto no_memory; c->base.active++; } if (option_block_ads) { ns_error = hlcache_handle_retrieve(adblock_stylesheet_url, 0, content__get_url(&c->base), NULL, html_convert_css_callback, c, &child, accept, &c->stylesheets[STYLESHEET_ADBLOCK]. data.external); if (ns_error != NSERROR_OK) goto no_memory; c->base.active++; } node = html; /* depth-first search the tree for link elements */ while (node) { if (node->children) { /* 1. children */ node = node->children; } else if (node->next) { /* 2. siblings */ node = node->next; } else { /* 3. ancestor siblings */ while (node && !node->next) node = node->parent; if (!node) break; node = node->next; } assert(node); if (node->type != XML_ELEMENT_NODE) continue; if (strcmp((const char *) node->name, "link") == 0) { /* rel= */ if ((rel = (char *) xmlGetProp(node, (const xmlChar *) "rel")) == NULL) continue; if (strcasestr(rel, "stylesheet") == 0) { xmlFree(rel); continue; } else if (strcasestr(rel, "alternate")) { /* Ignore alternate stylesheets */ xmlFree(rel); continue; } xmlFree(rel); /* type='text/css' or not present */ if ((type = (char *) xmlGetProp(node, (const xmlChar *) "type")) != NULL) { if (strcmp(type, "text/css") != 0) { xmlFree(type); continue; } xmlFree(type); } /* media contains 'screen' or 'all' or not present */ if ((media = (char *) xmlGetProp(node, (const xmlChar *) "media")) != NULL) { if (strcasestr(media, "screen") == NULL && strcasestr(media, "all") == NULL) { xmlFree(media); continue; } xmlFree(media); } /* href='...' */ if ((href = (char *) xmlGetProp(node, (const xmlChar *) "href")) == NULL) continue; /* TODO: only the first preferred stylesheets (ie. * those with a title attribute) should be loaded * (see HTML4 14.3) */ res = url_join(href, c->base_url, &url); xmlFree(href); if (res != URL_FUNC_OK) continue; LOG(("linked stylesheet %i '%s'", i, url)); res = url_normalize(url, &url2); free(url); if (res != URL_FUNC_OK) { if (res == URL_FUNC_NOMEM) goto no_memory; continue; } /* start fetch */ stylesheets = talloc_realloc(c, c->stylesheets, struct html_stylesheet, i + 1); if (stylesheets == NULL) { free(url2); goto no_memory; } c->stylesheets = stylesheets; c->stylesheet_count++; c->stylesheets[i].type = HTML_STYLESHEET_EXTERNAL; ns_error = hlcache_handle_retrieve(url2, 0, content__get_url(&c->base), NULL, html_convert_css_callback, c, &child, accept, &c->stylesheets[i].data.external); free(url2); if (ns_error != NSERROR_OK) goto no_memory; c->base.active++; i++; } else if (strcmp((const char *) node->name, "style") == 0) { if (!html_process_style_element(c, &i, node)) return false; } } assert(c->stylesheet_count == i); return true; no_memory: msg_data.error = messages_get("NoMemory"); content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); return false; } /** * Process an inline stylesheet in the document. * * \param c content structure * \param index Index of stylesheet in stylesheet_content array, * updated if successful * \param style xml node of style element * \return true on success, false if an error occurred */ bool html_process_style_element(html_content *c, unsigned int *index, xmlNode *style) { xmlNode *child; char *type, *media, *data; union content_msg_data msg_data; struct html_stylesheet *stylesheets; struct content_css_data *sheet; nserror error; /* type='text/css', or not present (invalid but common) */ if ((type = (char *) xmlGetProp(style, (const xmlChar *) "type"))) { if (strcmp(type, "text/css") != 0) { xmlFree(type); return true; } xmlFree(type); } /* media contains 'screen' or 'all' or not present */ if ((media = (char *) xmlGetProp(style, (const xmlChar *) "media"))) { if (strcasestr(media, "screen") == NULL && strcasestr(media, "all") == NULL) { xmlFree(media); return true; } xmlFree(media); } /* Extend array */ stylesheets = talloc_realloc(c, c->stylesheets, struct html_stylesheet, *index + 1); if (stylesheets == NULL) goto no_memory; c->stylesheets = stylesheets; c->stylesheet_count++; c->stylesheets[(*index)].type = HTML_STYLESHEET_INTERNAL; c->stylesheets[(*index)].data.internal = NULL; /* create stylesheet */ sheet = talloc(c, struct content_css_data); if (sheet == NULL) { c->stylesheet_count--; goto no_memory; } error = nscss_create_css_data(sheet, c->base_url, NULL, c->quirks, html_inline_style_done, c); if (error != NSERROR_OK) { c->stylesheet_count--; goto no_memory; } /* can't just use xmlNodeGetContent(style), because that won't * give the content of comments which may be used to 'hide' * the content */ for (child = style->children; child != 0; child = child->next) { data = (char *) xmlNodeGetContent(child); if (nscss_process_css_data(sheet, data, strlen(data)) == false) { xmlFree(data); nscss_destroy_css_data(sheet); talloc_free(sheet); c->stylesheet_count--; /** \todo not necessarily caused by * memory exhaustion */ goto no_memory; } xmlFree(data); } c->base.active++; /* Convert the content -- manually, as we want the result */ if (nscss_convert_css_data(sheet) != CSS_OK) { /* conversion failed */ c->base.active--; nscss_destroy_css_data(sheet); talloc_free(sheet); sheet = NULL; } /* Update index */ c->stylesheets[(*index)].data.internal = sheet; (*index)++; return true; no_memory: msg_data.error = messages_get("NoMemory"); content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); return false; } /** * Handle notification of inline style completion * * \param css Inline style object * \param pw Private data */ void html_inline_style_done(struct content_css_data *css, void *pw) { html_content *html = pw; if (--html->base.active == 0) html_finish_conversion(html); } /** * Callback for fetchcache() for linked stylesheets. */ 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->type == HTML_STYLESHEET_EXTERNAL && s->data.external == css) break; } assert(i != parent->stylesheet_count); switch (event->type) { case CONTENT_MSG_LOADING: break; case CONTENT_MSG_READY: break; case CONTENT_MSG_DONE: LOG(("got stylesheet '%s'", content_get_url(css))); parent->base.active--; break; case CONTENT_MSG_ERROR: LOG(("stylesheet %s failed: %s", content_get_url(css), event->data.error)); hlcache_handle_release(css); s->data.external = NULL; parent->base.active--; content_add_error(&parent->base, "?", 0); break; case CONTENT_MSG_STATUS: html_set_status(parent, content_get_status_message(css)); content_broadcast(&parent->base, CONTENT_MSG_STATUS, event->data); break; default: assert(0); } if (parent->base.active == 0) html_finish_conversion(parent); return NSERROR_OK; } /** * Start a fetch for an object required by a page. * * \param c content of type CONTENT_HTML * \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, const char *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; char *url2; url_func_result res; 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; /* Normalize the URL */ res = url_normalize(url, &url2); if (res != URL_FUNC_OK) { LOG(("failed to normalize url '%s'", url)); return res != URL_FUNC_NOMEM; } object = talloc(c, struct content_html_object); if (object == NULL) { free(url2); 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(url2, HLCACHE_RETRIEVE_SNIFF_TYPE, content__get_url(&c->base), NULL, html_object_callback, object, &child, permitted_types, &object->content); /* No longer need normalized url */ free(url2); if (error != NSERROR_OK) { talloc_free(object); return error != NSERROR_NOMEM; } /* add to object list */ object->next = c->object_list; c->object_list = object; c->num_objects++; c->base.active++; return error != NSERROR_NOMEM; } /** * 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 */ bool html_replace_object(struct content_html_object *object, const char *url) { html_content *c; hlcache_child_context child; html_content *page; char *url2; url_func_result res; nserror error; assert(object != 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--; hlcache_handle_release(object->content); object->content = NULL; object->box->object = NULL; } res = url_normalize(url, &url2); if (res != URL_FUNC_OK) return res != URL_FUNC_NOMEM; /* initialise fetch */ error = hlcache_handle_retrieve(url2, HLCACHE_RETRIEVE_SNIFF_TYPE, content__get_url(&c->base), NULL, html_object_callback, object, &child, object->permitted_types, &object->content); free(url2); if (error != NSERROR_OK) return false; for (page = c; page != NULL; page = page->page) { page->base.active++; page->base.status = CONTENT_STATUS_READY; } return true; } /** * Callback for hlcache_handle_retrieve() for objects. */ 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; assert(c->base.status == CONTENT_STATUS_READY || c->base.status == CONTENT_STATUS_DONE); box = o->box; switch (event->type) { case CONTENT_MSG_LOADING: if (c->bw != NULL) content_open(object, c->bw, &c->base, box, box->object_params); break; case CONTENT_MSG_READY: if (content_get_type(object) == CONTENT_HTML) { 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.height); } break; case CONTENT_MSG_DONE: c->base.active--; html_object_done(box, object, o->background); if (box->flags & REPLACE_DIM) { union content_msg_data data; 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; data.redraw.full_redraw = true; content_broadcast(&c->base, CONTENT_MSG_REDRAW, data); } break; case CONTENT_MSG_ERROR: hlcache_handle_release(object); o->content = NULL; c->base.active--; content_add_error(&c->base, "?", 0); html_set_status(c, event->data.error); content_broadcast(&c->base, CONTENT_MSG_STATUS, event->data); html_object_failed(box, c, o->background); break; case CONTENT_MSG_STATUS: html_set_status(c, content_get_status_message(object)); /* content_broadcast(&c->base, CONTENT_MSG_STATUS, 0); */ break; case CONTENT_MSG_REFORMAT: break; case CONTENT_MSG_REDRAW: { union content_msg_data data = event->data; if (!box_visible(box)) break; box_coords(box, &x, &y); if (hlcache_handle_get_content(object) == event->data.redraw.object) { data.redraw.x = data.redraw.x * box->width / content_get_width(object); data.redraw.y = data.redraw.y * box->height / content_get_height(object); data.redraw.width = data.redraw.width * box->width / content_get_width(object); data.redraw.height = data.redraw.height * box->height / content_get_height(object); data.redraw.object_width = box->width; data.redraw.object_height = box->height; } data.redraw.x += x + box->padding[LEFT]; data.redraw.y += y + box->padding[TOP]; data.redraw.object_x += x + box->padding[LEFT]; data.redraw.object_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 */ schedule(event->data.delay * 100, html_object_refresh, o); } break; default: assert(0); } 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.height); html_set_status(c, ""); content_set_done(&c->base); } /* If 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, * 5) the time since the previous reformat is more than the * configured minimum time between reformats * then reformat the page to display newly fetched objects */ else if (option_incremental_reflow && event->type == CONTENT_MSG_DONE && !(box->flags & REPLACE_DIM) && (c->base.status == CONTENT_STATUS_READY || c->base.status == CONTENT_STATUS_DONE) && (wallclock() > c->base.reformat_time)) { content__reformat(&c->base, false, c->base.available_width, c->base.height); } return NSERROR_OK; } /** * Update a box whose content has completed rendering. */ void html_object_done(struct box *box, hlcache_handle *object, bool background) { struct box *b; if (background) { box->background = object; return; } box->object = object; 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; } } } /** * 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 */ void html_object_failed(struct box *box, html_content *content, bool background) { /* Nothing to do */ return; } /** * schedule() callback for object refresh */ void html_object_refresh(void *p) { struct content_html_object *object = p; const char *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 */ } } /** * Stop loading a CONTENT_HTML. */ void html_stop(struct content *c) { html_content *htmlc = (html_content *) c; struct content_html_object *object; switch (c->status) { case CONTENT_STATUS_LOADING: /* Clean up objects if we were stopped after queuing up some * fetches within xml_to_box (i.e. gui_multitask is somewhere * in our call stack) */ for (object = htmlc->object_list; object != NULL; object = object->next) { if (object->content == NULL) continue; /* If there's a content already associated with our * handle, something's gone very wrong */ assert(content_get_status(object->content) == CONTENT_STATUS_ERROR); hlcache_handle_abort(object->content); hlcache_handle_release(object->content); object->content = NULL; c->active--; } /* Still loading; simply flag that we've been aborted * html_convert/html_finish_conversion will do the rest */ htmlc->aborted = true; break; case CONTENT_STATUS_READY: for (object = htmlc->object_list; object != NULL; object = object->next) { if (object->content == NULL) continue; if (content_get_status(object->content) == CONTENT_STATUS_DONE) ; /* already loaded: do nothing */ else if (content_get_status(object->content) == CONTENT_STATUS_READY) hlcache_handle_abort(object->content); /* Active count will be updated when * html_object_callback receives * CONTENT_MSG_DONE from this object */ else { hlcache_handle_abort(object->content); hlcache_handle_release(object->content); object->content = NULL; c->active--; } } /* If there are no further active fetches and we're still * in the READY state, transition to the DONE state. */ if (c->status == CONTENT_STATUS_READY && c->active == 0) { html_set_status(htmlc, ""); content_set_done(c); } break; case CONTENT_STATUS_DONE: /* Nothing to do */ break; default: LOG(("Unexpected status %d", c->status)); assert(0); } } /** * Reformat a CONTENT_HTML to a new width. */ void html_reformat(struct content *c, int width, int height) { html_content *htmlc = (html_content *) c; struct box *layout; unsigned int time_before, time_taken; time_before = wallclock(); layout_document(htmlc, width, height); layout = htmlc->layout; /* width and height are at least margin box of document */ c->width = layout->x + layout->padding[LEFT] + layout->width + layout->padding[RIGHT] + layout->border[RIGHT].width + layout->margin[RIGHT]; c->height = layout->y + layout->padding[TOP] + layout->height + layout->padding[BOTTOM] + layout->border[BOTTOM].width + layout->margin[BOTTOM]; /* if boxes overflow right or bottom edge, expand to contain it */ if (c->width < layout->x + layout->descendant_x1) c->width = layout->x + layout->descendant_x1; if (c->height < layout->y + layout->descendant_y1) c->height = layout->y + layout->descendant_y1; selection_reinit(&htmlc->sel, htmlc->layout); time_taken = wallclock() - time_before; c->reformat_time = wallclock() + ((time_taken * 3 < option_min_reflow_period ? option_min_reflow_period : time_taken * 3)); } /** * Redraw a box. * * \param h content containing the box, of type CONTENT_HTML * \param box box to redraw */ void html_redraw_a_box(hlcache_handle *h, struct box *box) { int x, y; box_coords(box, &x, &y); content_request_redraw(h, x, y, box->padding[LEFT] + box->width + box->padding[RIGHT], box->padding[TOP] + box->height + box->padding[BOTTOM]); } /** * Redraw a box. * * \param h content containing the box, of type CONTENT_HTML * \param box box to redraw */ void html__redraw_a_box(struct content *c, struct box *box) { int x, y; box_coords(box, &x, &y); content__request_redraw(c, x, y, box->padding[LEFT] + box->width + box->padding[RIGHT], box->padding[TOP] + box->height + box->padding[BOTTOM]); } /** * Destroy a CONTENT_HTML and free all resources it owns. */ void html_destroy(struct content *c) { html_content *html = (html_content *) c; unsigned int i; struct form *f, *g; LOG(("content %p", c)); /* Destroy forms */ for (f = html->forms; f != NULL; f = g) { g = f->prev; form_free(f); } imagemap_destroy(html); if (html->parser_binding != NULL) binding_destroy_tree(html->parser_binding); if (html->document != NULL) xmlFreeDoc(html->document); /* Free base target */ if (html->base_target != NULL) { talloc_free(html->base_target); html->base_target = NULL; } /* Free frameset */ if (html->frameset != NULL) { html_destroy_frameset(html->frameset); talloc_free(html->frameset); html->frameset = NULL; } /* Free iframes */ if (html->iframe != NULL) { html_destroy_iframe(html->iframe); html->iframe = NULL; } /* Destroy selection context */ if (html->select_ctx != NULL) { css_select_ctx_destroy(html->select_ctx); html->select_ctx = NULL; } /* Free stylesheets */ for (i = 0; i != html->stylesheet_count; i++) { if (html->stylesheets[i].type == HTML_STYLESHEET_EXTERNAL && html->stylesheets[i].data.external != NULL) { hlcache_handle_release( html->stylesheets[i].data.external); } else if (html->stylesheets[i].type == HTML_STYLESHEET_INTERNAL && html->stylesheets[i].data.internal != NULL) { nscss_destroy_css_data( html->stylesheets[i].data.internal); } } /* Free objects */ html_destroy_objects(html); } void html_destroy_objects(html_content *html) { while (html->object_list != NULL) { struct content_html_object *victim = html->object_list; if (victim->content != NULL) { LOG(("object %p", victim->content)); if (content_get_type(victim->content) == CONTENT_HTML) schedule_remove(html_object_refresh, victim); hlcache_handle_release(victim->content); } html->object_list = victim->next; talloc_free(victim); } } void html_destroy_frameset(struct content_html_frames *frameset) { int i; if (frameset->name) { talloc_free(frameset->name); frameset->name = NULL; } if (frameset->url) { talloc_free(frameset->url); frameset->url = NULL; } if (frameset->children) { for (i = 0; i < (frameset->rows * frameset->cols); i++) { if (frameset->children[i].name) { talloc_free(frameset->children[i].name); frameset->children[i].name = NULL; } if (frameset->children[i].url) { talloc_free(frameset->children[i].url); frameset->children[i].url = NULL; } if (frameset->children[i].children) html_destroy_frameset(&frameset->children[i]); } talloc_free(frameset->children); frameset->children = NULL; } } void html_destroy_iframe(struct content_html_iframe *iframe) { struct content_html_iframe *next; next = iframe; while ((iframe = next) != NULL) { next = iframe->next; if (iframe->name) talloc_free(iframe->name); if (iframe->url) talloc_free(iframe->url); talloc_free(iframe); } } nserror html_clone(const struct content *old, struct content **newc) { /** \todo Clone HTML specifics */ /* In the meantime, we should never be called, as HTML contents * cannot be shared and we're not intending to fix printing's * cloning of documents. */ assert(0 && "html_clone should never be called"); return true; } /** * Set the content status. */ void html_set_status(html_content *c, const char *extra) { content_set_status(&c->base, "%s", extra); } /** * Handle a window containing a CONTENT_HTML being opened. */ void html_open(struct content *c, struct browser_window *bw, struct content *page, struct box *box, struct object_params *params) { html_content *html = (html_content *) c; struct content_html_object *object, *next; html->bw = bw; html->page = (html_content *) page; html->box = box; /* text selection */ selection_init(&html->sel, html->layout); for (object = html->object_list; object != NULL; object = next) { next = object->next; if (object->content == NULL) continue; if (content_get_type(object->content) == CONTENT_NONE) continue; content_open(object->content, bw, c, object->box, object->box->object_params); } } /** * Handle a window containing a CONTENT_HTML being closed. */ void html_close(struct content *c) { html_content *html = (html_content *) c; struct content_html_object *object, *next; if (html->search != NULL) search_destroy_context(html->search); html->bw = NULL; for (object = html->object_list; object != NULL; object = next) { next = object->next; if (object->content == NULL) continue; if (content_get_type(object->content) == CONTENT_NONE) continue; if (content_get_type(object->content) == CONTENT_HTML) schedule_remove(html_object_refresh, object); content_close(object->content); } } /** * Return an HTML content's selection context */ struct selection *html_get_selection(struct content *c) { html_content *html = (html_content *) c; return &html->sel; } /** * Set an HTML content's search context * * \param c content of type html * \param s search context, or NULL if none */ void html_set_search(struct content *c, struct search_context *s) { html_content *html = (html_content *) c; html->search = s; } /** * Return an HTML content's search context * * \param c content of type html * \return content's search context, or NULL if none */ struct search_context *html_get_search(struct content *c) { html_content *html = (html_content *) c; return html->search; } #if ALWAYS_DUMP_FRAMESET /** * Print a frameset tree to stderr. */ void html_dump_frameset(struct content_html_frames *frame, unsigned int depth) { unsigned int i; int row, col, index; const char *unit[] = {"px", "%", "*"}; const char *scrolling[] = {"auto", "yes", "no"}; assert(frame); fprintf(stderr, "%p ", frame); fprintf(stderr, "(%i %i) ", frame->rows, frame->cols); fprintf(stderr, "w%g%s ", frame->width.value, unit[frame->width.unit]); fprintf(stderr, "h%g%s ", frame->height.value,unit[frame->height.unit]); fprintf(stderr, "(margin w%i h%i) ", frame->margin_width, frame->margin_height); if (frame->name) fprintf(stderr, "'%s' ", frame->name); if (frame->url) fprintf(stderr, "<%s> ", frame->url); if (frame->no_resize) fprintf(stderr, "noresize "); fprintf(stderr, "(scrolling %s) ", scrolling[frame->scrolling]); if (frame->border) fprintf(stderr, "border %x ", (unsigned int) frame->border_colour); fprintf(stderr, "\n"); if (frame->children) { for (row = 0; row != frame->rows; row++) { for (col = 0; col != frame->cols; col++) { for (i = 0; i != depth; i++) fprintf(stderr, " "); fprintf(stderr, "(%i %i): ", row, col); index = (row * frame->cols) + col; html_dump_frameset(&frame->children[index], depth + 1); } } } } #endif /** * Retrieve HTML document tree * * \param h HTML content to retrieve document tree from * \return Pointer to document tree */ xmlDoc *html_get_document(hlcache_handle *h) { html_content *c = (html_content *) hlcache_handle_get_content(h); assert(c != NULL); return c->document; } /** * Retrieve box tree * * \param h HTML content to retrieve tree from * \return Pointer to box tree * * \todo This API must die, as must all use of the box tree outside render/ */ struct box *html_get_box_tree(hlcache_handle *h) { html_content *c = (html_content *) hlcache_handle_get_content(h); assert(c != NULL); return c->layout; } /** * Retrieve the charset of an HTML document * * \param h Content to retrieve charset from * \return Pointer to charset, or NULL */ const char *html_get_encoding(hlcache_handle *h) { html_content *c = (html_content *) hlcache_handle_get_content(h); assert(c != NULL); return c->encoding; } /** * Retrieve the charset of an HTML document * * \param h Content to retrieve charset from * \return Pointer to charset, or NULL */ binding_encoding_source html_get_encoding_source(hlcache_handle *h) { html_content *c = (html_content *) hlcache_handle_get_content(h); assert(c != NULL); return c->encoding_source; } /** * Retrieve framesets used in an HTML document * * \param h Content to inspect * \return Pointer to framesets, or NULL if none */ struct content_html_frames *html_get_frameset(hlcache_handle *h) { html_content *c = (html_content *) hlcache_handle_get_content(h); assert(c != NULL); return c->frameset; } /** * Retrieve iframes used in an HTML document * * \param h Content to inspect * \return Pointer to iframes, or NULL if none */ struct content_html_iframe *html_get_iframe(hlcache_handle *h) { html_content *c = (html_content *) hlcache_handle_get_content(h); assert(c != NULL); return c->iframe; } /** * Retrieve an HTML content's base URL * * \param h Content to retrieve base target from * \return Pointer to URL */ const char *html_get_base_url(hlcache_handle *h) { html_content *c = (html_content *) hlcache_handle_get_content(h); assert(c != NULL); return c->base_url; } /** * Retrieve an HTML content's base target * * \param h Content to retrieve base target from * \return Pointer to target, or NULL if none */ const char *html_get_base_target(hlcache_handle *h) { html_content *c = (html_content *) hlcache_handle_get_content(h); assert(c != NULL); return c->base_target; } /** * Retrieve stylesheets used by HTML document * * \param h Content to retrieve stylesheets from * \param n Pointer to location to receive number of sheets * \return Pointer to array of stylesheets */ 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; } /** * 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; } /** * Retrieve favicon associated with an HTML document * * \param h HTML document to retrieve favicon from * \return Pointer to favicon, or NULL if none */ hlcache_handle *html_get_favicon(hlcache_handle *h) { html_content *c = (html_content *) hlcache_handle_get_content(h); assert(c != NULL); return NULL; } /** * Retrieve layout coordinates of box with given id * * \param h HTML document to search * \param frag_id String containing an element id * \param x Updated to global x coord iff id found * \param y Updated to global y coord iff id found * \return true iff id found */ bool html_get_id_offset(hlcache_handle *h, const char *frag_id, int *x, int *y) { struct box *pos; struct box *layout; if (content_get_type(h) != CONTENT_HTML) return false; layout = html_get_box_tree(h); if ((pos = box_find_by_id(layout, frag_id)) != 0) { box_coords(pos, x, y); return true; } return false; } /** * Compute the type of a content * * \return CONTENT_HTML */ content_type html_content_type(void) { return CONTENT_HTML; } /** * Get the browser window containing an HTML content * * \param c HTML content * \return the browser window */ struct browser_window *html_get_browser_window(struct content *c) { html_content *html = (html_content *) c; assert(c != NULL); assert(c->handler == &html_content_handler); return html->bw; }