summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorJohn Mark Bell <jmb@netsurf-browser.org>2009-07-17 16:01:25 +0000
committerJohn Mark Bell <jmb@netsurf-browser.org>2009-07-17 16:01:25 +0000
commitfdd5d5f6a27e1f072bd8ba0735c4c23c2456b8da (patch)
treee6a0f15279019094d25da45c03d9eb658a197581 /src
parentb8e3187d892d9adf45df2947adb9f03d2d9880ae (diff)
downloadlibcss-fdd5d5f6a27e1f072bd8ba0735c4c23c2456b8da.tar.gz
libcss-fdd5d5f6a27e1f072bd8ba0735c4c23c2456b8da.tar.bz2
Store em and percentage values for properties in the computed style.
Fully compute them on access. Introduce a swathe of internal accessors that don't perform the complete computation. Port property composition to these new APIs. Reduce absolute value computation to making font sizes absolute and converting any EX units to EM. svn path=/trunk/libcss/; revision=8601
Diffstat (limited to 'src')
-rw-r--r--src/select/computed.c444
-rw-r--r--src/select/properties.c351
-rw-r--r--src/select/propget.h1724
3 files changed, 1983 insertions, 536 deletions
diff --git a/src/select/computed.c b/src/select/computed.c
index 4e3d219..4b44f56 100644
--- a/src/select/computed.c
+++ b/src/select/computed.c
@@ -9,70 +9,57 @@
#include "select/computed.h"
#include "select/dispatch.h"
+#include "select/propget.h"
#include "select/propset.h"
#include "utils/utils.h"
static css_error compute_border_colors(css_computed_style *style);
-static css_error compute_float(css_computed_style *style);
static css_error compute_absolute_border_width(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size);
static css_error compute_absolute_border_side_width(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size,
uint8_t (*get)(const css_computed_style *style,
css_fixed *len, css_unit *unit),
css_error (*set)(css_computed_style *style, uint8_t type,
css_fixed len, css_unit unit));
static css_error compute_absolute_sides(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size);
static css_error compute_absolute_clip(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size);
static css_error compute_absolute_line_height(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size);
static css_error compute_absolute_margins(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size);
static css_error compute_absolute_padding(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size);
static css_error compute_absolute_vertical_align(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size);
static css_error compute_absolute_length(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size,
uint8_t (*get)(const css_computed_style *style,
css_fixed *len, css_unit *unit),
css_error (*set)(css_computed_style *style, uint8_t type,
css_fixed len, css_unit unit));
static css_error compute_absolute_length_auto(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size,
uint8_t (*get)(const css_computed_style *style,
css_fixed *len, css_unit *unit),
css_error (*set)(css_computed_style *style, uint8_t type,
css_fixed len, css_unit unit));
static css_error compute_absolute_length_none(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size,
uint8_t (*get)(const css_computed_style *style,
css_fixed *len, css_unit *unit),
css_error (*set)(css_computed_style *style, uint8_t type,
css_fixed len, css_unit unit));
static css_error compute_absolute_length_normal(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size,
uint8_t (*get)(const css_computed_style *style,
css_fixed *len, css_unit *unit),
css_error (*set)(css_computed_style *style, uint8_t type,
css_fixed len, css_unit unit));
static css_error compute_absolute_length_pair(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size,
uint8_t (*get)(const css_computed_style *style,
css_fixed *len1, css_unit *unit1,
@@ -273,12 +260,12 @@ css_error compute_absolute_values(const css_computed_style *parent,
/* Ensure font-size is absolute */
if (parent != NULL) {
- psize.status = css_computed_font_size(parent,
+ psize.status = get_font_size(parent,
&psize.data.length.value,
&psize.data.length.unit);
}
- size.status = css_computed_font_size(style,
+ size.status = get_font_size(style,
&size.data.length.value,
&size.data.length.unit);
@@ -287,8 +274,9 @@ css_error compute_absolute_values(const css_computed_style *parent,
if (error != CSS_OK)
return error;
- error = set_font_size(style, size.status,
- size.data.length.value, size.data.length.unit);
+ error = set_font_size(style, size.status,
+ size.data.length.value,
+ size.data.length.unit);
if (error != CSS_OK)
return error;
@@ -300,9 +288,14 @@ css_error compute_absolute_values(const css_computed_style *parent,
if (error != CSS_OK)
return error;
+ /* Convert ex size into ems */
+ ex_size.data.length.value = FDIV(ex_size.data.length.value,
+ size.data.length.value);
+ ex_size.data.length.unit = CSS_UNIT_EM;
+
/* Fix up background-position */
- error = compute_absolute_length_pair(style, &size.data.length,
- &ex_size.data.length, css_computed_background_position,
+ error = compute_absolute_length_pair(style, &ex_size.data.length,
+ get_background_position,
set_background_position);
if (error != CSS_OK)
return error;
@@ -313,90 +306,74 @@ css_error compute_absolute_values(const css_computed_style *parent,
return error;
/* Fix up border-{top,right,bottom,left}-width */
- error = compute_absolute_border_width(style, &size.data.length,
- &ex_size.data.length);
+ error = compute_absolute_border_width(style, &ex_size.data.length);
if (error != CSS_OK)
return error;
/* Fix up sides */
- error = compute_absolute_sides(style, &size.data.length,
- &ex_size.data.length);
- if (error != CSS_OK)
- return error;
-
- /* Fix up float */
- error = compute_float(style);
+ error = compute_absolute_sides(style, &ex_size.data.length);
if (error != CSS_OK)
return error;
/* Fix up height */
- error = compute_absolute_length_auto(style, &size.data.length,
- &ex_size.data.length, css_computed_height, set_height);
+ error = compute_absolute_length_auto(style, &ex_size.data.length,
+ get_height, set_height);
if (error != CSS_OK)
return error;
/* Fix up line-height (must be before vertical-align) */
- error = compute_absolute_line_height(style, &size.data.length,
- &ex_size.data.length);
+ error = compute_absolute_line_height(style, &ex_size.data.length);
if (error != CSS_OK)
return error;
/* Fix up margins */
- error = compute_absolute_margins(style, &size.data.length,
- &ex_size.data.length);
+ error = compute_absolute_margins(style, &ex_size.data.length);
if (error != CSS_OK)
return error;
/* Fix up max-height */
- error = compute_absolute_length_none(style, &size.data.length,
- &ex_size.data.length, css_computed_max_height,
- set_max_height);
+ error = compute_absolute_length_none(style, &ex_size.data.length,
+ get_max_height, set_max_height);
if (error != CSS_OK)
return error;
/* Fix up max-width */
- error = compute_absolute_length_none(style, &size.data.length,
- &ex_size.data.length, css_computed_max_width,
- set_max_width);
+ error = compute_absolute_length_none(style, &ex_size.data.length,
+ get_max_width, set_max_width);
if (error != CSS_OK)
return error;
/* Fix up min-height */
- error = compute_absolute_length(style, &size.data.length,
- &ex_size.data.length, css_computed_min_height,
- set_min_height);
+ error = compute_absolute_length(style, &ex_size.data.length,
+ get_min_height, set_min_height);
if (error != CSS_OK)
return error;
/* Fix up min-width */
- error = compute_absolute_length(style, &size.data.length,
- &ex_size.data.length, css_computed_min_width,
- set_min_width);
+ error = compute_absolute_length(style, &ex_size.data.length,
+ get_min_width, set_min_width);
if (error != CSS_OK)
return error;
/* Fix up padding */
- error = compute_absolute_padding(style, &size.data.length,
- &ex_size.data.length);
+ error = compute_absolute_padding(style, &ex_size.data.length);
if (error != CSS_OK)
return error;
/* Fix up text-indent */
- error = compute_absolute_length(style, &size.data.length,
- &ex_size.data.length, css_computed_text_indent,
- set_text_indent);
+ error = compute_absolute_length(style, &ex_size.data.length,
+ get_text_indent, set_text_indent);
if (error != CSS_OK)
return error;
/* Fix up vertical-align */
- error = compute_absolute_vertical_align(style, &size.data.length,
- &ex_size.data.length);
+ error = compute_absolute_vertical_align(style, &ex_size.data.length);
if (error != CSS_OK)
return error;
/* Fix up width */
- error = compute_absolute_length_auto(style, &size.data.length,
- &ex_size.data.length, css_computed_width, set_width);
+ error = compute_absolute_length_auto(style, &ex_size.data.length,
+ get_width, set_width);
if (error != CSS_OK)
return error;
@@ -404,37 +381,38 @@ css_error compute_absolute_values(const css_computed_style *parent,
if (style->uncommon != NULL) {
/* Fix up border-spacing */
error = compute_absolute_length_pair(style,
- &size.data.length, &ex_size.data.length,
- css_computed_border_spacing,
+ &ex_size.data.length,
+ get_border_spacing,
set_border_spacing);
if (error != CSS_OK)
return error;
/* Fix up clip */
- error = compute_absolute_clip(style, &size.data.length,
- &ex_size.data.length);
+ error = compute_absolute_clip(style, &ex_size.data.length);
if (error != CSS_OK)
return error;
/* Fix up letter-spacing */
error = compute_absolute_length_normal(style,
- &size.data.length, &ex_size.data.length,
- css_computed_letter_spacing,
+ &ex_size.data.length,
+ get_letter_spacing,
set_letter_spacing);
if (error != CSS_OK)
return error;
/* Fix up outline-width */
error = compute_absolute_border_side_width(style,
- &size.data.length, &ex_size.data.length,
- css_computed_outline_width, set_outline_width);
+ &ex_size.data.length,
+ get_outline_width,
+ set_outline_width);
if (error != CSS_OK)
return error;
/* Fix up word spacing */
error = compute_absolute_length_normal(style,
- &size.data.length, &ex_size.data.length,
- css_computed_word_spacing, set_word_spacing);
+ &ex_size.data.length,
+ get_word_spacing,
+ set_word_spacing);
if (error != CSS_OK)
return error;
}
@@ -460,32 +438,28 @@ css_error compute_border_colors(css_computed_style *style)
css_computed_color(style, &color);
- if (css_computed_border_top_color(style, &bcol) ==
- CSS_BORDER_COLOR_INITIAL) {
+ if (get_border_top_color(style, &bcol) == CSS_BORDER_COLOR_INITIAL) {
error = set_border_top_color(style,
CSS_BORDER_COLOR_COLOR, color);
if (error != CSS_OK)
return error;
}
- if (css_computed_border_right_color(style, &bcol) ==
- CSS_BORDER_COLOR_INITIAL) {
+ if (get_border_right_color(style, &bcol) == CSS_BORDER_COLOR_INITIAL) {
error = set_border_right_color(style,
CSS_BORDER_COLOR_COLOR, color);
if (error != CSS_OK)
return error;
}
- if (css_computed_border_bottom_color(style, &bcol) ==
- CSS_BORDER_COLOR_INITIAL) {
+ if (get_border_bottom_color(style, &bcol) == CSS_BORDER_COLOR_INITIAL) {
error = set_border_bottom_color(style,
CSS_BORDER_COLOR_COLOR, color);
if (error != CSS_OK)
return error;
}
- if (css_computed_border_left_color(style, &bcol) ==
- CSS_BORDER_COLOR_INITIAL) {
+ if (get_border_left_color(style, &bcol) == CSS_BORDER_COLOR_INITIAL) {
error = set_border_left_color(style,
CSS_BORDER_COLOR_COLOR, color);
if (error != CSS_OK)
@@ -496,61 +470,37 @@ css_error compute_border_colors(css_computed_style *style)
}
/**
- * Compute float, considering position ($9.7)
- *
- * \param style Style to process
- * \return CSS_OK on success
- */
-css_error compute_float(css_computed_style *style)
-{
- uint8_t pos;
- css_error error;
-
- pos = css_computed_position(style);
-
- if (pos == CSS_POSITION_ABSOLUTE || pos == CSS_POSITION_FIXED) /*2*/ {
- error = set_float(style, CSS_FLOAT_NONE);
- if (error != CSS_OK)
- return error;
- }
-
- return CSS_OK;
-}
-
-/**
* Compute absolute border widths
*
* \param style Style to process
- * \param font_size Absolute font size
- * \param ex_size Absolute ex size
+ * \param ex_size Ex size in ems
* \return CSS_OK on success
*/
css_error compute_absolute_border_width(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size)
{
css_error error;
- error = compute_absolute_border_side_width(style, font_size, ex_size,
- css_computed_border_top_width,
+ error = compute_absolute_border_side_width(style, ex_size,
+ get_border_top_width,
set_border_top_width);
if (error != CSS_OK)
return error;
- error = compute_absolute_border_side_width(style, font_size, ex_size,
- css_computed_border_right_width,
+ error = compute_absolute_border_side_width(style, ex_size,
+ get_border_right_width,
set_border_right_width);
if (error != CSS_OK)
return error;
- error = compute_absolute_border_side_width(style, font_size, ex_size,
- css_computed_border_bottom_width,
+ error = compute_absolute_border_side_width(style, ex_size,
+ get_border_bottom_width,
set_border_bottom_width);
if (error != CSS_OK)
return error;
- error = compute_absolute_border_side_width(style, font_size, ex_size,
- css_computed_border_left_width,
+ error = compute_absolute_border_side_width(style, ex_size,
+ get_border_left_width,
set_border_left_width);
if (error != CSS_OK)
return error;
@@ -562,14 +512,12 @@ css_error compute_absolute_border_width(css_computed_style *style,
* Compute an absolute border side width
*
* \param style Style to process
- * \param font_size Absolute font size
- * \param ex_size Absolute ex size
+ * \param ex_size Ex size, in ems
* \param get Function to read length
* \param set Function to write length
* \return CSS_OK on success
*/
css_error compute_absolute_border_side_width(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size,
uint8_t (*get)(const css_computed_style *style,
css_fixed *len, css_unit *unit),
@@ -592,10 +540,7 @@ css_error compute_absolute_border_side_width(css_computed_style *style,
unit = CSS_UNIT_PX;
}
- if (unit == CSS_UNIT_EM) {
- length = FMUL(length, font_size->value);
- unit = font_size->unit;
- } else if (unit == CSS_UNIT_EX) {
+ if (unit == CSS_UNIT_EX) {
length = FMUL(length, ex_size->value);
unit = ex_size->unit;
}
@@ -607,55 +552,40 @@ css_error compute_absolute_border_side_width(css_computed_style *style,
* Compute absolute clip
*
* \param style Style to process
- * \param font_size Absolute font size
- * \param ex_size Absolute ex size
+ * \param ex_size Ex size in ems
* \return CSS_OK on success
*/
css_error compute_absolute_clip(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size)
{
css_computed_clip_rect rect = { 0, 0, 0, 0, CSS_UNIT_PX, CSS_UNIT_PX,
CSS_UNIT_PX, CSS_UNIT_PX, false, false, false, false };
css_error error;
- if (css_computed_clip(style, &rect) == CSS_CLIP_RECT) {
+ if (get_clip(style, &rect) == CSS_CLIP_RECT) {
if (rect.top_auto == false) {
- if (rect.tunit == CSS_UNIT_EM) {
- rect.top = FMUL(rect.top, font_size->value);
- rect.tunit = font_size->unit;
- } else if (rect.tunit == CSS_UNIT_EX) {
+ if (rect.tunit == CSS_UNIT_EX) {
rect.top = FMUL(rect.top, ex_size->value);
rect.tunit = ex_size->unit;
}
}
if (rect.right_auto == false) {
- if (rect.runit == CSS_UNIT_EM) {
- rect.right = FMUL(rect.right, font_size->value);
- rect.runit = font_size->unit;
- } else if (rect.runit == CSS_UNIT_EX) {
+ if (rect.runit == CSS_UNIT_EX) {
rect.right = FMUL(rect.right, ex_size->value);
rect.runit = ex_size->unit;
}
}
if (rect.bottom_auto == false) {
- if (rect.bunit == CSS_UNIT_EM) {
- rect.bottom =
- FMUL(rect.bottom, font_size->value);
- rect.bunit = font_size->unit;
- } else if (rect.bunit == CSS_UNIT_EX) {
+ if (rect.bunit == CSS_UNIT_EX) {
rect.bottom = FMUL(rect.bottom, ex_size->value);
rect.bunit = ex_size->unit;
}
}
if (rect.left_auto == false) {
- if (rect.lunit == CSS_UNIT_EM) {
- rect.left = FMUL(rect.left, font_size->value);
- rect.lunit = font_size->unit;
- } else if (rect.lunit == CSS_UNIT_EX) {
+ if (rect.lunit == CSS_UNIT_EX) {
rect.left = FMUL(rect.left, ex_size->value);
rect.lunit = ex_size->unit;
}
@@ -673,12 +603,10 @@ css_error compute_absolute_clip(css_computed_style *style,
* Compute absolute line-height
*
* \param style Style to process
- * \param font_size Absolute font size
- * \param ex_size Absolute ex size
+ * \param ex_size Ex size, in ems
* \return CSS_OK on success
*/
css_error compute_absolute_line_height(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size)
{
css_fixed length = 0;
@@ -686,19 +614,12 @@ css_error compute_absolute_line_height(css_computed_style *style,
uint8_t type;
css_error error;
- type = css_computed_line_height(style, &length, &unit);
+ type = get_line_height(style, &length, &unit);
if (type == CSS_LINE_HEIGHT_DIMENSION) {
- if (unit == CSS_UNIT_EM) {
- length = FMUL(length, font_size->value);
- unit = font_size->unit;
- } else if (unit == CSS_UNIT_EX) {
+ if (unit == CSS_UNIT_EX) {
length = FMUL(length, ex_size->value);
unit = ex_size->unit;
- } else if (unit == CSS_UNIT_PCT) {
- length = FDIV(FMUL(length, font_size->value),
- INTTOFIX(100));
- unit = font_size->unit;
}
error = set_line_height(style, type, length, unit);
@@ -713,137 +634,34 @@ css_error compute_absolute_line_height(css_computed_style *style,
* Compute the absolute values of {top,right,bottom,left}
*
* \param style Style to process
- * \param font_size Absolute font size
- * \param ex_size Absolute ex size
+ * \param ex_size Ex size, in ems
* \return CSS_OK on success
*/
css_error compute_absolute_sides(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size)
{
- enum css_position pos;
css_error error;
/* Calculate absolute lengths for sides */
- error = compute_absolute_length_auto(style, font_size, ex_size,
- css_computed_top, set_top);
+ error = compute_absolute_length_auto(style, ex_size, get_top, set_top);
if (error != CSS_OK)
return error;
- error = compute_absolute_length_auto(style, font_size, ex_size,
- css_computed_right, set_right);
+ error = compute_absolute_length_auto(style, ex_size,
+ get_right, set_right);
if (error != CSS_OK)
return error;
- error = compute_absolute_length_auto(style, font_size, ex_size,
- css_computed_bottom, set_bottom);
+ error = compute_absolute_length_auto(style, ex_size,
+ get_bottom, set_bottom);
if (error != CSS_OK)
return error;
- error = compute_absolute_length_auto(style, font_size, ex_size,
- css_computed_left, set_left);
+ error = compute_absolute_length_auto(style, ex_size,
+ get_left, set_left);
if (error != CSS_OK)
return error;
- /* Now, complete computation based upon computed position */
- pos = css_computed_position(style);
- if (pos == CSS_POSITION_STATIC) {
- /* Static => everything is auto */
- error = set_top(style, CSS_TOP_AUTO, 0, CSS_UNIT_PX);
- if (error != CSS_OK)
- return error;
-
- error = set_right(style, CSS_RIGHT_AUTO, 0, CSS_UNIT_PX);
- if (error != CSS_OK)
- return error;
-
- error = set_bottom(style, CSS_BOTTOM_AUTO, 0, CSS_UNIT_PX);
- if (error != CSS_OK)
- return error;
-
- error = set_left(style, CSS_LEFT_AUTO, 0, CSS_UNIT_PX);
- if (error != CSS_OK)
- return error;
- } else if (pos == CSS_POSITION_RELATIVE) {
- /* Relative => follow $9.4.3 */
- css_fixed len1 = 0, len2 = 0;
- css_unit unit1 = CSS_UNIT_PX, unit2 = CSS_UNIT_PX;
- uint8_t type1, type2;
-
- /* First, left and right */
- type1 = css_computed_left(style, &len1, &unit1);
- type2 = css_computed_right(style, &len2, &unit2);
-
- if (type1 == CSS_LEFT_AUTO && type2 == CSS_RIGHT_AUTO) {
- /* Both auto => 0px */
- error = set_left(style, CSS_LEFT_SET, 0, CSS_UNIT_PX);
- if (error != CSS_OK)
- return error;
-
- error = set_right(style, CSS_RIGHT_SET, 0, CSS_UNIT_PX);
- if (error != CSS_OK)
- return error;
- } else if (type1 == CSS_LEFT_AUTO) {
- /* Left is auto => set to -right */
- error = set_left(style, CSS_LEFT_SET, -len2, unit2);
- if (error != CSS_OK)
- return error;
- } else if (type2 == CSS_RIGHT_AUTO) {
- /* Right is auto => set to -left */
- error = set_right(style, CSS_RIGHT_SET, -len1, unit1);
- if (error != CSS_OK)
- return error;
- } else {
- /** \todo This should be containing block's direction */
- /* Overconstrained => consult direction */
- if (css_computed_direction(style) ==
- CSS_DIRECTION_LTR) {
- /* Right = -left */
- error = set_right(style, CSS_RIGHT_SET,
- -len1, unit1);
- if (error != CSS_OK)
- return error;
- } else {
- /* Left = -right */
- error = set_left(style, CSS_LEFT_SET,
- -len2, unit2);
- if (error != CSS_OK)
- return error;
- }
- }
-
- /* Second, top and bottom */
- type1 = css_computed_top(style, &len1, &unit1);
- type2 = css_computed_bottom(style, &len2, &unit2);
-
- if (type1 == CSS_TOP_AUTO && type2 == CSS_BOTTOM_AUTO) {
- /* Both auto => 0px */
- error = set_top(style, CSS_TOP_SET, 0, CSS_UNIT_PX);
- if (error != CSS_OK)
- return error;
-
- error = set_bottom(style, CSS_BOTTOM_SET,
- 0, CSS_UNIT_PX);
- if (error != CSS_OK)
- return error;
- } else if (type1 == CSS_TOP_AUTO) {
- /* Top is auto => set to -bottom */
- error = set_top(style, CSS_TOP_SET, -len2, unit2);
- if (error != CSS_OK)
- return error;
- } else if (type2 == CSS_BOTTOM_AUTO) {
- /* Bottom is auto => set to -top */
- error = set_bottom(style, CSS_BOTTOM_SET, -len1, unit1);
- if (error != CSS_OK)
- return error;
- } else {
- /* Overconstrained => bottom = -top */
- error = set_bottom(style, CSS_BOTTOM_SET, -len1, unit1);
- if (error != CSS_OK)
- return error;
- }
- }
-
return CSS_OK;
}
@@ -851,33 +669,31 @@ css_error compute_absolute_sides(css_computed_style *style,
* Compute absolute margins
*
* \param style Style to process
- * \param font_size Absolute font size
- * \param ex_size Absolute ex size
+ * \param ex_size Ex size, in ems
* \return CSS_OK on success
*/
css_error compute_absolute_margins(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size)
{
css_error error;
- error = compute_absolute_length_auto(style, font_size, ex_size,
- css_computed_margin_top, set_margin_top);
+ error = compute_absolute_length_auto(style, ex_size,
+ get_margin_top, set_margin_top);
if (error != CSS_OK)
return error;
- error = compute_absolute_length_auto(style, font_size, ex_size,
- css_computed_margin_right, set_margin_right);
+ error = compute_absolute_length_auto(style, ex_size,
+ get_margin_right, set_margin_right);
if (error != CSS_OK)
return error;
- error = compute_absolute_length_auto(style, font_size, ex_size,
- css_computed_margin_bottom, set_margin_bottom);
+ error = compute_absolute_length_auto(style, ex_size,
+ get_margin_bottom, set_margin_bottom);
if (error != CSS_OK)
return error;
- error = compute_absolute_length_auto(style, font_size, ex_size,
- css_computed_margin_left, set_margin_left);
+ error = compute_absolute_length_auto(style, ex_size,
+ get_margin_left, set_margin_left);
if (error != CSS_OK)
return error;
@@ -888,33 +704,31 @@ css_error compute_absolute_margins(css_computed_style *style,
* Compute absolute padding
*
* \param style Style to process
- * \param font_size Absolute font size
- * \param ex_size Absolute ex size
+ * \param ex_size Ex size, in ems
* \return CSS_OK on success
*/
css_error compute_absolute_padding(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size)
{
css_error error;
- error = compute_absolute_length(style, font_size, ex_size,
- css_computed_padding_top, set_padding_top);
+ error = compute_absolute_length(style, ex_size,
+ get_padding_top, set_padding_top);
if (error != CSS_OK)
return error;
- error = compute_absolute_length(style, font_size, ex_size,
- css_computed_padding_right, set_padding_right);
+ error = compute_absolute_length(style, ex_size,
+ get_padding_right, set_padding_right);
if (error != CSS_OK)
return error;
- error = compute_absolute_length(style, font_size, ex_size,
- css_computed_padding_bottom, set_padding_bottom);
+ error = compute_absolute_length(style, ex_size,
+ get_padding_bottom, set_padding_bottom);
if (error != CSS_OK)
return error;
- error = compute_absolute_length(style, font_size, ex_size,
- css_computed_padding_left, set_padding_left);
+ error = compute_absolute_length(style, ex_size,
+ get_padding_left, set_padding_left);
if (error != CSS_OK)
return error;
@@ -925,12 +739,10 @@ css_error compute_absolute_padding(css_computed_style *style,
* Compute absolute vertical-align
*
* \param style Style to process
- * \param font_size Absolute font size
- * \param ex_size Absolute ex size
+ * \param ex_size Ex size, in ems
* \return CSS_OK on success
*/
css_error compute_absolute_vertical_align(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size)
{
css_fixed length = 0;
@@ -938,24 +750,12 @@ css_error compute_absolute_vertical_align(css_computed_style *style,
uint8_t type;
css_error error;
- type = css_computed_vertical_align(style, &length, &unit);
+ type = get_vertical_align(style, &length, &unit);
if (type == CSS_VERTICAL_ALIGN_SET) {
- if (unit == CSS_UNIT_EM) {
- length = FMUL(length, font_size->value);
- unit = font_size->unit;
- } else if (unit == CSS_UNIT_EX) {
+ if (unit == CSS_UNIT_EX) {
length = FMUL(length, ex_size->value);
unit = ex_size->unit;
- } else if (unit == CSS_UNIT_PCT) {
- css_fixed line_height = 0;
- css_unit lhunit = CSS_UNIT_PX;
-
- /* Relative to line-height */
- css_computed_line_height(style, &line_height, &lhunit);
-
- length = FDIV(FMUL(length, line_height), INTTOFIX(100));
- unit = lhunit;
}
error = set_vertical_align(style, type, length, unit);
@@ -970,14 +770,12 @@ css_error compute_absolute_vertical_align(css_computed_style *style,
* Compute the absolute value of length
*
* \param style Style to process
- * \param font_size Absolute font size
- * \param ex_size Absolute ex size
+ * \param ex_size Ex size, in ems
* \param get Function to read length
* \param set Function to write length
* \return CSS_OK on success
*/
css_error compute_absolute_length(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size,
uint8_t (*get)(const css_computed_style *style,
css_fixed *len, css_unit *unit),
@@ -990,10 +788,7 @@ css_error compute_absolute_length(css_computed_style *style,
type = get(style, &length, &unit);
- if (unit == CSS_UNIT_EM) {
- length = FMUL(length, font_size->value);
- unit = font_size->unit;
- } else if (unit == CSS_UNIT_EX) {
+ if (unit == CSS_UNIT_EX) {
length = FMUL(length, ex_size->value);
unit = ex_size->unit;
}
@@ -1005,14 +800,12 @@ css_error compute_absolute_length(css_computed_style *style,
* Compute the absolute value of length or auto
*
* \param style Style to process
- * \param font_size Absolute font size
- * \param ex_size Absolute ex size
+ * \param ex_size Ex size, in ems
* \param get Function to read length
* \param set Function to write length
* \return CSS_OK on success
*/
css_error compute_absolute_length_auto(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size,
uint8_t (*get)(const css_computed_style *style,
css_fixed *len, css_unit *unit),
@@ -1025,10 +818,7 @@ css_error compute_absolute_length_auto(css_computed_style *style,
type = get(style, &length, &unit);
if (type != CSS_BOTTOM_AUTO) {
- if (unit == CSS_UNIT_EM) {
- length = FMUL(length, font_size->value);
- unit = font_size->unit;
- } else if (unit == CSS_UNIT_EX) {
+ if (unit == CSS_UNIT_EX) {
length = FMUL(length, ex_size->value);
unit = ex_size->unit;
}
@@ -1043,14 +833,12 @@ css_error compute_absolute_length_auto(css_computed_style *style,
* Compute the absolute value of length or none
*
* \param style Style to process
- * \param font_size Absolute font size
- * \param ex_size Absolute ex size
+ * \param ex_size Ex size, in ems
* \param get Function to read length
* \param set Function to write length
* \return CSS_OK on success
*/
css_error compute_absolute_length_none(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size,
uint8_t (*get)(const css_computed_style *style,
css_fixed *len, css_unit *unit),
@@ -1063,10 +851,7 @@ css_error compute_absolute_length_none(css_computed_style *style,
type = get(style, &length, &unit);
if (type != CSS_MAX_HEIGHT_NONE) {
- if (unit == CSS_UNIT_EM) {
- length = FMUL(length, font_size->value);
- unit = font_size->unit;
- } else if (unit == CSS_UNIT_EX) {
+ if (unit == CSS_UNIT_EX) {
length = FMUL(length, ex_size->value);
unit = ex_size->unit;
}
@@ -1081,14 +866,12 @@ css_error compute_absolute_length_none(css_computed_style *style,
* Compute the absolute value of length or normal
*
* \param style Style to process
- * \param font_size Absolute font size
- * \param ex_size Absolute ex size
+ * \param ex_size Ex size, in ems
* \param get Function to read length
* \param set Function to write length
* \return CSS_OK on success
*/
css_error compute_absolute_length_normal(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size,
uint8_t (*get)(const css_computed_style *style,
css_fixed *len, css_unit *unit),
@@ -1101,10 +884,7 @@ css_error compute_absolute_length_normal(css_computed_style *style,
type = get(style, &length, &unit);
if (type != CSS_LETTER_SPACING_NORMAL) {
- if (unit == CSS_UNIT_EM) {
- length = FMUL(length, font_size->value);
- unit = font_size->unit;
- } else if (unit == CSS_UNIT_EX) {
+ if (unit == CSS_UNIT_EX) {
length = FMUL(length, ex_size->value);
unit = ex_size->unit;
}
@@ -1119,14 +899,12 @@ css_error compute_absolute_length_normal(css_computed_style *style,
* Compute the absolute value of length pair
*
* \param style Style to process
- * \param font_size Absolute font size
- * \param ex_size Absolute ex size
+ * \param ex_size Ex size, in ems
* \param get Function to read length
* \param set Function to write length
* \return CSS_OK on success
*/
css_error compute_absolute_length_pair(css_computed_style *style,
- const css_hint_length *font_size,
const css_hint_length *ex_size,
uint8_t (*get)(const css_computed_style *style,
css_fixed *len1, css_unit *unit1,
@@ -1141,18 +919,12 @@ css_error compute_absolute_length_pair(css_computed_style *style,
type = get(style, &length1, &unit1, &length2, &unit2);
- if (unit1 == CSS_UNIT_EM) {
- length1 = FMUL(length1, font_size->value);
- unit1 = font_size->unit;
- } else if (unit1 == CSS_UNIT_EX) {
+ if (unit1 == CSS_UNIT_EX) {
length1 = FMUL(length1, ex_size->value);
unit1 = ex_size->unit;
}
- if (unit2 == CSS_UNIT_EM) {
- length2 = FMUL(length2, font_size->value);
- unit2 = font_size->unit;
- } else if (unit2 == CSS_UNIT_EX) {
+ if (unit2 == CSS_UNIT_EX) {
length2 = FMUL(length2, ex_size->value);
unit2 = ex_size->unit;
}
diff --git a/src/select/properties.c b/src/select/properties.c
index b62dcb1..02a607f 100644
--- a/src/select/properties.c
+++ b/src/select/properties.c
@@ -10,6 +10,7 @@
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/properties.h"
+#include "select/propget.h"
#include "select/propset.h"
#include "utils/utils.h"
@@ -193,10 +194,10 @@ css_error compose_background_attachment(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_background_attachment(child) ==
+ if (get_background_attachment(child) ==
CSS_BACKGROUND_ATTACHMENT_INHERIT) {
return set_background_attachment(result,
- css_computed_background_attachment(parent));
+ get_background_attachment(parent));
}
return CSS_OK;
@@ -226,9 +227,9 @@ css_error compose_background_color(const css_computed_style *parent,
{
css_color color;
- if (css_computed_background_color(child, &color) ==
+ if (get_background_color(child, &color) ==
CSS_BACKGROUND_COLOR_INHERIT) {
- uint8_t p = css_computed_background_color(parent, &color);
+ uint8_t p = get_background_color(parent, &color);
return set_background_color(result, p, color);
}
@@ -260,9 +261,9 @@ css_error compose_background_image(const css_computed_style *parent,
{
lwc_string *url;
- if (css_computed_background_image(child, &url) ==
+ if (get_background_image(child, &url) ==
CSS_BACKGROUND_IMAGE_INHERIT) {
- uint8_t p = css_computed_background_image(parent, &url);
+ uint8_t p = get_background_image(parent, &url);
return set_background_image(result, p, url);
}
@@ -359,9 +360,9 @@ css_error compose_background_position(const css_computed_style *parent,
css_fixed hlength = 0, vlength = 0;
css_unit hunit = CSS_UNIT_PX, vunit = CSS_UNIT_PX;
- if (css_computed_background_position(child, &hlength, &hunit,
+ if (get_background_position(child, &hlength, &hunit,
&vlength, &vunit) == CSS_BACKGROUND_POSITION_INHERIT) {
- uint8_t p = css_computed_background_position(parent,
+ uint8_t p = get_background_position(parent,
&hlength, &hunit, &vlength, &vunit);
return set_background_position(result, p, hlength, hunit,
@@ -420,7 +421,7 @@ css_error compose_background_repeat(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_background_repeat(child) ==
+ if (get_background_repeat(child) ==
CSS_BACKGROUND_REPEAT_INHERIT) {
return set_background_repeat(result,
css_computed_background_repeat(parent));
@@ -470,7 +471,7 @@ css_error compose_border_collapse(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_border_collapse(child) ==
+ if (get_border_collapse(child) ==
CSS_BORDER_COLLAPSE_INHERIT) {
return set_border_collapse(result,
css_computed_border_collapse(parent));
@@ -535,10 +536,10 @@ css_error compose_border_spacing(const css_computed_style *parent,
css_unit hunit = CSS_UNIT_PX, vunit = CSS_UNIT_PX;
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
- css_computed_border_spacing(child,
+ get_border_spacing(child,
&hlength, &hunit, &vlength, &vunit) ==
CSS_BORDER_SPACING_INHERIT) {
- uint8_t p = css_computed_border_spacing(parent,
+ uint8_t p = get_border_spacing(parent,
&hlength, &hunit, &vlength, &vunit);
return set_border_spacing(result, p, hlength, hunit,
@@ -571,9 +572,8 @@ css_error compose_border_top_color(const css_computed_style *parent,
{
css_color color;
- if (css_computed_border_top_color(child, &color) ==
- CSS_BORDER_COLOR_INHERIT) {
- uint8_t p = css_computed_border_top_color(parent, &color);
+ if (get_border_top_color(child, &color) == CSS_BORDER_COLOR_INHERIT) {
+ uint8_t p = get_border_top_color(parent, &color);
return set_border_top_color(result, p, color);
}
@@ -606,9 +606,8 @@ css_error compose_border_right_color(const css_computed_style *parent,
{
css_color color;
- if (css_computed_border_right_color(child, &color) ==
- CSS_BORDER_COLOR_INHERIT) {
- uint8_t p = css_computed_border_right_color(parent, &color);
+ if (get_border_right_color(child, &color) == CSS_BORDER_COLOR_INHERIT) {
+ uint8_t p = get_border_right_color(parent, &color);
return set_border_right_color(result, p, color);
}
@@ -641,9 +640,9 @@ css_error compose_border_bottom_color(const css_computed_style *parent,
{
css_color color;
- if (css_computed_border_bottom_color(child, &color) ==
+ if (get_border_bottom_color(child, &color) ==
CSS_BORDER_COLOR_INHERIT) {
- uint8_t p = css_computed_border_bottom_color(parent, &color);
+ uint8_t p = get_border_bottom_color(parent, &color);
return set_border_bottom_color(result, p, color);
}
@@ -676,9 +675,8 @@ css_error compose_border_left_color(const css_computed_style *parent,
{
css_color color;
- if (css_computed_border_left_color(child, &color) ==
- CSS_BORDER_COLOR_INHERIT) {
- uint8_t p = css_computed_border_left_color(parent, &color);
+ if (get_border_left_color(child, &color) == CSS_BORDER_COLOR_INHERIT) {
+ uint8_t p = get_border_left_color(parent, &color);
return set_border_left_color(result, p, color);
}
@@ -707,10 +705,9 @@ css_error compose_border_top_style(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_border_top_style(child) ==
- CSS_BORDER_STYLE_INHERIT) {
+ if (get_border_top_style(child) == CSS_BORDER_STYLE_INHERIT) {
return set_border_top_style(result,
- css_computed_border_top_style(parent));
+ get_border_top_style(parent));
}
return CSS_OK;
@@ -737,10 +734,9 @@ css_error compose_border_right_style(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_border_right_style(child) ==
- CSS_BORDER_STYLE_INHERIT) {
+ if (get_border_right_style(child) == CSS_BORDER_STYLE_INHERIT) {
return set_border_right_style(result,
- css_computed_border_right_style(parent));
+ get_border_right_style(parent));
}
return CSS_OK;
@@ -767,10 +763,9 @@ css_error compose_border_bottom_style(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_border_bottom_style(child) ==
- CSS_BORDER_STYLE_INHERIT) {
+ if (get_border_bottom_style(child) == CSS_BORDER_STYLE_INHERIT) {
return set_border_bottom_style(result,
- css_computed_border_bottom_style(parent));
+ get_border_bottom_style(parent));
}
return CSS_OK;
@@ -797,10 +792,9 @@ css_error compose_border_left_style(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_border_left_style(child) ==
- CSS_BORDER_STYLE_INHERIT) {
+ if (get_border_left_style(child) == CSS_BORDER_STYLE_INHERIT) {
return set_border_left_style(result,
- css_computed_border_left_style(parent));
+ get_border_left_style(parent));
}
return CSS_OK;
@@ -832,10 +826,9 @@ css_error compose_border_top_width(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_border_top_width(child, &length, &unit) ==
+ if (get_border_top_width(child, &length, &unit) ==
CSS_BORDER_WIDTH_INHERIT) {
- uint8_t p = css_computed_border_top_width(parent,
- &length, &unit);
+ uint8_t p = get_border_top_width(parent, &length, &unit);
return set_border_top_width(result, p, length, unit);
}
@@ -869,10 +862,9 @@ css_error compose_border_right_width(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_border_right_width(child, &length, &unit) ==
+ if (get_border_right_width(child, &length, &unit) ==
CSS_BORDER_WIDTH_INHERIT) {
- uint8_t p = css_computed_border_right_width(parent,
- &length, &unit);
+ uint8_t p = get_border_right_width(parent, &length, &unit);
return set_border_right_width(result, p, length, unit);
}
@@ -906,10 +898,9 @@ css_error compose_border_bottom_width(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_border_bottom_width(child, &length, &unit) ==
+ if (get_border_bottom_width(child, &length, &unit) ==
CSS_BORDER_WIDTH_INHERIT) {
- uint8_t p = css_computed_border_bottom_width(parent,
- &length, &unit);
+ uint8_t p = get_border_bottom_width(parent, &length, &unit);
return set_border_bottom_width(result, p, length, unit);
}
@@ -943,10 +934,9 @@ css_error compose_border_left_width(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_border_left_width(child, &length, &unit) ==
+ if (get_border_left_width(child, &length, &unit) ==
CSS_BORDER_WIDTH_INHERIT) {
- uint8_t p = css_computed_border_left_width(parent,
- &length, &unit);
+ uint8_t p = get_border_left_width(parent, &length, &unit);
return set_border_left_width(result, p, length, unit);
}
@@ -979,9 +969,8 @@ css_error compose_bottom(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_bottom(child, &length, &unit) ==
- CSS_BOTTOM_INHERIT) {
- uint8_t p = css_computed_bottom(parent, &length, &unit);
+ if (get_bottom(child, &length, &unit) == CSS_BOTTOM_INHERIT) {
+ uint8_t p = get_bottom(parent, &length, &unit);
return set_bottom(result, p, length, unit);
}
@@ -1030,10 +1019,8 @@ css_error compose_caption_side(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_caption_side(child) ==
- CSS_CAPTION_SIDE_INHERIT) {
- return set_caption_side(result,
- css_computed_caption_side(parent));
+ if (get_caption_side(child) == CSS_CAPTION_SIDE_INHERIT) {
+ return set_caption_side(result, get_caption_side(parent));
}
return CSS_OK;
@@ -1086,8 +1073,8 @@ css_error compose_clear(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_clear(child) == CSS_CLEAR_INHERIT) {
- return set_clear(result, css_computed_clear(parent));
+ if (get_clear(child) == CSS_CLEAR_INHERIT) {
+ return set_clear(result, get_clear(parent));
}
return CSS_OK;
@@ -1180,9 +1167,8 @@ css_error compose_clip(const css_computed_style *parent,
false, false, false, false };
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
- css_computed_clip(child, &rect) ==
- CSS_CLIP_INHERIT) {
- uint8_t p = css_computed_clip(parent, &rect);
+ get_clip(child, &rect) == CSS_CLIP_INHERIT) {
+ uint8_t p = get_clip(parent, &rect);
return set_clip(result, p, &rect);
}
@@ -1234,8 +1220,8 @@ css_error compose_color(const css_computed_style *parent,
{
css_color color;
- if (css_computed_color(child, &color) == CSS_COLOR_INHERIT) {
- uint8_t p = css_computed_color(parent, &color);
+ if (get_color(child, &color) == CSS_COLOR_INHERIT) {
+ uint8_t p = get_color(parent, &color);
return set_color(result, p, color);
}
@@ -1429,9 +1415,8 @@ css_error compose_content(const css_computed_style *parent,
const css_computed_content_item *items = NULL;
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
- css_computed_content(child, &items) ==
- CSS_CONTENT_INHERIT) {
- uint8_t p = css_computed_content(parent, &items);
+ get_content(child, &items) == CSS_CONTENT_INHERIT) {
+ uint8_t p = get_content(parent, &items);
size_t n_items = 0;
css_computed_content_item *copy = NULL;
@@ -1514,9 +1499,9 @@ css_error compose_counter_increment(const css_computed_style *parent,
const css_computed_counter *items = NULL;
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
- css_computed_counter_increment(child, &items) ==
+ get_counter_increment(child, &items) ==
CSS_COUNTER_INCREMENT_INHERIT) {
- uint8_t p = css_computed_counter_increment(parent, &items);
+ uint8_t p = get_counter_increment(parent, &items);
size_t n_items = 0;
css_computed_counter *copy = NULL;
@@ -1597,9 +1582,9 @@ css_error compose_counter_reset(const css_computed_style *parent,
const css_computed_counter *items = NULL;
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
- css_computed_counter_reset(child, &items) ==
+ get_counter_reset(child, &items) ==
CSS_COUNTER_RESET_INHERIT) {
- uint8_t p = css_computed_counter_reset(parent, &items);
+ uint8_t p = get_counter_reset(parent, &items);
size_t n_items = 0;
css_computed_counter *copy = NULL;
@@ -1866,9 +1851,8 @@ css_error compose_cursor(const css_computed_style *parent,
lwc_string **urls = NULL;
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
- css_computed_cursor(child, &urls) ==
- CSS_CURSOR_INHERIT) {
- uint8_t p = css_computed_cursor(parent, &urls);
+ get_cursor(child, &urls) == CSS_CURSOR_INHERIT) {
+ uint8_t p = get_cursor(parent, &urls);
size_t n_urls = 0;
lwc_string **copy = NULL;
@@ -1939,8 +1923,8 @@ css_error compose_direction(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_direction(child) == CSS_DIRECTION_INHERIT) {
- return set_direction(result, css_computed_direction(parent));
+ if (get_direction(child) == CSS_DIRECTION_INHERIT) {
+ return set_direction(result, get_direction(parent));
}
return CSS_OK;
@@ -2029,8 +2013,8 @@ css_error compose_display(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_display_static(child) == CSS_DISPLAY_INHERIT) {
- return set_display(result, css_computed_display_static(parent));
+ if (get_display_static(child) == CSS_DISPLAY_INHERIT) {
+ return set_display(result, get_display_static(parent));
}
return CSS_OK;
@@ -2142,9 +2126,8 @@ css_error compose_empty_cells(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_empty_cells(child) == CSS_EMPTY_CELLS_INHERIT) {
- return set_empty_cells(result,
- css_computed_empty_cells(parent));
+ if (get_empty_cells(child) == CSS_EMPTY_CELLS_INHERIT) {
+ return set_empty_cells(result, get_empty_cells(parent));
}
return CSS_OK;
@@ -2194,8 +2177,8 @@ css_error compose_float(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_float(child) == CSS_FLOAT_INHERIT) {
- return set_float(result, css_computed_float(parent));
+ if (get_float(child) == CSS_FLOAT_INHERIT) {
+ return set_float(result, get_float(parent));
}
return CSS_OK;
@@ -2355,8 +2338,8 @@ css_error compose_font_family(const css_computed_style *parent,
css_error error;
lwc_string **urls = NULL;
- if (css_computed_font_family(child, &urls) == CSS_FONT_FAMILY_INHERIT) {
- uint8_t p = css_computed_font_family(parent, &urls);
+ if (get_font_family(child, &urls) == CSS_FONT_FAMILY_INHERIT) {
+ uint8_t p = get_font_family(parent, &urls);
size_t n_urls = 0;
lwc_string **copy = NULL;
@@ -2464,9 +2447,8 @@ css_error compose_font_size(const css_computed_style *parent,
css_fixed size = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_font_size(child, &size, &unit) ==
- CSS_FONT_SIZE_INHERIT) {
- uint8_t p = css_computed_font_size(parent, &size, &unit);
+ if (get_font_size(child, &size, &unit) == CSS_FONT_SIZE_INHERIT) {
+ uint8_t p = get_font_size(parent, &size, &unit);
return set_font_size(result, p, size, unit);
}
@@ -2517,8 +2499,8 @@ css_error compose_font_style(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_font_style(child) == CSS_FONT_STYLE_INHERIT) {
- return set_font_style(result, css_computed_font_style(parent));
+ if (get_font_style(child) == CSS_FONT_STYLE_INHERIT) {
+ return set_font_style(result, get_font_style(parent));
}
return CSS_OK;
@@ -2565,9 +2547,8 @@ css_error compose_font_variant(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_font_variant(child) == CSS_FONT_VARIANT_INHERIT) {
- return set_font_variant(result,
- css_computed_font_variant(parent));
+ if (get_font_variant(child) == CSS_FONT_VARIANT_INHERIT) {
+ return set_font_variant(result, get_font_variant(parent));
}
return CSS_OK;
@@ -2647,9 +2628,8 @@ css_error compose_font_weight(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_font_weight(child) == CSS_FONT_WEIGHT_INHERIT) {
- return set_font_weight(result,
- css_computed_font_weight(parent));
+ if (get_font_weight(child) == CSS_FONT_WEIGHT_INHERIT) {
+ return set_font_weight(result, get_font_weight(parent));
}
return CSS_OK;
@@ -2680,9 +2660,8 @@ css_error compose_height(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_height(child, &length, &unit) ==
- CSS_HEIGHT_INHERIT) {
- uint8_t p = css_computed_height(parent, &length, &unit);
+ if (get_height(child, &length, &unit) == CSS_HEIGHT_INHERIT) {
+ uint8_t p = get_height(parent, &length, &unit);
return set_height(result, p, length, unit);
}
@@ -2715,9 +2694,8 @@ css_error compose_left(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_left(child, &length, &unit) ==
- CSS_LEFT_INHERIT) {
- uint8_t p = css_computed_left(parent, &length, &unit);
+ if (get_left(child, &length, &unit) == CSS_LEFT_INHERIT) {
+ uint8_t p = get_left(parent, &length, &unit);
return set_left(result, p, length, unit);
}
@@ -2752,9 +2730,9 @@ css_error compose_letter_spacing(const css_computed_style *parent,
css_unit unit = CSS_UNIT_PX;
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
- css_computed_letter_spacing(child, &length, &unit) ==
+ get_letter_spacing(child, &length, &unit) ==
CSS_LETTER_SPACING_INHERIT) {
- uint8_t p = css_computed_letter_spacing(parent, &length, &unit);
+ uint8_t p = get_letter_spacing(parent, &length, &unit);
return set_letter_spacing(result, p, length, unit);
}
@@ -2819,9 +2797,8 @@ css_error compose_line_height(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_line_height(child, &length, &unit) ==
- CSS_LINE_HEIGHT_INHERIT) {
- uint8_t p = css_computed_line_height(parent, &length, &unit);
+ if (get_line_height(child, &length, &unit) == CSS_LINE_HEIGHT_INHERIT) {
+ uint8_t p = get_line_height(parent, &length, &unit);
return set_line_height(result, p, length, unit);
}
@@ -2853,9 +2830,8 @@ css_error compose_list_style_image(const css_computed_style *parent,
{
lwc_string *url;
- if (css_computed_list_style_image(child, &url) ==
- CSS_LIST_STYLE_IMAGE_INHERIT) {
- uint8_t p = css_computed_list_style_image(parent, &url);
+ if (get_list_style_image(child, &url) == CSS_LIST_STYLE_IMAGE_INHERIT) {
+ uint8_t p = get_list_style_image(parent, &url);
return set_list_style_image(result, p, url);
}
@@ -2905,10 +2881,9 @@ css_error compose_list_style_position(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_list_style_position(child) ==
- CSS_LIST_STYLE_POSITION_INHERIT) {
+ if (get_list_style_position(child) == CSS_LIST_STYLE_POSITION_INHERIT) {
return set_list_style_position(result,
- css_computed_list_style_position(parent));
+ get_list_style_position(parent));
}
return CSS_OK;
@@ -2994,10 +2969,8 @@ css_error compose_list_style_type(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_list_style_type(child) ==
- CSS_LIST_STYLE_TYPE_INHERIT) {
- return set_list_style_type(result,
- css_computed_list_style_type(parent));
+ if (get_list_style_type(child) == CSS_LIST_STYLE_TYPE_INHERIT) {
+ return set_list_style_type(result, get_list_style_type(parent));
}
return CSS_OK;
@@ -3028,9 +3001,8 @@ css_error compose_margin_top(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_margin_top(child, &length, &unit) ==
- CSS_MARGIN_INHERIT) {
- uint8_t p = css_computed_margin_top(parent, &length, &unit);
+ if (get_margin_top(child, &length, &unit) == CSS_MARGIN_INHERIT) {
+ uint8_t p = get_margin_top(parent, &length, &unit);
return set_margin_top(result, p, length, unit);
}
@@ -3063,9 +3035,8 @@ css_error compose_margin_right(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_margin_right(child, &length, &unit) ==
- CSS_MARGIN_INHERIT) {
- uint8_t p = css_computed_margin_right(parent, &length, &unit);
+ if (get_margin_right(child, &length, &unit) == CSS_MARGIN_INHERIT) {
+ uint8_t p = get_margin_right(parent, &length, &unit);
return set_margin_right(result, p, length, unit);
}
@@ -3098,9 +3069,8 @@ css_error compose_margin_bottom(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_margin_bottom(child, &length, &unit) ==
- CSS_MARGIN_INHERIT) {
- uint8_t p = css_computed_margin_bottom(parent, &length, &unit);
+ if (get_margin_bottom(child, &length, &unit) == CSS_MARGIN_INHERIT) {
+ uint8_t p = get_margin_bottom(parent, &length, &unit);
return set_margin_bottom(result, p, length, unit);
}
@@ -3133,9 +3103,8 @@ css_error compose_margin_left(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_margin_left(child, &length, &unit) ==
- CSS_MARGIN_INHERIT) {
- uint8_t p = css_computed_margin_left(parent, &length, &unit);
+ if (get_margin_left(child, &length, &unit) == CSS_MARGIN_INHERIT) {
+ uint8_t p = get_margin_left(parent, &length, &unit);
return set_margin_left(result, p, length, unit);
}
@@ -3169,9 +3138,8 @@ css_error compose_max_height(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_max_height(child, &length, &unit) ==
- CSS_MAX_HEIGHT_INHERIT) {
- uint8_t p = css_computed_max_height(parent, &length, &unit);
+ if (get_max_height(child, &length, &unit) == CSS_MAX_HEIGHT_INHERIT) {
+ uint8_t p = get_max_height(parent, &length, &unit);
return set_max_height(result, p, length, unit);
}
@@ -3204,9 +3172,8 @@ css_error compose_max_width(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_max_width(child, &length, &unit) ==
- CSS_MAX_WIDTH_INHERIT) {
- uint8_t p = css_computed_max_width(parent, &length, &unit);
+ if (get_max_width(child, &length, &unit) == CSS_MAX_WIDTH_INHERIT) {
+ uint8_t p = get_max_width(parent, &length, &unit);
return set_max_width(result, p, length, unit);
}
@@ -3240,9 +3207,8 @@ css_error compose_min_height(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_min_height(child, &length, &unit) ==
- CSS_MIN_HEIGHT_INHERIT) {
- uint8_t p = css_computed_min_height(parent, &length, &unit);
+ if (get_min_height(child, &length, &unit) == CSS_MIN_HEIGHT_INHERIT) {
+ uint8_t p = get_min_height(parent, &length, &unit);
return set_min_height(result, p, length, unit);
}
@@ -3275,9 +3241,8 @@ css_error compose_min_width(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_min_width(child, &length, &unit) ==
- CSS_MIN_WIDTH_INHERIT) {
- uint8_t p = css_computed_min_width(parent, &length, &unit);
+ if (get_min_width(child, &length, &unit) == CSS_MIN_WIDTH_INHERIT) {
+ uint8_t p = get_min_width(parent, &length, &unit);
return set_min_width(result, p, length, unit);
}
@@ -3364,9 +3329,9 @@ css_error compose_outline_color(const css_computed_style *parent,
css_color color = 0;
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
- css_computed_outline_color(child, &color) ==
+ get_outline_color(child, &color) ==
CSS_OUTLINE_COLOR_INHERIT) {
- uint8_t p = css_computed_outline_color(parent, &color);
+ uint8_t p = get_outline_color(parent, &color);
return set_outline_color(result, p, color);
}
@@ -3395,9 +3360,8 @@ css_error compose_outline_style(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_outline_style(child) == CSS_OUTLINE_STYLE_INHERIT) {
- return set_outline_style(result,
- css_computed_outline_style(parent));
+ if (get_outline_style(child) == CSS_OUTLINE_STYLE_INHERIT) {
+ return set_outline_style(result, get_outline_style(parent));
}
return CSS_OK;
@@ -3430,9 +3394,9 @@ css_error compose_outline_width(const css_computed_style *parent,
css_unit unit = CSS_UNIT_PX;
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
- css_computed_outline_width(child, &length, &unit) ==
+ get_outline_width(child, &length, &unit) ==
CSS_OUTLINE_WIDTH_INHERIT) {
- uint8_t p = css_computed_outline_width(parent, &length, &unit);
+ uint8_t p = get_outline_width(parent, &length, &unit);
return set_outline_width(result, p, length, unit);
}
@@ -3487,8 +3451,8 @@ css_error compose_overflow(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_overflow(child) == CSS_OVERFLOW_INHERIT) {
- return set_overflow(result, css_computed_overflow(parent));
+ if (get_overflow(child) == CSS_OVERFLOW_INHERIT) {
+ return set_overflow(result, get_overflow(parent));
}
return CSS_OK;
@@ -3519,9 +3483,8 @@ css_error compose_padding_top(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_padding_top(child, &length, &unit) ==
- CSS_PADDING_INHERIT) {
- uint8_t p = css_computed_padding_top(parent, &length, &unit);
+ if (get_padding_top(child, &length, &unit) == CSS_PADDING_INHERIT) {
+ uint8_t p = get_padding_top(parent, &length, &unit);
return set_padding_top(result, p, length, unit);
}
@@ -3555,9 +3518,8 @@ css_error compose_padding_right(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_padding_right(child, &length, &unit) ==
- CSS_PADDING_INHERIT) {
- uint8_t p = css_computed_padding_right(parent, &length, &unit);
+ if (get_padding_right(child, &length, &unit) == CSS_PADDING_INHERIT) {
+ uint8_t p = get_padding_right(parent, &length, &unit);
return set_padding_right(result, p, length, unit);
}
@@ -3591,9 +3553,8 @@ css_error compose_padding_bottom(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_padding_bottom(child, &length, &unit) ==
- CSS_PADDING_INHERIT) {
- uint8_t p = css_computed_padding_bottom(parent, &length, &unit);
+ if (get_padding_bottom(child, &length, &unit) == CSS_PADDING_INHERIT) {
+ uint8_t p = get_padding_bottom(parent, &length, &unit);
return set_padding_bottom(result, p, length, unit);
}
@@ -3626,9 +3587,8 @@ css_error compose_padding_left(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_padding_left(child, &length, &unit) ==
- CSS_PADDING_INHERIT) {
- uint8_t p = css_computed_padding_left(parent, &length, &unit);
+ if (get_padding_left(child, &length, &unit) == CSS_PADDING_INHERIT) {
+ uint8_t p = get_padding_left(parent, &length, &unit);
return set_padding_left(result, p, length, unit);
}
@@ -4027,8 +3987,8 @@ css_error compose_position(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_position(child) == CSS_POSITION_INHERIT) {
- return set_position(result, css_computed_position(parent));
+ if (get_position(child) == CSS_POSITION_INHERIT) {
+ return set_position(result, get_position(parent));
}
return CSS_OK;
@@ -4158,8 +4118,8 @@ css_error compose_quotes(const css_computed_style *parent,
css_error error;
lwc_string **quotes = NULL;
- if (css_computed_quotes(child, &quotes) == CSS_QUOTES_INHERIT) {
- uint8_t p = css_computed_quotes(parent, &quotes);
+ if (get_quotes(child, &quotes) == CSS_QUOTES_INHERIT) {
+ uint8_t p = get_quotes(parent, &quotes);
size_t n_quotes = 0;
lwc_string **copy = NULL;
@@ -4248,9 +4208,8 @@ css_error compose_right(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_right(child, &length, &unit) ==
- CSS_RIGHT_INHERIT) {
- uint8_t p = css_computed_right(parent, &length, &unit);
+ if (get_right(child, &length, &unit) == CSS_RIGHT_INHERIT) {
+ uint8_t p = get_right(parent, &length, &unit);
return set_right(result, p, length, unit);
}
@@ -4603,9 +4562,8 @@ css_error compose_table_layout(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_table_layout(child) == CSS_TABLE_LAYOUT_INHERIT) {
- return set_table_layout(result,
- css_computed_table_layout(parent));
+ if (get_table_layout(child) == CSS_TABLE_LAYOUT_INHERIT) {
+ return set_table_layout(result, get_table_layout(parent));
}
return CSS_OK;
@@ -4658,8 +4616,8 @@ css_error compose_text_align(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_text_align(child) == CSS_TEXT_ALIGN_INHERIT) {
- return set_text_align(result, css_computed_text_align(parent));
+ if (get_text_align(child) == CSS_TEXT_ALIGN_INHERIT) {
+ return set_text_align(result, get_text_align(parent));
}
return CSS_OK;
@@ -4712,10 +4670,8 @@ css_error compose_text_decoration(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_text_decoration(child) ==
- CSS_TEXT_DECORATION_INHERIT) {
- return set_text_decoration(result,
- css_computed_text_decoration(parent));
+ if (get_text_decoration(child) == CSS_TEXT_DECORATION_INHERIT) {
+ return set_text_decoration(result, get_text_decoration(parent));
}
return CSS_OK;
@@ -4747,9 +4703,8 @@ css_error compose_text_indent(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_text_indent(child, &length, &unit) ==
- CSS_TEXT_INDENT_INHERIT) {
- uint8_t p = css_computed_text_indent(parent, &length, &unit);
+ if (get_text_indent(child, &length, &unit) == CSS_TEXT_INDENT_INHERIT) {
+ uint8_t p = get_text_indent(parent, &length, &unit);
return set_text_indent(result, p, length, unit);
}
@@ -4804,9 +4759,8 @@ css_error compose_text_transform(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_text_transform(child) == CSS_TEXT_TRANSFORM_INHERIT) {
- return set_text_transform(result,
- css_computed_text_transform(parent));
+ if (get_text_transform(child) == CSS_TEXT_TRANSFORM_INHERIT) {
+ return set_text_transform(result, get_text_transform(parent));
}
return CSS_OK;
@@ -4837,9 +4791,8 @@ css_error compose_top(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_top(child, &length, &unit) ==
- CSS_TOP_INHERIT) {
- uint8_t p = css_computed_top(parent, &length, &unit);
+ if (get_top(child, &length, &unit) == CSS_TOP_INHERIT) {
+ uint8_t p = get_top(parent, &length, &unit);
return set_top(result, p, length, unit);
}
@@ -4891,9 +4844,8 @@ css_error compose_unicode_bidi(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_unicode_bidi(child) == CSS_UNICODE_BIDI_INHERIT) {
- return set_unicode_bidi(result,
- css_computed_unicode_bidi(parent));
+ if (get_unicode_bidi(child) == CSS_UNICODE_BIDI_INHERIT) {
+ return set_unicode_bidi(result, get_unicode_bidi(parent));
}
return CSS_OK;
@@ -4973,9 +4925,9 @@ css_error compose_vertical_align(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_vertical_align(child, &length, &unit) ==
+ if (get_vertical_align(child, &length, &unit) ==
CSS_VERTICAL_ALIGN_INHERIT) {
- uint8_t p = css_computed_vertical_align(parent, &length, &unit);
+ uint8_t p = get_vertical_align(parent, &length, &unit);
return set_vertical_align(result, p, length, unit);
}
@@ -5027,8 +4979,8 @@ css_error compose_visibility(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_visibility(child) == CSS_VISIBILITY_INHERIT) {
- return set_visibility(result, css_computed_visibility(parent));
+ if (get_visibility(child) == CSS_VISIBILITY_INHERIT) {
+ return set_visibility(result, get_visibility(parent));
}
return CSS_OK;
@@ -5275,9 +5227,8 @@ css_error compose_white_space(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
- if (css_computed_white_space(child) == CSS_WHITE_SPACE_INHERIT) {
- return set_white_space(result,
- css_computed_white_space(parent));
+ if (get_white_space(child) == CSS_WHITE_SPACE_INHERIT) {
+ return set_white_space(result, get_white_space(parent));
}
return CSS_OK;
@@ -5342,8 +5293,8 @@ css_error compose_width(const css_computed_style *parent,
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
- if (css_computed_width(child, &length, &unit) == CSS_WIDTH_INHERIT) {
- uint8_t p = css_computed_width(parent, &length, &unit);
+ if (get_width(child, &length, &unit) == CSS_WIDTH_INHERIT) {
+ uint8_t p = get_width(parent, &length, &unit);
return set_width(result, p, length, unit);
}
@@ -5378,9 +5329,9 @@ css_error compose_word_spacing(const css_computed_style *parent,
css_unit unit = CSS_UNIT_PX;
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
- css_computed_word_spacing(child, &length, &unit) ==
+ get_word_spacing(child, &length, &unit) ==
CSS_WORD_SPACING_INHERIT) {
- uint8_t p = css_computed_word_spacing(parent, &length, &unit);
+ uint8_t p = get_word_spacing(parent, &length, &unit);
return set_word_spacing(result, p, length, unit);
}
@@ -5433,8 +5384,8 @@ css_error compose_z_index(const css_computed_style *parent,
{
int32_t index = 0;
- if (css_computed_z_index(child, &index) == CSS_Z_INDEX_INHERIT) {
- uint8_t p = css_computed_z_index(parent, &index);
+ if (get_z_index(child, &index) == CSS_Z_INDEX_INHERIT) {
+ uint8_t p = get_z_index(parent, &index);
return set_z_index(result, p, index);
}
diff --git a/src/select/propget.h b/src/select/propget.h
new file mode 100644
index 0000000..23c7cdf
--- /dev/null
+++ b/src/select/propget.h
@@ -0,0 +1,1724 @@
+/*
+ * This file is part of LibCSS
+ * Licensed under the MIT License,
+ * http://www.opensource.org/licenses/mit-license.php
+ * Copyright 2009 John-Mark Bell <jmb@netsurf-browser.org>
+ */
+
+#ifndef css_select_propget_h_
+#define css_select_propget_h_
+
+#include <libcss/computed.h>
+
+/* Important: keep this file in sync with computed.h */
+/** \todo Is there a better way to ensure this happens? */
+
+#define LETTER_SPACING_INDEX 0
+#define LETTER_SPACING_SHIFT 2
+#define LETTER_SPACING_MASK 0xfc
+static inline uint8_t get_letter_spacing(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ if (style->uncommon != NULL) {
+ uint8_t bits = style->uncommon->bits[LETTER_SPACING_INDEX];
+ bits &= LETTER_SPACING_MASK;
+ bits >>= LETTER_SPACING_SHIFT;
+
+ /* 6bits: uuuutt : unit | type */
+
+ if ((bits & 3) == CSS_LETTER_SPACING_SET) {
+ *length = style->uncommon->letter_spacing;
+ *unit = bits >> 2;
+ }
+
+ return (bits & 3);
+ }
+
+ return CSS_LETTER_SPACING_NORMAL;
+}
+#undef LETTER_SPACING_MASK
+#undef LETTER_SPACING_SHIFT
+#undef LETTER_SPACING_INDEX
+
+#define OUTLINE_COLOR_INDEX 0
+#define OUTLINE_COLOR_SHIFT 0
+#define OUTLINE_COLOR_MASK 0x3
+static inline uint8_t get_outline_color(
+ const css_computed_style *style, css_color *color)
+{
+ if (style->uncommon != NULL) {
+ uint8_t bits = style->uncommon->bits[OUTLINE_COLOR_INDEX];
+ bits &= OUTLINE_COLOR_MASK;
+ bits >>= OUTLINE_COLOR_SHIFT;
+
+ /* 2bits: tt : type */
+
+ if ((bits & 3) == CSS_OUTLINE_COLOR_COLOR) {
+ *color = style->uncommon->outline_color;
+ }
+
+ return (bits & 3);
+ }
+
+ return CSS_OUTLINE_COLOR_INVERT;
+}
+#undef OUTLINE_COLOR_MASK
+#undef OUTLINE_COLOR_SHIFT
+#undef OUTLINE_COLOR_INDEX
+
+#define OUTLINE_WIDTH_INDEX 1
+#define OUTLINE_WIDTH_SHIFT 1
+#define OUTLINE_WIDTH_MASK 0xfe
+static inline uint8_t get_outline_width(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ if (style->uncommon != NULL) {
+ uint8_t bits = style->uncommon->bits[OUTLINE_WIDTH_INDEX];
+ bits &= OUTLINE_WIDTH_MASK;
+ bits >>= OUTLINE_WIDTH_SHIFT;
+
+ /* 7bits: uuuuttt : unit | type */
+
+ if ((bits & 7) == CSS_OUTLINE_WIDTH_WIDTH) {
+ *length = style->uncommon->outline_width;
+ *unit = bits >> 3;
+ }
+
+ return (bits & 7);
+ }
+
+ *length = INTTOFIX(2);
+ *unit = CSS_UNIT_PX;
+
+ return CSS_OUTLINE_WIDTH_WIDTH;
+}
+#undef OUTLINE_WIDTH_MASK
+#undef OUTLINE_WIDTH_SHIFT
+#undef OUTLINE_WIDTH_INDEX
+
+#define BORDER_SPACING_INDEX 1
+#define BORDER_SPACING_SHIFT 0
+#define BORDER_SPACING_MASK 0x1
+#define BORDER_SPACING_INDEX1 2
+#define BORDER_SPACING_SHIFT1 0
+#define BORDER_SPACING_MASK1 0xff
+static inline uint8_t get_border_spacing(
+ const css_computed_style *style,
+ css_fixed *hlength, css_unit *hunit,
+ css_fixed *vlength, css_unit *vunit)
+{
+ if (style->uncommon != NULL) {
+ uint8_t bits = style->uncommon->bits[BORDER_SPACING_INDEX];
+ bits &= BORDER_SPACING_MASK;
+ bits >>= BORDER_SPACING_SHIFT;
+
+ /* 1 bit: type */
+ if (bits == CSS_BORDER_SPACING_SET) {
+ uint8_t bits1 =
+ style->uncommon->bits[BORDER_SPACING_INDEX1];
+ bits1 &= BORDER_SPACING_MASK1;
+ bits1 >>= BORDER_SPACING_SHIFT1;
+
+ /* 8bits: hhhhvvvv : hunit | vunit */
+
+ *hlength = style->uncommon->border_spacing[0];
+ *hunit = bits1 >> 4;
+
+ *vlength = style->uncommon->border_spacing[1];
+ *vunit = bits1 & 0xf;
+ }
+
+ return bits;
+ } else {
+ *hlength = *vlength = 0;
+ *hunit = *vunit = CSS_UNIT_PX;
+ }
+
+ return CSS_BORDER_SPACING_SET;
+}
+#undef BORDER_SPACING_MASK1
+#undef BORDER_SPACING_SHIFT1
+#undef BORDER_SPACING_INDEX1
+#undef BORDER_SPACING_MASK
+#undef BORDER_SPACING_SHIFT
+#undef BORDER_SPACING_INDEX
+
+#define WORD_SPACING_INDEX 3
+#define WORD_SPACING_SHIFT 2
+#define WORD_SPACING_MASK 0xfc
+static inline uint8_t get_word_spacing(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ if (style->uncommon != NULL) {
+ uint8_t bits = style->uncommon->bits[WORD_SPACING_INDEX];
+ bits &= WORD_SPACING_MASK;
+ bits >>= WORD_SPACING_SHIFT;
+
+ /* 6bits: uuuutt : unit | type */
+
+ if ((bits & 3) == CSS_WORD_SPACING_SET) {
+ *length = style->uncommon->word_spacing;
+ *unit = bits >> 2;
+ }
+
+ return (bits & 3);
+ }
+
+ return CSS_WORD_SPACING_NORMAL;
+}
+#undef WORD_SPACING_MASK
+#undef WORD_SPACING_SHIFT
+#undef WORD_SPACING_INDEX
+
+#define COUNTER_INCREMENT_INDEX 3
+#define COUNTER_INCREMENT_SHIFT 1
+#define COUNTER_INCREMENT_MASK 0x2
+static inline uint8_t get_counter_increment(
+ const css_computed_style *style,
+ const css_computed_counter **counters)
+{
+ if (style->uncommon != NULL) {
+ uint8_t bits = style->uncommon->bits[COUNTER_INCREMENT_INDEX];
+ bits &= COUNTER_INCREMENT_MASK;
+ bits >>= COUNTER_INCREMENT_SHIFT;
+
+ /* 1bit: type */
+ *counters = style->uncommon->counter_increment;
+
+ return bits;
+ }
+
+ return CSS_COUNTER_INCREMENT_NONE;
+}
+#undef COUNTER_INCREMENT_MASK
+#undef COUNTER_INCREMENT_SHIFT
+#undef COUNTER_INCREMENT_INDEX
+
+#define COUNTER_RESET_INDEX 3
+#define COUNTER_RESET_SHIFT 0
+#define COUNTER_RESET_MASK 0x1
+static inline uint8_t get_counter_reset(
+ const css_computed_style *style,
+ const css_computed_counter **counters)
+{
+ if (style->uncommon != NULL) {
+ uint8_t bits = style->uncommon->bits[COUNTER_RESET_INDEX];
+ bits &= COUNTER_RESET_MASK;
+ bits >>= COUNTER_RESET_SHIFT;
+
+ /* 1bit: type */
+ *counters = style->uncommon->counter_reset;
+
+ return bits;
+ }
+
+ return CSS_COUNTER_RESET_NONE;
+}
+#undef COUNTER_RESET_MASK
+#undef COUNTER_RESET_SHIFT
+#undef COUNTER_RESET_INDEX
+
+#define CURSOR_INDEX 4
+#define CURSOR_SHIFT 3
+#define CURSOR_MASK 0xf8
+static inline uint8_t get_cursor(
+ const css_computed_style *style,
+ lwc_string ***urls)
+{
+ if (style->uncommon != NULL) {
+ uint8_t bits = style->uncommon->bits[CURSOR_INDEX];
+ bits &= CURSOR_MASK;
+ bits >>= CURSOR_SHIFT;
+
+ /* 5bits: type */
+ *urls = style->uncommon->cursor;
+
+ return bits;
+ }
+
+ return CSS_CURSOR_AUTO;
+}
+#undef CURSOR_MASK
+#undef CURSOR_SHIFT
+#undef CURSOR_INDEX
+
+#define CLIP_INDEX 7
+#define CLIP_SHIFT 2
+#define CLIP_MASK 0xfc
+#define CLIP_INDEX1 5
+#define CLIP_SHIFT1 0
+#define CLIP_MASK1 0xff
+#define CLIP_INDEX2 6
+#define CLIP_SHIFT2 0
+#define CLIP_MASK2 0xff
+static inline uint8_t get_clip(
+ const css_computed_style *style,
+ css_computed_clip_rect *rect)
+{
+ if (style->uncommon != NULL) {
+ uint8_t bits = style->uncommon->bits[CLIP_INDEX];
+ bits &= CLIP_MASK;
+ bits >>= CLIP_SHIFT;
+
+ /* 6bits: trblyy : top | right | bottom | left | type */
+ if ((bits & 0x3) == CSS_CLIP_RECT) {
+ uint8_t bits1;
+
+ rect->left_auto = (bits & 0x4);
+ rect->bottom_auto = (bits & 0x8);
+ rect->right_auto = (bits & 0x10);
+ rect->top_auto = (bits & 0x20);
+
+ if (rect->top_auto == false ||
+ rect->right_auto == false) {
+ /* 8bits: ttttrrrr : top | right */
+ bits1 = style->uncommon->bits[CLIP_INDEX1];
+ bits1 &= CLIP_MASK1;
+ bits1 >>= CLIP_SHIFT1;
+ } else {
+ bits1 = 0;
+ }
+
+ rect->top = style->uncommon->clip[0];
+ rect->tunit = bits1 >> 4;
+
+ rect->right = style->uncommon->clip[1];
+ rect->runit = bits1 & 0xf;
+
+ if (rect->bottom_auto == false ||
+ rect->left_auto == false) {
+ /* 8bits: bbbbllll : bottom | left */
+ bits1 = style->uncommon->bits[CLIP_INDEX2];
+ bits1 &= CLIP_MASK2;
+ bits1 >>= CLIP_SHIFT2;
+ } else {
+ bits1 = 0;
+ }
+
+ rect->bottom = style->uncommon->clip[2];
+ rect->bunit = bits1 >> 4;
+
+ rect->left = style->uncommon->clip[3];
+ rect->lunit = bits1 & 0xf;
+ }
+
+ return (bits & 0x3);
+ }
+
+ return CSS_CLIP_AUTO;
+}
+#undef CLIP_MASK2
+#undef CLIP_SHIFT2
+#undef CLIP_INDEX2
+#undef CLIP_MASK1
+#undef CLIP_SHIFT1
+#undef CLIP_INDEX1
+#undef CLIP_MASK
+#undef CLIP_SHIFT
+#undef CLIP_INDEX
+
+#define CONTENT_INDEX 7
+#define CONTENT_SHIFT 0
+#define CONTENT_MASK 0x3
+static inline uint8_t get_content(
+ const css_computed_style *style,
+ const css_computed_content_item **content)
+{
+ if (style->uncommon != NULL) {
+ uint8_t bits = style->uncommon->bits[CONTENT_INDEX];
+ bits &= CONTENT_MASK;
+ bits >>= CONTENT_SHIFT;
+
+ /* 2bits: type */
+ *content = style->uncommon->content;
+
+ return bits;
+ }
+
+ return CSS_CONTENT_NORMAL;
+}
+#undef CONTENT_MASK
+#undef CONTENT_SHIFT
+#undef CONTENT_INDEX
+
+#define VERTICAL_ALIGN_INDEX 0
+#define VERTICAL_ALIGN_SHIFT 0
+#define VERTICAL_ALIGN_MASK 0xff
+static inline uint8_t get_vertical_align(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[VERTICAL_ALIGN_INDEX];
+ bits &= VERTICAL_ALIGN_MASK;
+ bits >>= VERTICAL_ALIGN_SHIFT;
+
+ /* 8bits: uuuutttt : units | type */
+ if ((bits & 0xf) == CSS_VERTICAL_ALIGN_SET) {
+ *length = style->vertical_align;
+ *unit = bits >> 4;
+ }
+
+ return (bits & 0xf);
+}
+#undef VERTICAL_ALIGN_MASK
+#undef VERTICAL_ALIGN_SHIFT
+#undef VERTICAL_ALIGN_INDEX
+
+#define FONT_SIZE_INDEX 1
+#define FONT_SIZE_SHIFT 0
+#define FONT_SIZE_MASK 0xff
+static inline uint8_t get_font_size(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[FONT_SIZE_INDEX];
+ bits &= FONT_SIZE_MASK;
+ bits >>= FONT_SIZE_SHIFT;
+
+ /* 8bits: uuuutttt : units | type */
+ if ((bits & 0xf) == CSS_FONT_SIZE_DIMENSION) {
+ *length = style->font_size;
+ *unit = bits >> 4;
+ }
+
+ return (bits & 0xf);
+}
+#undef FONT_SIZE_MASK
+#undef FONT_SIZE_SHIFT
+#undef FONT_SIZE_INDEX
+
+#define BORDER_TOP_WIDTH_INDEX 2
+#define BORDER_TOP_WIDTH_SHIFT 1
+#define BORDER_TOP_WIDTH_MASK 0xfe
+static inline uint8_t get_border_top_width(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[BORDER_TOP_WIDTH_INDEX];
+ bits &= BORDER_TOP_WIDTH_MASK;
+ bits >>= BORDER_TOP_WIDTH_SHIFT;
+
+ /* 7bits: uuuuttt : units | type */
+ if ((bits & 0x7) == CSS_BORDER_WIDTH_WIDTH) {
+ *length = style->border_width[0];
+ *unit = bits >> 3;
+ }
+
+ return (bits & 0x7);
+}
+#undef BORDER_TOP_WIDTH_MASK
+#undef BORDER_TOP_WIDTH_SHIFT
+#undef BORDER_TOP_WIDTH_INDEX
+
+#define BORDER_RIGHT_WIDTH_INDEX 3
+#define BORDER_RIGHT_WIDTH_SHIFT 1
+#define BORDER_RIGHT_WIDTH_MASK 0xfe
+static inline uint8_t get_border_right_width(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[BORDER_RIGHT_WIDTH_INDEX];
+ bits &= BORDER_RIGHT_WIDTH_MASK;
+ bits >>= BORDER_RIGHT_WIDTH_SHIFT;
+
+ /* 7bits: uuuuttt : units | type */
+ if ((bits & 0x7) == CSS_BORDER_WIDTH_WIDTH) {
+ *length = style->border_width[1];
+ *unit = bits >> 3;
+ }
+
+ return (bits & 0x7);
+}
+#undef BORDER_RIGHT_WIDTH_MASK
+#undef BORDER_RIGHT_WIDTH_SHIFT
+#undef BORDER_RIGHT_WIDTH_INDEX
+
+#define BORDER_BOTTOM_WIDTH_INDEX 4
+#define BORDER_BOTTOM_WIDTH_SHIFT 1
+#define BORDER_BOTTOM_WIDTH_MASK 0xfe
+static inline uint8_t get_border_bottom_width(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[BORDER_BOTTOM_WIDTH_INDEX];
+ bits &= BORDER_BOTTOM_WIDTH_MASK;
+ bits >>= BORDER_BOTTOM_WIDTH_SHIFT;
+
+ /* 7bits: uuuuttt : units | type */
+ if ((bits & 0x7) == CSS_BORDER_WIDTH_WIDTH) {
+ *length = style->border_width[2];
+ *unit = bits >> 3;
+ }
+
+ return (bits & 0x7);
+}
+#undef BORDER_BOTTOM_WIDTH_MASK
+#undef BORDER_BOTTOM_WIDTH_SHIFT
+#undef BORDER_BOTTOM_WIDTH_INDEX
+
+#define BORDER_LEFT_WIDTH_INDEX 5
+#define BORDER_LEFT_WIDTH_SHIFT 1
+#define BORDER_LEFT_WIDTH_MASK 0xfe
+static inline uint8_t get_border_left_width(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[BORDER_LEFT_WIDTH_INDEX];
+ bits &= BORDER_LEFT_WIDTH_MASK;
+ bits >>= BORDER_LEFT_WIDTH_SHIFT;
+
+ /* 7bits: uuuuttt : units | type */
+ if ((bits & 0x7) == CSS_BORDER_WIDTH_WIDTH) {
+ *length = style->border_width[3];
+ *unit = bits >> 3;
+ }
+
+ return (bits & 0x7);
+}
+#undef BORDER_LEFT_WIDTH_MASK
+#undef BORDER_LEFT_WIDTH_SHIFT
+#undef BORDER_LEFT_WIDTH_INDEX
+
+#define BACKGROUND_IMAGE_INDEX 2
+#define BACKGROUND_IMAGE_SHIFT 0
+#define BACKGROUND_IMAGE_MASK 0x1
+static inline uint8_t get_background_image(
+ const css_computed_style *style,
+ lwc_string **url)
+{
+ uint8_t bits = style->bits[BACKGROUND_IMAGE_INDEX];
+ bits &= BACKGROUND_IMAGE_MASK;
+ bits >>= BACKGROUND_IMAGE_SHIFT;
+
+ /* 1bit: type */
+ *url = style->background_image;
+
+ return bits;
+}
+#undef BACKGROUND_IMAGE_MASK
+#undef BACKGROUND_IMAGE_SHIFT
+#undef BACKGROUND_IMAGE_INDEX
+
+#define COLOR_INDEX 3
+#define COLOR_SHIFT 0
+#define COLOR_MASK 0x1
+static inline uint8_t get_color(
+ const css_computed_style *style,
+ css_color *color)
+{
+ uint8_t bits = style->bits[COLOR_INDEX];
+ bits &= COLOR_MASK;
+ bits >>= COLOR_SHIFT;
+
+ /* 1bit: type */
+ *color = style->color;
+
+ return bits;
+}
+#undef COLOR_MASK
+#undef COLOR_SHIFT
+#undef COLOR_INDEX
+
+#define LIST_STYLE_IMAGE_INDEX 4
+#define LIST_STYLE_IMAGE_SHIFT 0
+#define LIST_STYLE_IMAGE_MASK 0x1
+static inline uint8_t get_list_style_image(
+ const css_computed_style *style,
+ lwc_string **url)
+{
+ uint8_t bits = style->bits[LIST_STYLE_IMAGE_INDEX];
+ bits &= LIST_STYLE_IMAGE_MASK;
+ bits >>= LIST_STYLE_IMAGE_SHIFT;
+
+ /* 1bit: type */
+ *url = style->list_style_image;
+
+ return bits;
+}
+#undef LIST_STYLE_IMAGE_MASK
+#undef LIST_STYLE_IMAGE_SHIFT
+#undef LIST_STYLE_IMAGE_INDEX
+
+#define QUOTES_INDEX 5
+#define QUOTES_SHIFT 0
+#define QUOTES_MASK 0x1
+static inline uint8_t get_quotes(
+ const css_computed_style *style,
+ lwc_string ***quotes)
+{
+ uint8_t bits = style->bits[QUOTES_INDEX];
+ bits &= QUOTES_MASK;
+ bits >>= QUOTES_SHIFT;
+
+ /* 1bit: type */
+ *quotes = style->quotes;
+
+ return bits;
+}
+#undef QUOTES_MASK
+#undef QUOTES_SHIFT
+#undef QUOTES_INDEX
+
+#define TOP_INDEX 6
+#define TOP_SHIFT 2
+#define TOP_MASK 0xfc
+static inline uint8_t get_top(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[TOP_INDEX];
+ bits &= TOP_MASK;
+ bits >>= TOP_SHIFT;
+
+ /* 6bits: uuuutt : units | type */
+ if ((bits & 0x3) == CSS_TOP_SET) {
+ *length = style->top;
+ *unit = bits >> 2;
+ }
+
+ return (bits & 0x3);
+}
+#undef TOP_MASK
+#undef TOP_SHIFT
+#undef TOP_INDEX
+
+#define RIGHT_INDEX 7
+#define RIGHT_SHIFT 2
+#define RIGHT_MASK 0xfc
+static inline uint8_t get_right(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[RIGHT_INDEX];
+ bits &= RIGHT_MASK;
+ bits >>= RIGHT_SHIFT;
+
+ /* 6bits: uuuutt : units | type */
+ if ((bits & 0x3) == CSS_RIGHT_SET) {
+ *length = style->right;
+ *unit = bits >> 2;
+ }
+
+ return (bits & 0x3);
+}
+#undef RIGHT_MASK
+#undef RIGHT_SHIFT
+#undef RIGHT_INDEX
+
+#define BOTTOM_INDEX 8
+#define BOTTOM_SHIFT 2
+#define BOTTOM_MASK 0xfc
+static inline uint8_t get_bottom(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[BOTTOM_INDEX];
+ bits &= BOTTOM_MASK;
+ bits >>= BOTTOM_SHIFT;
+
+ /* 6bits: uuuutt : units | type */
+ if ((bits & 0x3) == CSS_BOTTOM_SET) {
+ *length = style->bottom;
+ *unit = bits >> 2;
+ }
+
+ return (bits & 0x3);
+}
+#undef BOTTOM_MASK
+#undef BOTTOM_SHIFT
+#undef BOTTOM_INDEX
+
+#define LEFT_INDEX 9
+#define LEFT_SHIFT 2
+#define LEFT_MASK 0xfc
+static inline uint8_t get_left(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[LEFT_INDEX];
+ bits &= LEFT_MASK;
+ bits >>= LEFT_SHIFT;
+
+ /* 6bits: uuuutt : units | type */
+ if ((bits & 0x3) == CSS_LEFT_SET) {
+ *length = style->left;
+ *unit = bits >> 2;
+ }
+
+ return (bits & 0x3);
+}
+#undef LEFT_MASK
+#undef LEFT_SHIFT
+#undef LEFT_INDEX
+
+#define BORDER_TOP_COLOR_INDEX 6
+#define BORDER_TOP_COLOR_SHIFT 0
+#define BORDER_TOP_COLOR_MASK 0x3
+static inline uint8_t get_border_top_color(
+ const css_computed_style *style,
+ css_color *color)
+{
+ uint8_t bits = style->bits[BORDER_TOP_COLOR_INDEX];
+ bits &= BORDER_TOP_COLOR_MASK;
+ bits >>= BORDER_TOP_COLOR_SHIFT;
+
+ /* 2bits: type */
+ *color = style->border_color[0];
+
+ return bits;
+}
+#undef BORDER_TOP_COLOR_MASK
+#undef BORDER_TOP_COLOR_SHIFT
+#undef BORDER_TOP_COLOR_INDEX
+
+#define BORDER_RIGHT_COLOR_INDEX 7
+#define BORDER_RIGHT_COLOR_SHIFT 0
+#define BORDER_RIGHT_COLOR_MASK 0x3
+static inline uint8_t get_border_right_color(
+ const css_computed_style *style,
+ css_color *color)
+{
+ uint8_t bits = style->bits[BORDER_RIGHT_COLOR_INDEX];
+ bits &= BORDER_RIGHT_COLOR_MASK;
+ bits >>= BORDER_RIGHT_COLOR_SHIFT;
+
+ /* 2bits: type */
+ *color = style->border_color[1];
+
+ return bits;
+}
+#undef BORDER_RIGHT_COLOR_MASK
+#undef BORDER_RIGHT_COLOR_SHIFT
+#undef BORDER_RIGHT_COLOR_INDEX
+
+#define BORDER_BOTTOM_COLOR_INDEX 8
+#define BORDER_BOTTOM_COLOR_SHIFT 0
+#define BORDER_BOTTOM_COLOR_MASK 0x3
+static inline uint8_t get_border_bottom_color(
+ const css_computed_style *style,
+ css_color *color)
+{
+ uint8_t bits = style->bits[BORDER_BOTTOM_COLOR_INDEX];
+ bits &= BORDER_BOTTOM_COLOR_MASK;
+ bits >>= BORDER_BOTTOM_COLOR_SHIFT;
+
+ /* 2bits: type */
+ *color = style->border_color[2];
+
+ return bits;
+}
+#undef BORDER_BOTTOM_COLOR_MASK
+#undef BORDER_BOTTOM_COLOR_SHIFT
+#undef BORDER_BOTTOM_COLOR_INDEX
+
+#define BORDER_LEFT_COLOR_INDEX 9
+#define BORDER_LEFT_COLOR_SHIFT 0
+#define BORDER_LEFT_COLOR_MASK 0x3
+static inline uint8_t get_border_left_color(
+ const css_computed_style *style,
+ css_color *color)
+{
+ uint8_t bits = style->bits[BORDER_LEFT_COLOR_INDEX];
+ bits &= BORDER_LEFT_COLOR_MASK;
+ bits >>= BORDER_LEFT_COLOR_SHIFT;
+
+ /* 2bits: type */
+ *color = style->border_color[3];
+
+ return bits;
+}
+#undef BORDER_LEFT_COLOR_MASK
+#undef BORDER_LEFT_COLOR_SHIFT
+#undef BORDER_LEFT_COLOR_INDEX
+
+#define HEIGHT_INDEX 10
+#define HEIGHT_SHIFT 2
+#define HEIGHT_MASK 0xfc
+static inline uint8_t get_height(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[HEIGHT_INDEX];
+ bits &= HEIGHT_MASK;
+ bits >>= HEIGHT_SHIFT;
+
+ /* 6bits: uuuutt : units | type */
+ if ((bits & 0x3) == CSS_HEIGHT_SET) {
+ *length = style->height;
+ *unit = bits >> 2;
+ }
+
+ return (bits & 0x3);
+}
+#undef HEIGHT_MASK
+#undef HEIGHT_SHIFT
+#undef HEIGHT_INDEX
+
+#define LINE_HEIGHT_INDEX 11
+#define LINE_HEIGHT_SHIFT 2
+#define LINE_HEIGHT_MASK 0xfc
+static inline uint8_t get_line_height(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[LINE_HEIGHT_INDEX];
+ bits &= LINE_HEIGHT_MASK;
+ bits >>= LINE_HEIGHT_SHIFT;
+
+ /* 6bits: uuuutt : units | type */
+ if ((bits & 0x3) == CSS_LINE_HEIGHT_NUMBER ||
+ (bits & 0x3) == CSS_LINE_HEIGHT_DIMENSION) {
+ *length = style->line_height;
+ }
+
+ if ((bits & 0x3) == CSS_LINE_HEIGHT_DIMENSION) {
+ *unit = bits >> 2;
+ }
+
+ return (bits & 0x3);
+}
+#undef LINE_HEIGHT_MASK
+#undef LINE_HEIGHT_SHIFT
+#undef LINE_HEIGHT_INDEX
+
+#define BACKGROUND_COLOR_INDEX 10
+#define BACKGROUND_COLOR_SHIFT 0
+#define BACKGROUND_COLOR_MASK 0x3
+static inline uint8_t get_background_color(
+ const css_computed_style *style,
+ css_color *color)
+{
+ uint8_t bits = style->bits[BACKGROUND_COLOR_INDEX];
+ bits &= BACKGROUND_COLOR_MASK;
+ bits >>= BACKGROUND_COLOR_SHIFT;
+
+ /* 2bits: type */
+ *color = style->background_color;
+
+ return bits;
+}
+#undef BACKGROUND_COLOR_MASK
+#undef BACKGROUND_COLOR_SHIFT
+#undef BACKGROUND_COLOR_INDEX
+
+#define Z_INDEX_INDEX 11
+#define Z_INDEX_SHIFT 0
+#define Z_INDEX_MASK 0x3
+static inline uint8_t get_z_index(
+ const css_computed_style *style,
+ int32_t *z_index)
+{
+ uint8_t bits = style->bits[Z_INDEX_INDEX];
+ bits &= Z_INDEX_MASK;
+ bits >>= Z_INDEX_SHIFT;
+
+ /* 2bits: type */
+ *z_index = style->z_index;
+
+ return bits;
+}
+#undef Z_INDEX_MASK
+#undef Z_INDEX_SHIFT
+#undef Z_INDEX_INDEX
+
+#define MARGIN_TOP_INDEX 12
+#define MARGIN_TOP_SHIFT 2
+#define MARGIN_TOP_MASK 0xfc
+static inline uint8_t get_margin_top(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[MARGIN_TOP_INDEX];
+ bits &= MARGIN_TOP_MASK;
+ bits >>= MARGIN_TOP_SHIFT;
+
+ /* 6bits: uuuutt : units | type */
+ if ((bits & 0x3) == CSS_MARGIN_SET) {
+ *length = style->margin[0];
+ *unit = bits >> 2;
+ }
+
+ return (bits & 0x3);
+}
+#undef MARGIN_TOP_MASK
+#undef MARGIN_TOP_SHIFT
+#undef MARGIN_TOP_INDEX
+
+#define MARGIN_RIGHT_INDEX 13
+#define MARGIN_RIGHT_SHIFT 2
+#define MARGIN_RIGHT_MASK 0xfc
+static inline uint8_t get_margin_right(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[MARGIN_RIGHT_INDEX];
+ bits &= MARGIN_RIGHT_MASK;
+ bits >>= MARGIN_RIGHT_SHIFT;
+
+ /* 6bits: uuuutt : units | type */
+ if ((bits & 0x3) == CSS_MARGIN_SET) {
+ *length = style->margin[1];
+ *unit = bits >> 2;
+ }
+
+ return (bits & 0x3);
+}
+#undef MARGIN_RIGHT_MASK
+#undef MARGIN_RIGHT_SHIFT
+#undef MARGIN_RIGHT_INDEX
+
+#define MARGIN_BOTTOM_INDEX 14
+#define MARGIN_BOTTOM_SHIFT 2
+#define MARGIN_BOTTOM_MASK 0xfc
+static inline uint8_t get_margin_bottom(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[MARGIN_BOTTOM_INDEX];
+ bits &= MARGIN_BOTTOM_MASK;
+ bits >>= MARGIN_BOTTOM_SHIFT;
+
+ /* 6bits: uuuutt : units | type */
+ if ((bits & 0x3) == CSS_MARGIN_SET) {
+ *length = style->margin[2];
+ *unit = bits >> 2;
+ }
+
+ return (bits & 0x3);
+}
+#undef MARGIN_BOTTOM_MASK
+#undef MARGIN_BOTTOM_SHIFT
+#undef MARGIN_BOTTOM_INDEX
+
+#define MARGIN_LEFT_INDEX 15
+#define MARGIN_LEFT_SHIFT 2
+#define MARGIN_LEFT_MASK 0xfc
+static inline uint8_t get_margin_left(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[MARGIN_LEFT_INDEX];
+ bits &= MARGIN_LEFT_MASK;
+ bits >>= MARGIN_LEFT_SHIFT;
+
+ /* 6bits: uuuutt : units | type */
+ if ((bits & 0x3) == CSS_MARGIN_SET) {
+ *length = style->margin[3];
+ *unit = bits >> 2;
+ }
+
+ return (bits & 0x3);
+}
+#undef MARGIN_LEFT_MASK
+#undef MARGIN_LEFT_SHIFT
+#undef MARGIN_LEFT_INDEX
+
+#define BACKGROUND_ATTACHMENT_INDEX 12
+#define BACKGROUND_ATTACHMENT_SHIFT 0
+#define BACKGROUND_ATTACHMENT_MASK 0x3
+static inline uint8_t get_background_attachment(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[BACKGROUND_ATTACHMENT_INDEX];
+ bits &= BACKGROUND_ATTACHMENT_MASK;
+ bits >>= BACKGROUND_ATTACHMENT_SHIFT;
+
+ /* 2bits: type */
+ return bits;
+}
+#undef BACKGROUND_ATTACHMENT_MASK
+#undef BACKGROUND_ATTACHMENT_SHIFT
+#undef BACKGROUND_ATTACHMENT_INDEX
+
+#define BORDER_COLLAPSE_INDEX 13
+#define BORDER_COLLAPSE_SHIFT 0
+#define BORDER_COLLAPSE_MASK 0x3
+static inline uint8_t get_border_collapse(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[BORDER_COLLAPSE_INDEX];
+ bits &= BORDER_COLLAPSE_MASK;
+ bits >>= BORDER_COLLAPSE_SHIFT;
+
+ /* 2bits: type */
+ return bits;
+}
+#undef BORDER_COLLAPSE_MASK
+#undef BORDER_COLLAPSE_SHIFT
+#undef BORDER_COLLAPSE_INDEX
+
+#define CAPTION_SIDE_INDEX 14
+#define CAPTION_SIDE_SHIFT 0
+#define CAPTION_SIDE_MASK 0x3
+static inline uint8_t get_caption_side(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[CAPTION_SIDE_INDEX];
+ bits &= CAPTION_SIDE_MASK;
+ bits >>= CAPTION_SIDE_SHIFT;
+
+ /* 2bits: type */
+ return bits;
+}
+#undef CAPTION_SIDE_MASK
+#undef CAPTION_SIDE_SHIFT
+#undef CAPTION_SIDE_INDEX
+
+#define DIRECTION_INDEX 15
+#define DIRECTION_SHIFT 0
+#define DIRECTION_MASK 0x3
+static inline uint8_t get_direction(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[DIRECTION_INDEX];
+ bits &= DIRECTION_MASK;
+ bits >>= DIRECTION_SHIFT;
+
+ /* 2bits: type */
+ return bits;
+}
+#undef DIRECTION_MASK
+#undef DIRECTION_SHIFT
+#undef DIRECTION_INDEX
+
+#define MAX_HEIGHT_INDEX 16
+#define MAX_HEIGHT_SHIFT 2
+#define MAX_HEIGHT_MASK 0xfc
+static inline uint8_t get_max_height(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[MAX_HEIGHT_INDEX];
+ bits &= MAX_HEIGHT_MASK;
+ bits >>= MAX_HEIGHT_SHIFT;
+
+ /* 6bits: uuuutt : units | type */
+ if ((bits & 0x3) == CSS_MAX_HEIGHT_SET) {
+ *length = style->max_height;
+ *unit = bits >> 2;
+ }
+
+ return (bits & 0x3);
+}
+#undef MAX_HEIGHT_MASK
+#undef MAX_HEIGHT_SHIFT
+#undef MAX_HEIGHT_INDEX
+
+#define MAX_WIDTH_INDEX 17
+#define MAX_WIDTH_SHIFT 2
+#define MAX_WIDTH_MASK 0xfc
+static inline uint8_t get_max_width(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[MAX_WIDTH_INDEX];
+ bits &= MAX_WIDTH_MASK;
+ bits >>= MAX_WIDTH_SHIFT;
+
+ /* 6bits: uuuutt : units | type */
+ if ((bits & 0x3) == CSS_MAX_WIDTH_SET) {
+ *length = style->max_width;
+ *unit = bits >> 2;
+ }
+
+ return (bits & 0x3);
+}
+#undef MAX_WIDTH_MASK
+#undef MAX_WIDTH_SHIFT
+#undef MAX_WIDTH_INDEX
+
+#define WIDTH_INDEX 18
+#define WIDTH_SHIFT 2
+#define WIDTH_MASK 0xfc
+static inline uint8_t get_width(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[WIDTH_INDEX];
+ bits &= WIDTH_MASK;
+ bits >>= WIDTH_SHIFT;
+
+ /* 6bits: uuuutt : units | type */
+ if ((bits & 0x3) == CSS_WIDTH_SET) {
+ *length = style->width;
+ *unit = bits >> 2;
+ }
+
+ return (bits & 0x3);
+}
+#undef WIDTH_MASK
+#undef WIDTH_SHIFT
+#undef WIDTH_INDEX
+
+#define EMPTY_CELLS_INDEX 16
+#define EMPTY_CELLS_SHIFT 0
+#define EMPTY_CELLS_MASK 0x3
+static inline uint8_t get_empty_cells(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[EMPTY_CELLS_INDEX];
+ bits &= EMPTY_CELLS_MASK;
+ bits >>= EMPTY_CELLS_SHIFT;
+
+ /* 2bits: type */
+ return bits;
+}
+#undef EMPTY_CELLS_MASK
+#undef EMPTY_CELLS_SHIFT
+#undef EMPTY_CELLS_INDEX
+
+#define FLOAT_INDEX 17
+#define FLOAT_SHIFT 0
+#define FLOAT_MASK 0x3
+static inline uint8_t get_float(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[FLOAT_INDEX];
+ bits &= FLOAT_MASK;
+ bits >>= FLOAT_SHIFT;
+
+ /* 2bits: type */
+ return bits;
+}
+#undef FLOAT_MASK
+#undef FLOAT_SHIFT
+#undef FLOAT_INDEX
+
+#define FONT_STYLE_INDEX 18
+#define FONT_STYLE_SHIFT 0
+#define FONT_STYLE_MASK 0x3
+static inline uint8_t get_font_style(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[FONT_STYLE_INDEX];
+ bits &= FONT_STYLE_MASK;
+ bits >>= FONT_STYLE_SHIFT;
+
+ /* 2bits: type */
+ return bits;
+}
+#undef FONT_STYLE_MASK
+#undef FONT_STYLE_SHIFT
+#undef FONT_STYLE_INDEX
+
+#define MIN_HEIGHT_INDEX 19
+#define MIN_HEIGHT_SHIFT 3
+#define MIN_HEIGHT_MASK 0xf8
+static inline uint8_t get_min_height(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[MIN_HEIGHT_INDEX];
+ bits &= MIN_HEIGHT_MASK;
+ bits >>= MIN_HEIGHT_SHIFT;
+
+ /* 5bits: uuuut : units | type */
+ if ((bits & 0x1) == CSS_MIN_HEIGHT_SET) {
+ *length = style->min_height;
+ *unit = bits >> 1;
+ }
+
+ return (bits & 0x1);
+}
+#undef MIN_HEIGHT_MASK
+#undef MIN_HEIGHT_SHIFT
+#undef MIN_HEIGHT_INDEX
+
+#define MIN_WIDTH_INDEX 20
+#define MIN_WIDTH_SHIFT 3
+#define MIN_WIDTH_MASK 0xf8
+static inline uint8_t get_min_width(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[MIN_WIDTH_INDEX];
+ bits &= MIN_WIDTH_MASK;
+ bits >>= MIN_WIDTH_SHIFT;
+
+ /* 5bits: uuuut : units | type */
+ if ((bits & 0x1) == CSS_MIN_WIDTH_SET) {
+ *length = style->min_width;
+ *unit = bits >> 1;
+ }
+
+ return (bits & 0x1);
+}
+#undef MIN_WIDTH_MASK
+#undef MIN_WIDTH_SHIFT
+#undef MIN_WIDTH_INDEX
+
+#define BACKGROUND_REPEAT_INDEX 19
+#define BACKGROUND_REPEAT_SHIFT 0
+#define BACKGROUND_REPEAT_MASK 0x7
+static inline uint8_t get_background_repeat(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[BACKGROUND_REPEAT_INDEX];
+ bits &= BACKGROUND_REPEAT_MASK;
+ bits >>= BACKGROUND_REPEAT_SHIFT;
+
+ /* 3bits: type */
+ return bits;
+}
+#undef BACKGROUND_REPEAT_MASK
+#undef BACKGROUND_REPEAT_SHIFT
+#undef BACKGROUND_REPEAT_INDEX
+
+#define CLEAR_INDEX 20
+#define CLEAR_SHIFT 0
+#define CLEAR_MASK 0x7
+static inline uint8_t get_clear(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[CLEAR_INDEX];
+ bits &= CLEAR_MASK;
+ bits >>= CLEAR_SHIFT;
+
+ /* 3bits: type */
+ return bits;
+}
+#undef CLEAR_MASK
+#undef CLEAR_SHIFT
+#undef CLEAR_INDEX
+
+#define PADDING_TOP_INDEX 21
+#define PADDING_TOP_SHIFT 3
+#define PADDING_TOP_MASK 0xf8
+static inline uint8_t get_padding_top(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[PADDING_TOP_INDEX];
+ bits &= PADDING_TOP_MASK;
+ bits >>= PADDING_TOP_SHIFT;
+
+ /* 5bits: uuuut : units | type */
+ if ((bits & 0x1) == CSS_PADDING_SET) {
+ *length = style->padding[0];
+ *unit = bits >> 1;
+ }
+
+ return (bits & 0x1);
+}
+#undef PADDING_TOP_MASK
+#undef PADDING_TOP_SHIFT
+#undef PADDING_TOP_INDEX
+
+#define PADDING_RIGHT_INDEX 22
+#define PADDING_RIGHT_SHIFT 3
+#define PADDING_RIGHT_MASK 0xf8
+static inline uint8_t get_padding_right(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[PADDING_RIGHT_INDEX];
+ bits &= PADDING_RIGHT_MASK;
+ bits >>= PADDING_RIGHT_SHIFT;
+
+ /* 5bits: uuuut : units | type */
+ if ((bits & 0x1) == CSS_PADDING_SET) {
+ *length = style->padding[1];
+ *unit = bits >> 1;
+ }
+
+ return (bits & 0x1);
+}
+#undef PADDING_RIGHT_MASK
+#undef PADDING_RIGHT_SHIFT
+#undef PADDING_RIGHT_INDEX
+
+#define PADDING_BOTTOM_INDEX 23
+#define PADDING_BOTTOM_SHIFT 3
+#define PADDING_BOTTOM_MASK 0xf8
+static inline uint8_t get_padding_bottom(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[PADDING_BOTTOM_INDEX];
+ bits &= PADDING_BOTTOM_MASK;
+ bits >>= PADDING_BOTTOM_SHIFT;
+
+ /* 5bits: uuuut : units | type */
+ if ((bits & 0x1) == CSS_PADDING_SET) {
+ *length = style->padding[2];
+ *unit = bits >> 1;
+ }
+
+ return (bits & 0x1);
+}
+#undef PADDING_BOTTOM_MASK
+#undef PADDING_BOTTOM_SHIFT
+#undef PADDING_BOTTOM_INDEX
+
+#define PADDING_LEFT_INDEX 24
+#define PADDING_LEFT_SHIFT 3
+#define PADDING_LEFT_MASK 0xf8
+static inline uint8_t get_padding_left(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[PADDING_LEFT_INDEX];
+ bits &= PADDING_LEFT_MASK;
+ bits >>= PADDING_LEFT_SHIFT;
+
+ /* 5bits: uuuut : units | type */
+ if ((bits & 0x1) == CSS_PADDING_SET) {
+ *length = style->padding[3];
+ *unit = bits >> 1;
+ }
+
+ return (bits & 0x1);
+}
+#undef PADDING_LEFT_MASK
+#undef PADDING_LEFT_SHIFT
+#undef PADDING_LEFT_INDEX
+
+#define OVERFLOW_INDEX 21
+#define OVERFLOW_SHIFT 0
+#define OVERFLOW_MASK 0x7
+static inline uint8_t get_overflow(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[OVERFLOW_INDEX];
+ bits &= OVERFLOW_MASK;
+ bits >>= OVERFLOW_SHIFT;
+
+ /* 3bits: type */
+ return bits;
+}
+#undef OVERFLOW_MASK
+#undef OVERFLOW_SHIFT
+#undef OVERFLOW_INDEX
+
+#define POSITION_INDEX 22
+#define POSITION_SHIFT 0
+#define POSITION_MASK 0x7
+static inline uint8_t get_position(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[POSITION_INDEX];
+ bits &= POSITION_MASK;
+ bits >>= POSITION_SHIFT;
+
+ /* 3bits: type */
+ return bits;
+}
+#undef POSITION_MASK
+#undef POSITION_SHIFT
+#undef POSITION_INDEX
+
+#define TEXT_ALIGN_INDEX 23
+#define TEXT_ALIGN_SHIFT 0
+#define TEXT_ALIGN_MASK 0x7
+static inline uint8_t get_text_align(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[TEXT_ALIGN_INDEX];
+ bits &= TEXT_ALIGN_MASK;
+ bits >>= TEXT_ALIGN_SHIFT;
+
+ /* 3bits: type */
+ return bits;
+}
+#undef TEXT_ALIGN_MASK
+#undef TEXT_ALIGN_SHIFT
+#undef TEXT_ALIGN_INDEX
+
+#define TEXT_TRANSFORM_INDEX 24
+#define TEXT_TRANSFORM_SHIFT 0
+#define TEXT_TRANSFORM_MASK 0x7
+static inline uint8_t get_text_transform(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[TEXT_TRANSFORM_INDEX];
+ bits &= TEXT_TRANSFORM_MASK;
+ bits >>= TEXT_TRANSFORM_SHIFT;
+
+ /* 3bits: type */
+ return bits;
+}
+#undef TEXT_TRANSFORM_MASK
+#undef TEXT_TRANSFORM_SHIFT
+#undef TEXT_TRANSFORM_INDEX
+
+#define TEXT_INDENT_INDEX 25
+#define TEXT_INDENT_SHIFT 3
+#define TEXT_INDENT_MASK 0xf8
+static inline uint8_t get_text_indent(
+ const css_computed_style *style,
+ css_fixed *length, css_unit *unit)
+{
+ uint8_t bits = style->bits[TEXT_INDENT_INDEX];
+ bits &= TEXT_INDENT_MASK;
+ bits >>= TEXT_INDENT_SHIFT;
+
+ /* 5bits: uuuut : units | type */
+ if ((bits & 0x1) == CSS_TEXT_INDENT_SET) {
+ *length = style->text_indent;
+ *unit = bits >> 1;
+ }
+
+ return (bits & 0x1);
+}
+#undef TEXT_INDENT_MASK
+#undef TEXT_INDENT_SHIFT
+#undef TEXT_INDENT_INDEX
+
+#define WHITE_SPACE_INDEX 25
+#define WHITE_SPACE_SHIFT 0
+#define WHITE_SPACE_MASK 0x7
+static inline uint8_t get_white_space(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[WHITE_SPACE_INDEX];
+ bits &= WHITE_SPACE_MASK;
+ bits >>= WHITE_SPACE_SHIFT;
+
+ /* 3bits: type */
+ return bits;
+}
+#undef WHITE_SPACE_MASK
+#undef WHITE_SPACE_SHIFT
+#undef WHITE_SPACE_INDEX
+
+#define BACKGROUND_POSITION_INDEX 27
+#define BACKGROUND_POSITION_SHIFT 7
+#define BACKGROUND_POSITION_MASK 0x80
+#define BACKGROUND_POSITION_INDEX1 26
+#define BACKGROUND_POSITION_SHIFT1 0
+#define BACKGROUND_POSITION_MASK1 0xff
+static inline uint8_t get_background_position(
+ const css_computed_style *style,
+ css_fixed *hlength, css_unit *hunit,
+ css_fixed *vlength, css_unit *vunit)
+{
+ uint8_t bits = style->bits[BACKGROUND_POSITION_INDEX];
+ bits &= BACKGROUND_POSITION_MASK;
+ bits >>= BACKGROUND_POSITION_SHIFT;
+
+ /* 1bit: type */
+ if (bits == CSS_BACKGROUND_POSITION_SET) {
+ uint8_t bits1 = style->bits[BACKGROUND_POSITION_INDEX1];
+ bits1 &= BACKGROUND_POSITION_MASK1;
+ bits1 >>= BACKGROUND_POSITION_SHIFT1;
+
+ /* 8bits: hhhhvvvv : hunit | vunit */
+ *hlength = style->background_position[0];
+ *hunit = bits1 >> 4;
+
+ *vlength = style->background_position[1];
+ *vunit = bits1 & 0xf;
+ }
+
+ return bits;
+}
+#undef BACKGROUND_POSITION_MASK1
+#undef BACKGROUND_POSITION_SHIFT1
+#undef BACKGROUND_POSITION_INDEX1
+#undef BACKGROUND_POSITION_MASK
+#undef BACKGROUND_POSITION_SHIFT
+#undef BACKGROUND_POSITION_INDEX
+
+#define DISPLAY_INDEX 27
+#define DISPLAY_SHIFT 2
+#define DISPLAY_MASK 0x7c
+static inline uint8_t get_display(
+ const css_computed_style *style, bool root)
+{
+ uint8_t position;
+ uint8_t bits = style->bits[DISPLAY_INDEX];
+ bits &= DISPLAY_MASK;
+ bits >>= DISPLAY_SHIFT;
+
+ /* Return computed display as per $9.7 */
+ position = css_computed_position(style);
+
+ /* 5bits: type */
+ if (bits == CSS_DISPLAY_NONE)
+ return bits; /* 1. */
+
+ if ((position == CSS_POSITION_ABSOLUTE ||
+ position == CSS_POSITION_FIXED) /* 2. */ ||
+ css_computed_float(style) != CSS_FLOAT_NONE /* 3. */ ||
+ root /* 4. */) {
+ if (bits == CSS_DISPLAY_INLINE_TABLE) {
+ return CSS_DISPLAY_TABLE;
+ } else if (bits == CSS_DISPLAY_INLINE ||
+ bits == CSS_DISPLAY_RUN_IN ||
+ bits == CSS_DISPLAY_TABLE_ROW_GROUP ||
+ bits == CSS_DISPLAY_TABLE_COLUMN ||
+ bits == CSS_DISPLAY_TABLE_COLUMN_GROUP ||
+ bits == CSS_DISPLAY_TABLE_HEADER_GROUP ||
+ bits == CSS_DISPLAY_TABLE_FOOTER_GROUP ||
+ bits == CSS_DISPLAY_TABLE_ROW ||
+ bits == CSS_DISPLAY_TABLE_CELL ||
+ bits == CSS_DISPLAY_TABLE_CAPTION ||
+ bits == CSS_DISPLAY_INLINE_BLOCK) {
+ return CSS_DISPLAY_BLOCK;
+ }
+ }
+
+ /* 5. */
+ return bits;
+}
+
+static inline uint8_t get_display_static(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[DISPLAY_INDEX];
+ bits &= DISPLAY_MASK;
+ bits >>= DISPLAY_SHIFT;
+
+ /* 5bits: type */
+ return bits;
+}
+
+#undef DISPLAY_MASK
+#undef DISPLAY_SHIFT
+#undef DISPLAY_INDEX
+
+#define FONT_VARIANT_INDEX 27
+#define FONT_VARIANT_SHIFT 0
+#define FONT_VARIANT_MASK 0x3
+static inline uint8_t get_font_variant(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[FONT_VARIANT_INDEX];
+ bits &= FONT_VARIANT_MASK;
+ bits >>= FONT_VARIANT_SHIFT;
+
+ /* 2bits: type */
+ return bits;
+}
+#undef FONT_VARIANT_MASK
+#undef FONT_VARIANT_SHIFT
+#undef FONT_VARIANT_INDEX
+
+#define TEXT_DECORATION_INDEX 28
+#define TEXT_DECORATION_SHIFT 3
+#define TEXT_DECORATION_MASK 0xf8
+static inline uint8_t get_text_decoration(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[TEXT_DECORATION_INDEX];
+ bits &= TEXT_DECORATION_MASK;
+ bits >>= TEXT_DECORATION_SHIFT;
+
+ /* 5bits: type */
+ return bits;
+}
+#undef TEXT_DECORATION_MASK
+#undef TEXT_DECORATION_SHIFT
+#undef TEXT_DECORATION_INDEX
+
+#define FONT_FAMILY_INDEX 28
+#define FONT_FAMILY_SHIFT 0
+#define FONT_FAMILY_MASK 0x7
+static inline uint8_t get_font_family(
+ const css_computed_style *style,
+ lwc_string ***names)
+{
+ uint8_t bits = style->bits[FONT_FAMILY_INDEX];
+ bits &= FONT_FAMILY_MASK;
+ bits >>= FONT_FAMILY_SHIFT;
+
+ /* 3bits: type */
+ *names = style->font_family;
+
+ return bits;
+}
+#undef FONT_FAMILY_MASK
+#undef FONT_FAMILY_SHIFT
+#undef FONT_FAMILY_INDEX
+
+#define BORDER_TOP_STYLE_INDEX 29
+#define BORDER_TOP_STYLE_SHIFT 4
+#define BORDER_TOP_STYLE_MASK 0xf0
+static inline uint8_t get_border_top_style(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[BORDER_TOP_STYLE_INDEX];
+ bits &= BORDER_TOP_STYLE_MASK;
+ bits >>= BORDER_TOP_STYLE_SHIFT;
+
+ /* 4bits: type */
+ return bits;
+}
+#undef BORDER_TOP_STYLE_MASK
+#undef BORDER_TOP_STYLE_SHIFT
+#undef BORDER_TOP_STYLE_INDEX
+
+#define BORDER_RIGHT_STYLE_INDEX 29
+#define BORDER_RIGHT_STYLE_SHIFT 0
+#define BORDER_RIGHT_STYLE_MASK 0xf
+static inline uint8_t get_border_right_style(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[BORDER_RIGHT_STYLE_INDEX];
+ bits &= BORDER_RIGHT_STYLE_MASK;
+ bits >>= BORDER_RIGHT_STYLE_SHIFT;
+
+ /* 4bits: type */
+ return bits;
+}
+#undef BORDER_RIGHT_STYLE_MASK
+#undef BORDER_RIGHT_STYLE_SHIFT
+#undef BORDER_RIGHT_STYLE_INDEX
+
+#define BORDER_BOTTOM_STYLE_INDEX 30
+#define BORDER_BOTTOM_STYLE_SHIFT 4
+#define BORDER_BOTTOM_STYLE_MASK 0xf0
+static inline uint8_t get_border_bottom_style(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[BORDER_BOTTOM_STYLE_INDEX];
+ bits &= BORDER_BOTTOM_STYLE_MASK;
+ bits >>= BORDER_BOTTOM_STYLE_SHIFT;
+
+ /* 4bits: type */
+ return bits;
+}
+#undef BORDER_BOTTOM_STYLE_MASK
+#undef BORDER_BOTTOM_STYLE_SHIFT
+#undef BORDER_BOTTOM_STYLE_INDEX
+
+#define BORDER_LEFT_STYLE_INDEX 30
+#define BORDER_LEFT_STYLE_SHIFT 0
+#define BORDER_LEFT_STYLE_MASK 0xf
+static inline uint8_t get_border_left_style(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[BORDER_LEFT_STYLE_INDEX];
+ bits &= BORDER_LEFT_STYLE_MASK;
+ bits >>= BORDER_LEFT_STYLE_SHIFT;
+
+ /* 4bits: type */
+ return bits;
+}
+#undef BORDER_LEFT_STYLE_MASK
+#undef BORDER_LEFT_STYLE_SHIFT
+#undef BORDER_LEFT_STYLE_INDEX
+
+#define FONT_WEIGHT_INDEX 31
+#define FONT_WEIGHT_SHIFT 4
+#define FONT_WEIGHT_MASK 0xf0
+static inline uint8_t get_font_weight(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[FONT_WEIGHT_INDEX];
+ bits &= FONT_WEIGHT_MASK;
+ bits >>= FONT_WEIGHT_SHIFT;
+
+ /* 4bits: type */
+ return bits;
+}
+#undef FONT_WEIGHT_MASK
+#undef FONT_WEIGHT_SHIFT
+#undef FONT_WEIGHT_INDEX
+
+#define LIST_STYLE_TYPE_INDEX 31
+#define LIST_STYLE_TYPE_SHIFT 0
+#define LIST_STYLE_TYPE_MASK 0xf
+static inline uint8_t get_list_style_type(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[LIST_STYLE_TYPE_INDEX];
+ bits &= LIST_STYLE_TYPE_MASK;
+ bits >>= LIST_STYLE_TYPE_SHIFT;
+
+ /* 4bits: type */
+ return bits;
+}
+#undef LIST_STYLE_TYPE_MASK
+#undef LIST_STYLE_TYPE_SHIFT
+#undef LIST_STYLE_TYPE_INDEX
+
+#define OUTLINE_STYLE_INDEX 32
+#define OUTLINE_STYLE_SHIFT 4
+#define OUTLINE_STYLE_MASK 0xf0
+static inline uint8_t get_outline_style(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[OUTLINE_STYLE_INDEX];
+ bits &= OUTLINE_STYLE_MASK;
+ bits >>= OUTLINE_STYLE_SHIFT;
+
+ /* 4bits: type */
+ return bits;
+}
+#undef OUTLINE_STYLE_MASK
+#undef OUTLINE_STYLE_SHIFT
+#undef OUTLINE_STYLE_INDEX
+
+#define TABLE_LAYOUT_INDEX 32
+#define TABLE_LAYOUT_SHIFT 2
+#define TABLE_LAYOUT_MASK 0xc
+static inline uint8_t get_table_layout(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[TABLE_LAYOUT_INDEX];
+ bits &= TABLE_LAYOUT_MASK;
+ bits >>= TABLE_LAYOUT_SHIFT;
+
+ /* 2bits: type */
+ return bits;
+}
+#undef TABLE_LAYOUT_MASK
+#undef TABLE_LAYOUT_SHIFT
+#undef TABLE_LAYOUT_INDEX
+
+#define UNICODE_BIDI_INDEX 32
+#define UNICODE_BIDI_SHIFT 0
+#define UNICODE_BIDI_MASK 0x3
+static inline uint8_t get_unicode_bidi(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[UNICODE_BIDI_INDEX];
+ bits &= UNICODE_BIDI_MASK;
+ bits >>= UNICODE_BIDI_SHIFT;
+
+ /* 2bits: type */
+ return bits;
+}
+#undef UNICODE_BIDI_MASK
+#undef UNICODE_BIDI_SHIFT
+#undef UNICODE_BIDI_INDEX
+
+#define VISIBILITY_INDEX 33
+#define VISIBILITY_SHIFT 6
+#define VISIBILITY_MASK 0xc0
+static inline uint8_t get_visibility(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[VISIBILITY_INDEX];
+ bits &= VISIBILITY_MASK;
+ bits >>= VISIBILITY_SHIFT;
+
+ /* 2bits: type */
+ return bits;
+}
+#undef VISIBILITY_MASK
+#undef VISIBILITY_SHIFT
+#undef VISIBILITY_INDEX
+
+#define LIST_STYLE_POSITION_INDEX 33
+#define LIST_STYLE_POSITION_SHIFT 4
+#define LIST_STYLE_POSITION_MASK 0x30
+static inline uint8_t get_list_style_position(
+ const css_computed_style *style)
+{
+ uint8_t bits = style->bits[LIST_STYLE_POSITION_INDEX];
+ bits &= LIST_STYLE_POSITION_MASK;
+ bits >>= LIST_STYLE_POSITION_SHIFT;
+
+ /* 2bits: type */
+ return bits;
+}
+#undef LIST_STYLE_POSITION_MASK
+#undef LIST_STYLE_POSITION_SHIFT
+#undef LIST_STYLE_POSITION_INDEX
+
+#endif
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-20 11:32:40 +0000