mirrors/netsurf
1
0
Fork 0
mirror of https://github.com/netsurf-browser/netsurf synced 2025-01-15 23:29:21 +03:00
Code Issues Packages Projects Releases Wiki Activity

[project @ 2004-06-25 14:28:29 by bursa]

Browse Source 
Parse CSS background shorthand property. Background rendering improvements.

svn path=/import/netsurf/; revision=1006
This commit is contained in:
James Bursa 2004-06-25 14:28:29 +00:00
parent bca6a63c45
commit aa6e904604
4 changed files with 319 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
css/css.c
View File

@ -1005,10 +1005,10 @@ void css_dump_style(const struct css_style * const style)
break;
}
fprintf(stderr, " %s %s ",
css_background_attachment_name[
style->background_attachment],
css_background_repeat_name[
style->background_repeat]);
style->background_repeat],
css_background_attachment_name[
style->background_attachment]);
switch (style->background_position.horz.pos) {
case CSS_BACKGROUND_POSITION_LENGTH:
css_dump_length(&style->background_position.
@ -1038,6 +1038,7 @@ void css_dump_style(const struct css_style * const style)
vert.value.percent);
break;
case CSS_BACKGROUND_POSITION_INHERIT:
fprintf(stderr, "inherit");
break;
default:
fprintf(stderr, "UNKNOWN");

74
css/css.h
View File

@ -54,42 +54,42 @@ typedef enum {
} css_text_decoration;
typedef enum {
CSS_BACKGROUND_POSITION_LENGTH,
CSS_BACKGROUND_POSITION_PERCENT,
CSS_BACKGROUND_POSITION_INHERIT
} css_background_position;
CSS_BACKGROUND_IMAGE_NONE,
CSS_BACKGROUND_IMAGE_INHERIT,
CSS_BACKGROUND_IMAGE_URI
} css_background_image_type;
/** Part of struct css_style, for convenience. */
struct css_background_position {
enum {
CSS_BACKGROUND_POSITION_LENGTH,
CSS_BACKGROUND_POSITION_PERCENT,
CSS_BACKGROUND_POSITION_INHERIT
} pos;
union {
float percent;
struct css_length length;
} value;
};
/** Representation of a complete CSS 2 style. */
struct css_style {
colour background_color;
css_background_attachment background_attachment;
css_background_attachment background_attachment;
struct {
enum { CSS_BACKGROUND_IMAGE_NONE,
CSS_BACKGROUND_IMAGE_INHERIT,
CSS_BACKGROUND_IMAGE_URI } type;
char *uri;
css_background_image_type type;
char *uri;
} background_image;
struct {
struct {
css_background_position pos;
union {
float percent;
struct css_length length;
} value;
} horz;
struct {
css_background_position pos;
union {
float percent;
struct css_length length;
} value;
} vert;
} background_position;
struct {
struct css_background_position horz;
struct css_background_position vert;
} background_position;
css_background_repeat background_repeat;
css_background_repeat background_repeat;
struct {
colour color;
@ -119,7 +119,7 @@ struct css_style {
} value;
} font_size;
css_font_family font_family;
css_font_family font_family;
css_font_weight font_weight;
css_font_style font_style;
css_font_variant font_variant;
@ -167,14 +167,14 @@ struct css_style {
css_text_align text_align;
css_text_decoration text_decoration;
struct {
enum { CSS_TEXT_INDENT_INHERIT,
CSS_TEXT_INDENT_LENGTH,
CSS_TEXT_INDENT_PERCENT } size;
union {
struct css_length length;
float percent;
} value ;
} text_indent;
enum { CSS_TEXT_INDENT_INHERIT,
CSS_TEXT_INDENT_LENGTH,
CSS_TEXT_INDENT_PERCENT } size;
union {
struct css_length length;
float percent;
} value ;
} text_indent;
css_text_transform text_transform;
css_visibility visibility;
@ -317,7 +317,7 @@ void css_destroy(struct content *c);
#ifdef CSS_INTERNALS
struct css_node * css_new_node(struct content *stylesheet,
css_node_type type,
css_node_type type,
const char *data, unsigned int data_length);
void css_free_node(struct css_node *node);
struct css_selector * css_new_selector(css_selector_type type,
@ -349,7 +349,7 @@ void css_cascade(struct css_style * const style,
void css_merge(struct css_style * const style,
const struct css_style * const apply);
void css_parse_property_list(struct content *c, struct css_style * style,
char * str);
char * str);
colour named_colour(const char *name);
void css_dump_style(const struct css_style * const style);
void css_dump_stylesheet(const struct css_stylesheet * stylesheet);

357
css/ruleset.c
View File

@ -11,6 +11,10 @@
* This file implements the last stage of CSS parsing. It converts trees of
* struct css_node produced by the parser into struct style, and adds them to a
* stylesheet.
*
* This code is complicated by the CSS error handling rules. According to
* CSS 2.1 4.2 "Illegal values", the whole of a declaration must be legal for
* any of it to be used.
*/
#include <assert.h>
@ -34,13 +38,21 @@ static int parse_length(struct css_length * const length,
const struct css_node * const v, bool non_negative);
static colour parse_colour(const struct css_node * const v);
static colour css_parse_rgb(struct css_node *v);
static void parse_background(struct css_style * const s, const struct css_node * v);
static void parse_background(struct css_style * const s,
const struct css_node * v);
static void parse_background_attachment(struct css_style * const s, const struct css_node * const v);
static void parse_background_color(struct css_style * const s, const struct css_node * const v);
static void parse_background_image(struct css_style * const s, const struct css_node * const v);
static void parse_background_image(struct css_style * const s,
const struct css_node * const v);
static bool css_background_image_parse(const struct css_node *v,
css_background_image_type *type, char **uri);
static struct css_background_entry *css_background_lookup(
const struct css_node *v);
static void parse_background_position(struct css_style * const s, const struct css_node * const v);
static void parse_background_position(struct css_style * const s,
const struct css_node * const v);
static bool css_background_position_parse(const struct css_node **node,
struct css_background_position *horz,
struct css_background_position *vert);
static void parse_background_repeat(struct css_style * const s, const struct css_node * const v);
static void parse_border(struct css_style * const s, const struct css_node * v);
static void parse_border_bottom(struct css_style * const s, const struct css_node * v);
@ -522,52 +534,113 @@ colour css_parse_rgb(struct css_node *v)
}
void parse_background(struct css_style * const s, const struct css_node * v)
/**
* \name Individual property parsers.
* \{
*/
void parse_background(struct css_style * const s,
const struct css_node * v)
{
colour c;
css_background_attachment ba;
css_background_repeat br;
for (; v; v = v->next) {
colour c = TRANSPARENT, c2;
css_background_image_type bi = CSS_BACKGROUND_IMAGE_NONE, bi2;
char *bi_uri = 0;
css_background_repeat br = CSS_BACKGROUND_REPEAT_REPEAT, br2;
css_background_attachment ba = CSS_BACKGROUND_ATTACHMENT_SCROLL, ba2;
struct css_background_position horz =
{ CSS_BACKGROUND_POSITION_PERCENT, { 0 } };
struct css_background_position vert =
{ CSS_BACKGROUND_POSITION_PERCENT, { 0 } };
struct css_background_position horz2, vert2;
while (v) {
switch (v->type) {
/**\todo background-position */
case CSS_NODE_URI:
case CSS_NODE_STRING:
parse_background_image(s, v);
/* background-image */
if (!css_background_image_parse(v, &bi2,
&bi_uri))
return;
bi = bi2;
v = v->next;
break;
/*case CSS_NODE_DIMENSION:
case CSS_NODE_DIMENSION:
case CSS_NODE_PERCENTAGE:
parse_background_position(s, v);
v = v->naxt;
break;*/
/* background-position */
if (!css_background_position_parse(&v,
&horz2, &vert2))
return;
horz = horz2;
vert = vert2;
break;
case CSS_NODE_IDENT:
/* background-attachment */
ba = css_background_attachment_parse(v->data, v->data_length);
if (ba != CSS_BACKGROUND_ATTACHMENT_UNKNOWN) {
s->background_attachment = ba;
/* could be background-image: none */
if (v->data_length == 4 &&
strncasecmp(v->data, "none",
4) == 0) {
bi = CSS_BACKGROUND_IMAGE_NONE;
v = v->next;
break;
}
/* background-repeat */
br = css_background_repeat_parse(v->data, v->data_length);
if (br != CSS_BACKGROUND_REPEAT_UNKNOWN) {
s->background_repeat = br;
br2 = css_background_repeat_parse(v->data,
v->data_length);
if (br2 != CSS_BACKGROUND_REPEAT_UNKNOWN) {
br = br2;
v = v->next;
break;
}
/* background-attachment */
ba2 = css_background_attachment_parse(v->data,
v->data_length);
if (ba2 != CSS_BACKGROUND_ATTACHMENT_UNKNOWN) {
ba = ba2;
v = v->next;
break;
}
/* background-position */
if (css_background_position_parse(&v,
&horz2, &vert2)) {
horz = horz2;
vert = vert2;
break;
}
/* fall through */
case CSS_NODE_HASH:
case CSS_NODE_FUNCTION:
c = parse_colour(v);
if (c != CSS_COLOR_NONE)
s->background_color = c;
break;
/* background-color */
c2 = parse_colour(v);
if (c2 != CSS_COLOR_NONE) {
c = c2;
v = v->next;
break;
}
/* fall through */
default:
break;
/* parsing failed */
return;
}
}
s->background_color = c;
s->background_image.type = bi;
s->background_image.uri = bi_uri;
s->background_repeat = br;
s->background_attachment = ba;
s->background_position.horz = horz;
s->background_position.vert = vert;
}
void parse_background_attachment(struct css_style * const s, const struct css_node * const v)
void parse_background_attachment(struct css_style * const s,
const struct css_node * const v)
{
css_background_attachment z;
if (v->type != CSS_NODE_IDENT || v->next != 0)
@ -577,19 +650,51 @@ void parse_background_attachment(struct css_style * const s, const struct css_no
s->background_attachment = z;
}
void parse_background_color(struct css_style * const s, const struct css_node * const v)
void parse_background_color(struct css_style * const s,
const struct css_node * const v)
{
colour c = parse_colour(v);
colour c;
if (v->next)
return;
c = parse_colour(v);
if (c != CSS_COLOR_NONE)
s->background_color = c;
}
void parse_background_image(struct css_style * const s, const struct css_node * const v)
void parse_background_image(struct css_style * const s,
const struct css_node * const v)
{
css_background_image_type type;
char *uri = 0;
if (v->next)
return;
if (!css_background_image_parse(v, &type, &uri))
return;
s->background_image.type = type;
s->background_image.uri = uri;
}
/**
* Parse a background-image property.
*
* \param node node to parse
* \param type updated to background image type
* \param uri updated to background image uri, if type is
* CSS_BACKGROUND_IMAGE_URI
* \return true on success, false on parse failure
*/
bool css_background_image_parse(const struct css_node *v,
css_background_image_type *type, char **uri)
{
bool string = false;
const char *u;
char *t, *url;
s->background_image.uri = 0;
switch (v->type) {
case CSS_NODE_URI:
@ -603,9 +708,8 @@ void parse_background_image(struct css_style * const s, const struct css_node *
u++;
}
url = strndup(u, v->data_length - (u - v->data));
if (!url) {
return;
}
if (!url)
return false;
for (t = url + strlen(url) - 2;
*t == ' ' || *t == '\t' || *t == '\r' ||
*t == '\n' || *t == '\f';
@ -620,32 +724,37 @@ void parse_background_image(struct css_style * const s, const struct css_node *
* content is the parent HTML content
*/
if (v->stylesheet->type == CONTENT_HTML)
s->background_image.uri = url_join(url, v->stylesheet->data.html.base_url);
*uri = url_join(url, v->stylesheet->data.html.base_url);
else
s->background_image.uri = url_join(url, v->stylesheet->url);
*uri = url_join(url, v->stylesheet->url);
free(url);
if (!s->background_image.uri) return;
s->background_image.type = CSS_BACKGROUND_IMAGE_URI;
if (!*uri)
return false;
*type = CSS_BACKGROUND_IMAGE_URI;
break;
case CSS_NODE_STRING:
url = strndup(v->data, v->data_length);
if (!url)
return;
return false;
s->background_image.uri = url_join(url, v->stylesheet->url);
*uri = url_join(url, v->stylesheet->url);
free(url);
if (!s->background_image.uri) return;
s->background_image.type = CSS_BACKGROUND_IMAGE_URI;
if (!*uri)
return false;
*type = CSS_BACKGROUND_IMAGE_URI;
break;
case CSS_NODE_IDENT:
if (v->data_length == 7 && strncasecmp(v->data, "inherit", 7) == 0)
s->background_image.type = CSS_BACKGROUND_IMAGE_INHERIT;
else if (v->data_length == 4 && strncasecmp(v->data, "none", 4) == 0)
s->background_image.type = CSS_BACKGROUND_IMAGE_NONE;
if (v->data_length == 7 &&
strncasecmp(v->data, "inherit", 7) == 0)
*type = CSS_BACKGROUND_IMAGE_INHERIT;
else if (v->data_length == 4 &&
strncasecmp(v->data, "none", 4) == 0)
*type = CSS_BACKGROUND_IMAGE_NONE;
break;
default:
break;
return false;
}
return true;
}
@ -695,128 +804,146 @@ struct css_background_entry *css_background_lookup(
void parse_background_position(struct css_style * const s,
const struct css_node * v)
{
struct css_node *w = v->next;
struct css_background_entry *bg = 0, *bg2 = 0;
const struct css_node *node = v;
struct css_background_position horz, vert;
if (w && w->next)
if (v->next && v->next->next)
/* more than two nodes */
return;
if (!w) { /* only one value specified */
if (!css_background_position_parse(&node, &horz, &vert))
return;
if (node)
/* didn't parse all the nodes */
return;
s->background_position.horz = horz;
s->background_position.vert = vert;
}
/**
* Parse a background-position property.
*
* \param node list of nodes, updated to first unused node
* \param horz updated to horizontal background position
* \param vert updated to vertical background position
* \return true on success, false on parse failure
*/
bool css_background_position_parse(const struct css_node **node,
struct css_background_position *horz,
struct css_background_position *vert)
{
const struct css_node *v = *node;
const struct css_node *w = v->next;
struct css_background_entry *bg = 0, *bg2 = 0;
if (v->type == CSS_NODE_IDENT)
bg = css_background_lookup(v);
if (w && w->type == CSS_NODE_IDENT)
bg2 = css_background_lookup(w);
if (!(w && ((w->type == CSS_NODE_IDENT && bg2) ||
w->type == CSS_NODE_PERCENTAGE ||
w->type == CSS_NODE_DIMENSION))) {
/* only one value specified */
if (v->type == CSS_NODE_IDENT) {
if (v->data_length == 7 &&
strncasecmp(v->data, "inherit", 7)
== 0) {
s->background_position.horz.pos =
s->background_position.vert.pos =
horz->pos = vert->pos =
CSS_BACKGROUND_POSITION_INHERIT;
return;
return false;
}
bg = css_background_lookup(v);
if (!bg)
return;
s->background_position.horz.pos =
s->background_position.vert.pos =
CSS_BACKGROUND_POSITION_PERCENT;
s->background_position.horz.value.percent =
bg->horizontal ? bg->value : 50;
s->background_position.vert.value.percent =
bg->vertical ? bg->value : 50;
return false;
horz->pos = vert->pos = CSS_BACKGROUND_POSITION_PERCENT;
horz->value.percent = bg->horizontal ? bg->value : 50;
vert->value.percent = bg->vertical ? bg->value : 50;
}
else if (v->type == CSS_NODE_PERCENTAGE) {
s->background_position.horz.pos =
s->background_position.vert.pos =
CSS_BACKGROUND_POSITION_PERCENT;
s->background_position.horz.value.percent =
atof(v->data);
s->background_position.vert.value.percent = 50.0;
horz->pos = vert->pos = CSS_BACKGROUND_POSITION_PERCENT;
horz->value.percent = atof(v->data);
vert->value.percent = 50.0;
}
else if (v->type == CSS_NODE_DIMENSION) {
if (parse_length(&s->background_position.horz.value.
if (parse_length(&horz->value.
length, v, false) == 0) {
s->background_position.horz.pos =
CSS_BACKGROUND_POSITION_LENGTH;
s->background_position.vert.pos =
CSS_BACKGROUND_POSITION_PERCENT;
s->background_position.vert.value.percent =
50.0;
horz->pos = CSS_BACKGROUND_POSITION_LENGTH;
vert->pos = CSS_BACKGROUND_POSITION_PERCENT;
vert->value.percent = 50.0;
}
}
return;
*node = w;
return true;
}
/* two values specified */
if (v->type == CSS_NODE_IDENT && w->type == CSS_NODE_IDENT) {
/* both keywords */
bg = css_background_lookup(v);
bg2 = css_background_lookup(w);
if (!bg || !bg2)
return;
return false;
if ((bg->horizontal && bg2->horizontal) ||
(bg->vertical && bg2->vertical))
return;
s->background_position.horz.pos =
s->background_position.vert.pos =
CSS_BACKGROUND_POSITION_PERCENT;
s->background_position.horz.value.percent =
s->background_position.vert.value.percent = 50;
return false;
horz->pos = vert->pos = CSS_BACKGROUND_POSITION_PERCENT;
horz->value.percent = vert->value.percent = 50;
if (bg->horizontal)
s->background_position.horz.value.percent = bg->value;
horz->value.percent = bg->value;
else if (bg2->horizontal)
s->background_position.horz.value.percent = bg2->value;
horz->value.percent = bg2->value;
if (bg->vertical)
s->background_position.vert.value.percent = bg->value;
vert->value.percent = bg->value;
else if (bg2->vertical)
s->background_position.vert.value.percent = bg2->value;
vert->value.percent = bg2->value;
return;
*node = w->next;
return true;
}
if (v->type == CSS_NODE_IDENT) { /* horizontal value */
bg = css_background_lookup(v);
if (!bg || bg->vertical)
return;
return false;
}
if (w->type == CSS_NODE_IDENT) { /* vertical value */
bg2 = css_background_lookup(w);
if (!bg2 || bg2->horizontal)
return;
return false;
}
if (v->type == CSS_NODE_IDENT) { /* horizontal value */
s->background_position.horz.pos =
CSS_BACKGROUND_POSITION_PERCENT;
s->background_position.horz.value.percent = bg->value;
horz->pos = CSS_BACKGROUND_POSITION_PERCENT;
horz->value.percent = bg->value;
} else if (v->type == CSS_NODE_PERCENTAGE) {
s->background_position.horz.pos =
CSS_BACKGROUND_POSITION_PERCENT;
s->background_position.horz.value.percent = atof(v->data);
horz->pos = CSS_BACKGROUND_POSITION_PERCENT;
horz->value.percent = atof(v->data);
} else if (v->type == CSS_NODE_DIMENSION) {
if (parse_length(&s->background_position.horz.value.length,
if (parse_length(&horz->value.length,
v, false) == 0)
s->background_position.horz.pos =
CSS_BACKGROUND_POSITION_LENGTH;
horz->pos = CSS_BACKGROUND_POSITION_LENGTH;
}
if (w->type == CSS_NODE_IDENT) { /* vertical value */
s->background_position.vert.pos =
CSS_BACKGROUND_POSITION_PERCENT;
s->background_position.vert.value.percent = bg2->value;
vert->pos = CSS_BACKGROUND_POSITION_PERCENT;
vert->value.percent = bg2->value;
} else if (w->type == CSS_NODE_PERCENTAGE) {
s->background_position.vert.pos =
CSS_BACKGROUND_POSITION_PERCENT;
s->background_position.vert.value.percent = atof(w->data);
vert->pos = CSS_BACKGROUND_POSITION_PERCENT;
vert->value.percent = atof(w->data);
} else if (w->type == CSS_NODE_DIMENSION) {
if (parse_length(&s->background_position.vert.value.length,
if (parse_length(&vert->value.length,
w, false) == 0)
s->background_position.vert.pos =
CSS_BACKGROUND_POSITION_LENGTH;
vert->pos = CSS_BACKGROUND_POSITION_LENGTH;
}
*node = w->next;
return true;
}
void parse_background_repeat(struct css_style * const s, const struct css_node * const v)
void parse_background_repeat(struct css_style * const s,
const struct css_node * const v)
{
css_background_repeat z;
if (v->type != CSS_NODE_IDENT || v->next != 0)
@ -826,6 +953,7 @@ void parse_background_repeat(struct css_style * const s, const struct css_node *
s->background_repeat = z;
}
void parse_border_width(struct css_style * const s,
const struct css_node * const v)
{
@ -1616,3 +1744,4 @@ css_text_decoration css_text_decoration_parse(const char * const s,
return CSS_TEXT_DECORATION_UNKNOWN;
}
/** \} */

68
riscos/htmlredraw.c
View File

@ -102,11 +102,7 @@ void html_redraw_box(struct content *content, struct box * box,
int padding_left, padding_top;
int padding_width, padding_height;
int x0, y0, x1, y1;
int px0, py0, px1, py1;
int colour;
os_VDU_VAR_LIST(5) vars = { { os_VDUVAR_GWL_COL, os_VDUVAR_GWB_ROW,
os_VDUVAR_GWR_COL, os_VDUVAR_GWT_ROW, -1 } };
os_vdu_var cgw[4];
x += box->x * 2 * scale;
y -= box->y * 2 * scale;
@ -215,38 +211,44 @@ void html_redraw_box(struct content *content, struct box * box,
y1 = clip_y1;
}
/* find intersection of clip box and padding box */
px0 = x < x0 ? x0 : x;
py0 = y - padding_height < y0 ? y0 : y - padding_height;
px1 = x + padding_width < x1 ? x + padding_width : x1;
py1 = y < y1 ? y : y1;
/* background colour and image */
if (box->style && (box->type != BOX_INLINE ||
box->style != box->parent->parent->style)) {
/* find intersection of clip box and padding box */
int px0 = x < x0 ? x0 : x;
int py0 = y - padding_height < y0 ? y0 : y - padding_height;
int px1 = x + padding_width < x1 ? x + padding_width : x1;
int py1 = y < y1 ? y : y1;
/* background colour */
if (box->style != 0 && box->style->background_color != TRANSPARENT) {
colourtrans_set_gcol(box->style->background_color << 8,
colourtrans_USE_ECFS, os_ACTION_OVERWRITE, 0);
os_plot(os_MOVE_TO, px0, py0);
if (px0 < px1 && py0 < py1)
os_plot(os_PLOT_RECTANGLE | os_PLOT_TO, px1, py1);
current_background_color = box->style->background_color;
/* background colour */
/* optimisation: skip if fully repeated background image */
if (box->style->background_color != TRANSPARENT &&
(!box->background ||
box->style->background_repeat !=
CSS_BACKGROUND_REPEAT_REPEAT)) {
colourtrans_set_gcol(box->style->background_color << 8,
colourtrans_USE_ECFS,
os_ACTION_OVERWRITE, 0);
os_plot(os_MOVE_TO, px0, py0);
if (px0 < px1 && py0 < py1)
os_plot(os_PLOT_RECTANGLE | os_PLOT_TO,
px1, py1);
current_background_color = box->style->background_color;
}
if (box->background) {
/* clip to padding box */
html_redraw_clip(px0, py0, px1, py1);
/* plot background image */
html_redraw_background(x, y, width, clip_y1 - clip_y0,
box, scale);
/* restore previous graphics window */
html_redraw_clip(x0, y0, x1, y1);
}
}
/* read current graphics window dimensions */
xos_read_vdu_variables((os_vdu_var_list const *) &vars, (int*)&cgw);
/* clip to padding box */
html_redraw_clip(px0, py0, px1, py1);
/* plot background image */
/* the if statement below causes regression on acornarcade.com
* but fixes some issues with the CSS testsuite background section */
// if (box->type != BOX_INLINE && box->background)
html_redraw_background(x, y, width, clip_y1-clip_y0, box, scale);
/* restore previous graphics window */
/* should probably take account of the eigvalues here... */
html_redraw_clip(cgw[0]*2, cgw[1]*2, cgw[2]*2, cgw[3]*2);
if (box->object) {
content_redraw(box->object, x + padding_left, y - padding_top,
width, height, x0, y0, x1, y1, scale);