diff options
Diffstat (limited to 'css/css.c')
| -rw-r--r-- | css/css.c | 410 |
1 files changed, 410 insertions, 0 deletions
diff --git a/css/css.c b/css/css.c new file mode 100644 index 000000000..205fd8a83 --- /dev/null +++ b/css/css.c @@ -0,0 +1,410 @@ +/** + * $Id: css.c,v 1.1 2003/04/04 15:19:31 bursa Exp $ + */ + +#include <assert.h> +#include <stdlib.h> +#include <string.h> +#include <strings.h> +#define CSS_INTERNALS +#include "netsurf/content/content.h" +#include "netsurf/css/css.h" +#include "netsurf/utils/log.h" +#include "netsurf/utils/utils.h" + +/** + * internal structures + */ + +struct decl { + unsigned long score; + struct rule * rule; +}; + +void css_dump_style(const struct css_style * const style); + + + +const struct css_style css_base_style = { + 0xffffff, + CSS_CLEAR_NONE, + 0x000000, + CSS_DISPLAY_BLOCK, + CSS_FLOAT_NONE, + { CSS_FONT_SIZE_LENGTH, { { 12, CSS_UNIT_PT } } }, + CSS_FONT_WEIGHT_NORMAL, + CSS_FONT_STYLE_NORMAL, + { CSS_HEIGHT_AUTO, { 1, CSS_UNIT_EM } }, + { CSS_LINE_HEIGHT_ABSOLUTE, { 1.2 } }, + CSS_TEXT_ALIGN_LEFT, + { CSS_WIDTH_AUTO, { { 1, CSS_UNIT_EM } } } +}; + +const struct css_style css_empty_style = { + CSS_COLOR_INHERIT, + CSS_CLEAR_INHERIT, + CSS_COLOR_INHERIT, + CSS_DISPLAY_INHERIT, + CSS_FLOAT_INHERIT, + { CSS_FONT_SIZE_INHERIT, { { 1, CSS_UNIT_EM } } }, + CSS_FONT_WEIGHT_INHERIT, + CSS_FONT_STYLE_INHERIT, + { CSS_HEIGHT_AUTO, { 1, CSS_UNIT_EM } }, + { CSS_LINE_HEIGHT_INHERIT, { 1.2 } }, + CSS_TEXT_ALIGN_INHERIT, + { CSS_WIDTH_INHERIT, { { 1, CSS_UNIT_EM } } } +}; + +const struct css_style css_blank_style = { + TRANSPARENT, + CSS_CLEAR_NONE, + CSS_COLOR_INHERIT, + CSS_DISPLAY_INLINE, + CSS_FLOAT_NONE, + { CSS_FONT_SIZE_INHERIT, { { 1, CSS_UNIT_EM } } }, + CSS_FONT_WEIGHT_INHERIT, + CSS_FONT_STYLE_INHERIT, + { CSS_HEIGHT_AUTO, { 1, CSS_UNIT_EM } }, + { CSS_LINE_HEIGHT_INHERIT, { 1.2 } }, + CSS_TEXT_ALIGN_INHERIT, + { CSS_WIDTH_AUTO, { { 1, CSS_UNIT_EM } } } +}; + + + +void css_create(struct content *c) +{ + LOG(("content %p", c)); + c->data.css = xcalloc(1, sizeof(*c->data.css)); + css_lex_init(&c->data.css->lexer); + c->data.css->parser = css_parser_Alloc(malloc); + c->data.css->rule = 0; + c->data.css->last_rule = 0; +} + + +void css_process_data(struct content *c, char *data, unsigned long size) +{ + int token; + YY_BUFFER_STATE buffer; + + LOG(("content %p, size %lu", c, size)); + + buffer = css__scan_bytes(data, size, c->data.css->lexer); + while ((token = css_lex(c->data.css->lexer))) { + css_parser_(c->data.css->parser, token, + strdup(css_get_text(c->data.css->lexer)), + c->data.css); + } + css__delete_buffer(buffer, c->data.css->lexer); +} + + +int css_convert(struct content *c, unsigned int width, unsigned int height) +{ + LOG(("content %p", c)); + + css_parser_(c->data.css->parser, 0, 0, c->data.css); + + css_parser_Free(c->data.css->parser, free); + css_lex_destroy(c->data.css->lexer); + + return 0; +} + + +void css_revive(struct content *c, unsigned int width, unsigned int height) +{ +} + + +void css_reformat(struct content *c, unsigned int width, unsigned int height) +{ +} + + +void css_destroy(struct content *c) +{ + xfree(c->data.css); +} + + +/** + * parser support functions + */ + +struct node * css_new_node(node_type type, char *data, + struct node *left, struct node *right) +{ + struct node *node = xcalloc(1, sizeof(*node)); + node->type = type; + node->data = data; + node->left = left; + node->right = right; + node->next = 0; + node->comb = COMB_NONE; + node->style = 0; + return node; +} + +void css_free_node(struct node *node) +{ + if (node == 0) + return; + if (node->left != 0) + css_free_node(node->left); + if (node->right != 0) + css_free_node(node->right); + if (node->next != 0) + css_free_node(node->next); + if (node->data != 0) + free(node->data); + free(node); +} + + + +void css_get_style(struct css_stylesheet * stylesheet, struct css_selector * selector, + unsigned int selectors, struct css_style * style) +{ + struct node *r, *n, *m; + unsigned int i; + + LOG(("stylesheet %p, selectors %u", stylesheet, selectors)); + + for (r = stylesheet->rule; r != 0; r = r->next) { + i = selectors - 1; + n = r; + /* compare element */ + if (strcasecmp(selector[i].element, n->data) != 0) + goto not_matched; + LOG(("top element '%s' matched", selector[i].element)); + while (1) { + /* class and id */ + for (m = n->left; m != 0; m = m->next) { + if (m->type == NODE_ID) { + /* TODO: check if case sensitive */ + if (strcmp(selector[i].id, m->data) != 0) + goto not_matched; + } else if (m->type == NODE_CLASS) { + /* TODO: check if case sensitive */ + if (strcmp(selector[i].class, m->data) != 0) + goto not_matched; + } else { + goto not_matched; + } + } + LOG(("class and id matched")); + /* ancestors etc. */ + if (n->comb == COMB_NONE) + goto matched; /* match successful */ + else if (n->comb == COMB_ANCESTOR) { + /* search for ancestor */ + assert(n->right != 0); + n = n->right; + LOG(("searching for ancestor '%s'", n->data)); + while (i != 0 && strcasecmp(selector[i - 1].element, n->data) != 0) + i--; + if (i == 0) + goto not_matched; + i--; + LOG(("found")); + } else { + /* TODO: COMB_PRECEDED, COMB_PARENT */ + goto not_matched; + } + } + +matched: + /* TODO: sort by specificity */ + LOG(("matched rule %p", r)); + css_dump_style(r->style); + css_cascade(style, r->style); + +not_matched: + + } + + css_dump_style(style); +} + + +void css_parse_property_list(struct css_style * style, char * str) +{ +} + + + +/** + * dump a style + */ + +static void dump_length(const struct css_length * const length) +{ + LOG(("%g%s", length->value, + css_unit_name[length->unit])); +} + +#define DUMP_LENGTH(pre, len, post) LOG((pre "%g%s" post, (len)->value, css_unit_name[(len)->unit])); + +void css_dump_style(const struct css_style * const style) +{ + LOG(("{ ")); + LOG(("background-color: #%lx;", style->background_color)); + LOG(("clear: %s;", css_clear_name[style->clear])); + LOG(("color: #%lx;", style->color)); + LOG(("display: %s;", css_display_name[style->display])); + LOG(("float: %s;", css_float_name[style->float_])); + switch (style->font_size.size) { + case CSS_FONT_SIZE_ABSOLUTE: + LOG(("font-size: [%g];", style->font_size.value.absolute)); break; + case CSS_FONT_SIZE_LENGTH: + DUMP_LENGTH("font-size: ", &style->font_size.value.length, ";"); break; + case CSS_FONT_SIZE_PERCENT: + LOG(("font-size: %g%%;", style->font_size.value.percent)); break; + case CSS_FONT_SIZE_INHERIT: LOG(("font-size: inherit;")); break; + default: LOG(("font-size: UNKNOWN;")); break; + } + switch (style->height.height) { + case CSS_HEIGHT_AUTO: LOG(("height: auto;")); break; + case CSS_HEIGHT_LENGTH: DUMP_LENGTH("height: ", &style->height.length, ";"); break; + default: LOG(("height: UNKNOWN;")); break; + } + switch (style->line_height.size) { + case CSS_LINE_HEIGHT_ABSOLUTE: + LOG(("line-height: [%g];", style->line_height.value.absolute)); break; + case CSS_LINE_HEIGHT_LENGTH: + DUMP_LENGTH("line-height: ", &style->line_height.value.length, ";"); break; + case CSS_LINE_HEIGHT_PERCENT: + LOG(("line-height: %g%%;", style->line_height.value.percent)); break; + case CSS_LINE_HEIGHT_INHERIT: LOG(("line-height: inherit;")); break; + default: LOG(("line-height: UNKNOWN;")); break; + } + LOG(("text-align: %s;", css_text_align_name[style->text_align])); + switch (style->width.width) { + case CSS_WIDTH_AUTO: LOG(("width: auto;")); break; + case CSS_WIDTH_LENGTH: + DUMP_LENGTH("width: ", &style->width.value.length, ";"); break; + case CSS_WIDTH_PERCENT: LOG(("width: %g%%;", style->width.value.percent)); break; + default: LOG(("width: UNKNOWN;")); break; + } + LOG(("}")); +} +#if 0 +static void dump_selector(const struct css_selector * const sel) +{ + if (sel->class != 0) + LOG(("'%s'.'%s' ", sel->element, sel->class); + else if (sel->id != 0) + LOG(("'%s'#'%s' ", sel->element, sel->id); + else + LOG(("'%s' ", sel->element); +} + +static void dump_rule(const struct rule * rule) +{ + unsigned int i; + for (i = 0; i < rule->selectors; i++) + dump_selector(&rule->selector[i]); + css_dump_style(rule->style); +} + +void css_dump_stylesheet(const struct css_stylesheet * stylesheet) +{ + unsigned int i; + for (i = 0; i < HASH_SIZE; i++) { + struct rule * rule; + LOG(("hash %i:\n", i); + for (rule = stylesheet->hash[i]; rule != 0; rule = rule->next) + dump_rule(rule); + } +} +#endif +/** + * cascade styles + */ + +void css_cascade(struct css_style * const style, const struct css_style * const apply) +{ + float f; + + if (apply->background_color != CSS_COLOR_INHERIT) + style->background_color = apply->background_color; + if (apply->clear != CSS_CLEAR_INHERIT) + style->clear = apply->clear; + if (apply->color != CSS_COLOR_INHERIT) + style->color = apply->color; + if (apply->display != CSS_DISPLAY_INHERIT) + style->display = apply->display; + if (apply->float_ != CSS_FLOAT_INHERIT) + style->float_ = apply->float_; + if (apply->height.height != CSS_HEIGHT_INHERIT) + style->height = apply->height; + if (apply->text_align != CSS_TEXT_ALIGN_INHERIT) + style->text_align = apply->text_align; + if (apply->width.width != CSS_WIDTH_INHERIT) + style->width = apply->width; + if (apply->font_weight != CSS_FONT_WEIGHT_INHERIT) + style->font_weight = apply->font_weight; + if (apply->font_style != CSS_FONT_STYLE_INHERIT) + style->font_style = apply->font_style; + + /* font-size */ + f = apply->font_size.value.percent / 100; + switch (apply->font_size.size) { + case CSS_FONT_SIZE_ABSOLUTE: + style->font_size = apply->font_size; + break; + case CSS_FONT_SIZE_LENGTH: + switch (apply->font_size.value.length.unit) { + case CSS_UNIT_EM: + f = apply->font_size.value.length.value; + break; + case CSS_UNIT_EX: + f = apply->font_size.value.length.value * 0.6 /*?*/; + break; + default: + style->font_size = apply->font_size; + } + if ((apply->font_size.value.length.unit != CSS_UNIT_EM) && + (apply->font_size.value.length.unit != CSS_UNIT_EX)) + break; + /* drop through if EM or EX */ + case CSS_FONT_SIZE_PERCENT: + switch (style->font_size.size) { + case CSS_FONT_SIZE_ABSOLUTE: + style->font_size.value.absolute *= f; + break; + case CSS_FONT_SIZE_LENGTH: + style->font_size.value.length.value *= f; + break; + default: + die("attempting percentage of unknown font-size"); + } + break; + case CSS_FONT_SIZE_INHERIT: + default: /* leave unchanged */ + break; + } +} + + +#ifdef DEBUG + +int main() +{ + const char data[] = "h1 { blah: foo; display: block; }" + "h1.c1 h2#id1 + h3, h4 h5.c2#id2 { size: 100mm; color: red }" + "p { background-color: #123; clear: left; color: #ff0000; display: block;" + "float: left; font-size: 150%; height: blah; line-height: 100;" + "text-align: left right; width: 90%;}"; + struct content c; + css_create(&c); + css_process_data(&c, data, 24); + css_process_data(&c, data + 24, sizeof(data) - 25); + css_convert(&c, 100, 100); + return 0; +} + +#endif + |