summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorJohn Mark Bell <jmb@netsurf-browser.org>2009-02-07 01:40:12 +0000
committerJohn Mark Bell <jmb@netsurf-browser.org>2009-02-07 01:40:12 +0000
commit9ed557ba18facc04fd9d9b35a5dac15844f161c3 (patch)
tree5b86c13a3fbe303000c4bcfb287af42fc8d8d291 /src
parent86263d609fbc16711b997eb4ae115020d1892f41 (diff)
downloadlibcss-9ed557ba18facc04fd9d9b35a5dac15844f161c3.tar.gz
libcss-9ed557ba18facc04fd9d9b35a5dac15844f161c3.tar.bz2
Mutators for computed style
svn path=/trunk/libcss/; revision=6388
Diffstat (limited to 'src')
-rw-r--r--src/select/propset.h1627
-rw-r--r--src/select/select.c2
2 files changed, 1628 insertions, 1 deletions
diff --git a/src/select/propset.h b/src/select/propset.h
new file mode 100644
index 0000000..7f397d7
--- /dev/null
+++ b/src/select/propset.h
@@ -0,0 +1,1627 @@
+/*
+ * 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_propset_h_
+#define css_select_propset_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 ENSURE_UNCOMMON do { \
+ if (style->uncommon == NULL) { \
+ style->uncommon = style->alloc(NULL, \
+ sizeof(css_computed_uncommon), style->pw); \
+ if (style->uncommon == NULL) \
+ return CSS_NOMEM; \
+ \
+ memset(style->uncommon, 0, \
+ sizeof(css_computed_uncommon)); \
+ } \
+} while(0)
+
+#define LETTER_SPACING_INDEX 0
+#define LETTER_SPACING_SHIFT 2
+#define LETTER_SPACING_MASK 0xfc
+static inline css_error set_letter_spacing(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits;
+
+ ENSURE_UNCOMMON;
+
+ bits = &style->uncommon->bits[LETTER_SPACING_INDEX];
+
+ /* 6bits: uuuutt : unit | type */
+ *bits = (*bits & ~LETTER_SPACING_MASK) |
+ (((type & 0x3) | unit << 2) << LETTER_SPACING_SHIFT);
+
+ style->uncommon->letter_spacing = length;
+
+ return CSS_OK;
+}
+#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 css_error set_outline_color(
+ css_computed_style *style, uint8_t type, css_color color)
+{
+ uint8_t *bits;
+
+ ENSURE_UNCOMMON;
+
+ bits = &style->uncommon->bits[OUTLINE_COLOR_INDEX];
+
+ /* 2bits: tt : type */
+ *bits = (*bits & ~OUTLINE_COLOR_MASK) |
+ ((type & 0x3) << OUTLINE_COLOR_SHIFT);
+
+ style->uncommon->outline_color = color;
+
+ return CSS_OK;
+}
+#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 css_error set_outline_width(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits;
+
+ ENSURE_UNCOMMON;
+
+ bits = &style->uncommon->bits[OUTLINE_WIDTH_INDEX];
+
+ /* 7bits: uuuuttt : unit | type */
+ *bits = (*bits & ~OUTLINE_WIDTH_MASK) |
+ (((type & 0x7) | (unit << 3)) << OUTLINE_WIDTH_SHIFT);
+
+ style->uncommon->outline_width = length;
+
+ return CSS_OK;
+}
+#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 css_error set_border_spacing(
+ css_computed_style *style, uint8_t type,
+ css_fixed hlength, css_unit hunit,
+ css_fixed vlength, css_unit vunit)
+{
+ uint8_t *bits;
+
+ ENSURE_UNCOMMON;
+
+ bits = &style->uncommon->bits[BORDER_SPACING_INDEX];
+
+ /* 1 bit: type */
+ *bits = (*bits & ~BORDER_SPACING_MASK) |
+ ((type & 0x1) << BORDER_SPACING_SHIFT);
+
+ bits = &style->uncommon->bits[BORDER_SPACING_INDEX1];
+
+ /* 8bits: hhhhvvvv : hunit | vunit */
+ *bits = (*bits & ~BORDER_SPACING_MASK1) |
+ (((hunit << 4) | vunit) << BORDER_SPACING_SHIFT1);
+
+
+ style->uncommon->border_spacing[0] = hlength;
+ style->uncommon->border_spacing[1] = vlength;
+
+ return CSS_OK;
+}
+#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 css_error set_word_spacing(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits;
+
+ ENSURE_UNCOMMON;
+
+ bits = &style->uncommon->bits[WORD_SPACING_INDEX];
+
+ /* 6bits: uuuutt : unit | type */
+ *bits = (*bits & ~WORD_SPACING_MASK) |
+ (((type & 0x3) | (unit << 2)) << WORD_SPACING_SHIFT);
+
+ style->uncommon->word_spacing = length;
+
+ return CSS_OK;
+}
+#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 css_error set_counter_increment(
+ css_computed_style *style, uint8_t type,
+ css_computed_counter **counters)
+{
+ uint8_t *bits;
+
+ ENSURE_UNCOMMON;
+
+ bits = &style->uncommon->bits[COUNTER_INCREMENT_INDEX];
+
+ /* 1bit: type */
+ *bits = (*bits & ~COUNTER_INCREMENT_MASK) |
+ ((type & 0x1) << COUNTER_INCREMENT_SHIFT);
+
+ /** \todo Is this remotely sane? Would it be better to have this
+ * function append entries to the array, instead? */
+ style->uncommon->counter_increment = counters;
+
+ return CSS_OK;
+}
+#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 css_error set_counter_reset(
+ css_computed_style *style, uint8_t type,
+ css_computed_counter **counters)
+{
+ uint8_t *bits;
+
+ ENSURE_UNCOMMON;
+
+ bits = &style->uncommon->bits[COUNTER_RESET_INDEX];
+
+ /* 1bit: type */
+ *bits = (*bits & ~COUNTER_RESET_MASK) |
+ ((type & 0x1) << COUNTER_RESET_SHIFT);
+
+ /** \todo Is this remotely sane? Would it be better to have this
+ * function append entries to the array, instead? */
+ style->uncommon->counter_reset = counters;
+
+ return CSS_OK;
+}
+#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 css_error set_cursor(
+ css_computed_style *style, uint8_t type,
+ const css_string **urls)
+{
+ uint8_t *bits;
+
+ ENSURE_UNCOMMON;
+
+ bits = &style->uncommon->bits[CURSOR_INDEX];
+
+ /* 5bits: type */
+ *bits = (*bits & ~CURSOR_MASK) |
+ ((type & 0x1f) << CURSOR_SHIFT);
+
+ /** \todo Is this remotely sane? Would it be better to have this
+ * function append entries to the array, instead? */
+ style->uncommon->cursor = urls;
+
+ return CSS_OK;
+}
+#undef CURSOR_MASK
+#undef CURSOR_SHIFT
+#undef CURSOR_INDEX
+
+#define QUOTES_INDEX 4
+#define QUOTES_SHIFT 2
+#define QUOTES_MASK 0x4
+static inline css_error set_quotes(
+ css_computed_style *style, uint8_t type,
+ const css_string **quotes)
+{
+ uint8_t *bits;
+
+ ENSURE_UNCOMMON;
+
+ bits = &style->uncommon->bits[QUOTES_INDEX];
+
+ /* 1bit: type */
+ *bits = (*bits & ~QUOTES_MASK) |
+ ((type & 0x1) << QUOTES_SHIFT);
+
+ /** \todo Is this remotely sane? Would it be better to have this
+ * function append entries to the array, instead? */
+ style->uncommon->quotes = quotes;
+
+ return CSS_OK;
+}
+#undef QUOTES_MASK
+#undef QUOTES_SHIFT
+#undef QUOTES_INDEX
+
+#define CLIP_INDEX 4
+#define CLIP_SHIFT 0
+#define CLIP_MASK 0x3
+#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 css_error set_clip(
+ css_computed_style *style, uint8_t type,
+ css_computed_clip_rect *rect)
+{
+ uint8_t *bits;
+
+ ENSURE_UNCOMMON;
+
+ bits = &style->uncommon->bits[CLIP_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~CLIP_MASK) |
+ ((type & 0x3) << CLIP_SHIFT);
+
+ if (type == CSS_CLIP_RECT) {
+ bits = &style->uncommon->bits[CLIP_INDEX1];
+
+ /* 8bits: ttttrrrr : top | right */
+ *bits = (*bits & ~CLIP_MASK1) |
+ (((rect->tunit << 4) | rect->runit) << CLIP_SHIFT1);
+
+ bits = &style->uncommon->bits[CLIP_INDEX2];
+
+ /* 8bits: bbbbllll : bottom | left */
+ *bits = (*bits & ~CLIP_MASK2) |
+ (((rect->bunit << 4) | rect->lunit) << CLIP_SHIFT2);
+
+ style->uncommon->clip[0] = rect->top;
+ style->uncommon->clip[1] = rect->right;
+ style->uncommon->clip[2] = rect->bottom;
+ style->uncommon->clip[3] = rect->left;
+ }
+
+ return CSS_OK;
+}
+#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 VERTICAL_ALIGN_INDEX 0
+#define VERTICAL_ALIGN_SHIFT 0
+#define VERTICAL_ALIGN_MASK 0xff
+static inline css_error set_vertical_align(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[VERTICAL_ALIGN_INDEX];
+
+ /* 8bits: uuuutttt : units | type */
+ *bits = (*bits & ~VERTICAL_ALIGN_MASK) |
+ (((type & 0xf) | (unit << 4)) << VERTICAL_ALIGN_SHIFT);
+
+ style->vertical_align = length;
+
+ return CSS_OK;
+}
+#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 css_error set_font_size(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[FONT_SIZE_INDEX];
+
+ /* 8bits: uuuutttt : units | type */
+ *bits = (*bits & ~FONT_SIZE_MASK) |
+ (((type & 0xf) | (unit << 4)) << FONT_SIZE_SHIFT);
+
+ style->font_size = length;
+
+ return CSS_OK;
+}
+#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 css_error set_border_top_width(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[BORDER_TOP_WIDTH_INDEX];
+
+ /* 7bits: uuuuttt : units | type */
+ *bits = (*bits & ~BORDER_TOP_WIDTH_MASK) |
+ (((type & 0x7) | (unit << 3)) << BORDER_TOP_WIDTH_SHIFT);
+
+ style->border_width[0] = length;
+
+ return CSS_OK;
+}
+#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 css_error set_border_right_width(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[BORDER_RIGHT_WIDTH_INDEX];
+
+ /* 7bits: uuuuttt : units | type */
+ *bits = (*bits & ~BORDER_RIGHT_WIDTH_MASK) |
+ (((type & 0x7) | (unit << 3)) << BORDER_RIGHT_WIDTH_SHIFT);
+
+ style->border_width[1] = length;
+
+ return CSS_OK;
+}
+#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 css_error set_border_bottom_width(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[BORDER_BOTTOM_WIDTH_INDEX];
+
+ /* 7bits: uuuuttt : units | type */
+ *bits = (*bits & ~BORDER_BOTTOM_WIDTH_MASK) |
+ (((type & 0x7) | (unit << 3)) << BORDER_BOTTOM_WIDTH_SHIFT);
+
+ style->border_width[2] = length;
+
+ return CSS_OK;
+}
+#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 css_error set_border_left_width(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[BORDER_LEFT_WIDTH_INDEX];
+
+ /* 7bits: uuuuttt : units | type */
+ *bits = (*bits & ~BORDER_LEFT_WIDTH_MASK) |
+ (((type & 0x7) | (unit << 3)) << BORDER_LEFT_WIDTH_SHIFT);
+
+ style->border_width[3] = length;
+
+ return CSS_OK;
+}
+#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 css_error set_background_image(
+ css_computed_style *style, uint8_t type,
+ const css_string *url)
+{
+ uint8_t *bits = &style->bits[BACKGROUND_IMAGE_INDEX];
+
+ /* 1bit: type */
+ *bits = (*bits & ~BACKGROUND_IMAGE_MASK) |
+ ((type & 0x1) << BACKGROUND_IMAGE_SHIFT);
+
+ style->background_image = url;
+
+ return CSS_OK;
+}
+#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 css_error set_color(
+ css_computed_style *style, uint8_t type,
+ css_color color)
+{
+ uint8_t *bits = &style->bits[COLOR_INDEX];
+
+ /* 1bit: type */
+ *bits = (*bits & ~COLOR_MASK) |
+ ((type & 0x1) << COLOR_SHIFT);
+
+ style->color = color;
+
+ return CSS_OK;
+}
+#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 css_error set_list_style_image(
+ css_computed_style *style, uint8_t type,
+ const css_string *url)
+{
+ uint8_t *bits = &style->bits[LIST_STYLE_IMAGE_INDEX];
+
+ /* 1bit: type */
+ *bits = (*bits & ~LIST_STYLE_IMAGE_MASK) |
+ ((type & 0x1) << LIST_STYLE_IMAGE_SHIFT);
+
+ style->list_style_image = url;
+
+ return CSS_OK;
+}
+#undef LIST_STYLE_IMAGE_MASK
+#undef LIST_STYLE_IMAGE_SHIFT
+#undef LIST_STYLE_IMAGE_INDEX
+
+#define FONT_FAMILY_INDEX 5
+#define FONT_FAMILY_SHIFT 0
+#define FONT_FAMILY_MASK 0x1
+static inline css_error set_font_family(
+ css_computed_style *style, uint8_t type,
+ const css_string **names)
+{
+ uint8_t *bits = &style->bits[FONT_FAMILY_INDEX];
+
+ /* 1bit: type */
+ *bits = (*bits & ~FONT_FAMILY_MASK) |
+ ((type & 0x1) << FONT_FAMILY_SHIFT);
+
+ /** \todo This probably wants to append to the array */
+ style->font_family = names;
+
+ return CSS_OK;
+}
+#undef FONT_FAMILY_MASK
+#undef FONT_FAMILY_SHIFT
+#undef FONT_FAMILY_INDEX
+
+#define TOP_INDEX 6
+#define TOP_SHIFT 2
+#define TOP_MASK 0xfc
+static inline css_error set_top(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[TOP_INDEX];
+
+ /* 6bits: uuuutt : units | type */
+ *bits = (*bits & ~TOP_MASK) |
+ (((type & 0x3) | (unit << 2)) << TOP_SHIFT);
+
+ style->top = length;
+
+ return CSS_OK;
+}
+#undef TOP_MASK
+#undef TOP_SHIFT
+#undef TOP_INDEX
+
+#define RIGHT_INDEX 7
+#define RIGHT_SHIFT 2
+#define RIGHT_MASK 0xfc
+static inline css_error set_right(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[RIGHT_INDEX];
+
+ /* 6bits: uuuutt : units | type */
+ *bits = (*bits & ~RIGHT_MASK) |
+ (((type & 0x3) | (unit << 2)) << RIGHT_SHIFT);
+
+ style->right = length;
+
+ return CSS_OK;
+}
+#undef RIGHT_MASK
+#undef RIGHT_SHIFT
+#undef RIGHT_INDEX
+
+#define BOTTOM_INDEX 8
+#define BOTTOM_SHIFT 2
+#define BOTTOM_MASK 0xfc
+static inline css_error set_bottom(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[BOTTOM_INDEX];
+
+ /* 6bits: uuuutt : units | type */
+ *bits = (*bits & ~BOTTOM_MASK) |
+ (((type & 0x3) | (unit << 2)) << BOTTOM_SHIFT);
+
+ style->bottom = length;
+
+ return CSS_OK;
+}
+#undef BOTTOM_MASK
+#undef BOTTOM_SHIFT
+#undef BOTTOM_INDEX
+
+#define LEFT_INDEX 9
+#define LEFT_SHIFT 2
+#define LEFT_MASK 0xfc
+static inline css_error set_left(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[LEFT_INDEX];
+
+ /* 6bits: uuuutt : units | type */
+ *bits = (*bits & ~LEFT_MASK) |
+ (((type & 0x3) | (unit << 2)) << LEFT_SHIFT);
+
+ style->left = length;
+
+ return CSS_OK;
+}
+#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 css_error set_border_top_color(
+ css_computed_style *style, uint8_t type,
+ css_color color)
+{
+ uint8_t *bits = &style->bits[BORDER_TOP_COLOR_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~BORDER_TOP_COLOR_MASK) |
+ ((type & 0x3) << BORDER_TOP_COLOR_SHIFT);
+
+ style->border_color[0] = color;
+
+ return CSS_OK;
+}
+#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 css_error set_border_right_color(
+ css_computed_style *style, uint8_t type,
+ css_color color)
+{
+ uint8_t *bits = &style->bits[BORDER_RIGHT_COLOR_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~BORDER_RIGHT_COLOR_MASK) |
+ ((type & 0x3) << BORDER_RIGHT_COLOR_SHIFT);
+
+ style->border_color[1] = color;
+
+ return CSS_OK;
+}
+#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 css_error set_border_bottom_color(
+ css_computed_style *style, uint8_t type,
+ css_color color)
+{
+ uint8_t *bits = &style->bits[BORDER_BOTTOM_COLOR_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~BORDER_BOTTOM_COLOR_MASK) |
+ ((type & 0x3) << BORDER_BOTTOM_COLOR_SHIFT);
+
+ style->border_color[2] = color;
+
+ return CSS_OK;
+}
+#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 css_error set_border_left_color(
+ css_computed_style *style, uint8_t type,
+ css_color color)
+{
+ uint8_t *bits = &style->bits[BORDER_LEFT_COLOR_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~BORDER_LEFT_COLOR_MASK) |
+ ((type & 0x3) << BORDER_LEFT_COLOR_SHIFT);
+
+ style->border_color[3] = color;
+
+ return CSS_OK;
+}
+#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 css_error set_height(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[HEIGHT_INDEX];
+
+ /* 6bits: uuuutt : units | type */
+ *bits = (*bits & ~HEIGHT_MASK) |
+ (((type & 0x3) | (unit << 2)) << HEIGHT_SHIFT);
+
+ style->height = length;
+
+ return CSS_OK;
+}
+#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 css_error set_line_height(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[LINE_HEIGHT_INDEX];
+
+ /* 6bits: uuuutt : units | type */
+ *bits = (*bits & ~LINE_HEIGHT_MASK) |
+ (((type & 0x3) | (unit << 2)) << LINE_HEIGHT_SHIFT);
+
+ style->line_height = length;
+
+ return CSS_OK;
+}
+#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 css_error set_background_color(
+ css_computed_style *style, uint8_t type,
+ css_color color)
+{
+ uint8_t *bits = &style->bits[BACKGROUND_COLOR_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~BACKGROUND_COLOR_MASK) |
+ ((type & 0x3) << BACKGROUND_COLOR_SHIFT);
+
+ style->background_color = color;
+
+ return CSS_OK;
+}
+#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 css_error set_z_index(
+ css_computed_style *style, uint8_t type,
+ int32_t z_index)
+{
+ uint8_t *bits = &style->bits[Z_INDEX_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~Z_INDEX_MASK) |
+ ((type & 0x3) << Z_INDEX_SHIFT);
+
+ style->z_index = z_index;
+
+ return CSS_OK;
+}
+#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 css_error set_margin_top(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[MARGIN_TOP_INDEX];
+
+ /* 6bits: uuuutt : units | type */
+ *bits = (*bits & ~MARGIN_TOP_MASK) |
+ (((type & 0x3) | (unit << 2)) << MARGIN_TOP_SHIFT);
+
+ style->margin[0] = length;
+
+ return CSS_OK;
+}
+#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 css_error set_margin_right(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[MARGIN_RIGHT_INDEX];
+
+ /* 6bits: uuuutt : units | type */
+ *bits = (*bits & ~MARGIN_RIGHT_MASK) |
+ (((type & 0x3) | (unit << 2)) << MARGIN_RIGHT_SHIFT);
+
+ style->margin[1] = length;
+
+ return CSS_OK;
+}
+#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 css_error set_margin_bottom(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[MARGIN_BOTTOM_INDEX];
+
+ /* 6bits: uuuutt : units | type */
+ *bits = (*bits & ~MARGIN_BOTTOM_MASK) |
+ (((type & 0x3) | (unit << 2)) << MARGIN_BOTTOM_SHIFT);
+
+ style->margin[2] = length;
+
+ return CSS_OK;
+}
+#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 css_error set_margin_left(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[MARGIN_LEFT_INDEX];
+
+ /* 6bits: uuuutt : units | type */
+ *bits = (*bits & ~MARGIN_LEFT_MASK) |
+ (((type & 0x3) | (unit << 2)) << MARGIN_LEFT_SHIFT);
+
+ style->margin[3] = length;
+
+ return CSS_OK;
+}
+#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 css_error set_background_attachment(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[BACKGROUND_ATTACHMENT_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~BACKGROUND_ATTACHMENT_MASK) |
+ ((type & 0x3) << BACKGROUND_ATTACHMENT_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_border_collapse(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[BORDER_COLLAPSE_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~BORDER_COLLAPSE_MASK) |
+ ((type & 0x3) << BORDER_COLLAPSE_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_caption_side(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[CAPTION_SIDE_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~CAPTION_SIDE_MASK) |
+ ((type & 0x3) << CAPTION_SIDE_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_direction(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[DIRECTION_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~DIRECTION_MASK) |
+ ((type & 0x3) << DIRECTION_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_max_height(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[MAX_HEIGHT_INDEX];
+
+ /* 6bits: uuuutt : units | type */
+ *bits = (*bits & ~MAX_HEIGHT_MASK) |
+ (((type & 0x3) | (unit << 2)) << MAX_HEIGHT_SHIFT);
+
+ style->max_height = length;
+
+ return CSS_OK;
+}
+#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 css_error set_max_width(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[MAX_WIDTH_INDEX];
+
+ /* 6bits: uuuutt : units | type */
+ *bits = (*bits & ~MAX_WIDTH_MASK) |
+ (((type & 0x3) | (unit << 2)) << MAX_WIDTH_SHIFT);
+
+ style->max_width = length;
+
+ return CSS_OK;
+}
+#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 css_error set_width(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[WIDTH_INDEX];
+
+ /* 6bits: uuuutt : units | type */
+ *bits = (*bits & ~WIDTH_MASK) |
+ (((type & 0x3) | (unit << 2)) << WIDTH_SHIFT);
+
+ style->width = length;
+
+ return CSS_OK;
+}
+#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 css_error set_empty_cells(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[EMPTY_CELLS_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~EMPTY_CELLS_MASK) |
+ ((type & 0x3) << EMPTY_CELLS_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_float(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[FLOAT_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~FLOAT_MASK) |
+ ((type & 0x3) << FLOAT_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_font_style(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[FONT_STYLE_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~FONT_STYLE_MASK) |
+ ((type & 0x3) << FONT_STYLE_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_min_height(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[MIN_HEIGHT_INDEX];
+
+ /* 5bits: uuuut : units | type */
+ *bits = (*bits & ~MIN_HEIGHT_MASK) |
+ (((type & 0x1) | (unit << 1)) << MIN_HEIGHT_SHIFT);
+
+ style->min_height = length;
+
+ return CSS_OK;
+}
+#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 css_error set_min_width(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[MIN_WIDTH_INDEX];
+
+ /* 5bits: uuuut : units | type */
+ *bits = (*bits & ~MIN_WIDTH_MASK) |
+ (((type & 0x1) | (unit << 1)) << MIN_WIDTH_SHIFT);
+
+ style->min_width = length;
+
+ return CSS_OK;
+}
+#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 css_error set_background_repeat(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[BACKGROUND_REPEAT_INDEX];
+
+ /* 3bits: type */
+ *bits = (*bits & ~BACKGROUND_REPEAT_MASK) |
+ ((type & 0x7) << BACKGROUND_REPEAT_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_clear(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[CLEAR_INDEX];
+
+ /* 3bits: type */
+ *bits = (*bits & ~CLEAR_MASK) |
+ ((type & 0x7) << CLEAR_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_padding_top(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[PADDING_TOP_INDEX];
+
+ /* 5bits: uuuut : units | type */
+ *bits = (*bits & ~PADDING_TOP_MASK) |
+ (((type & 0x1) | (unit << 1)) << PADDING_TOP_SHIFT);
+
+ style->padding[0] = length;
+
+ return CSS_OK;
+}
+#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 css_error set_padding_right(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[PADDING_RIGHT_INDEX];
+
+ /* 5bits: uuuut : units | type */
+ *bits = (*bits & ~PADDING_RIGHT_MASK) |
+ (((type & 0x1) | (unit << 1)) << PADDING_RIGHT_SHIFT);
+
+ style->padding[1] = length;
+
+ return CSS_OK;
+}
+#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 css_error set_padding_bottom(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[PADDING_BOTTOM_INDEX];
+
+ /* 5bits: uuuut : units | type */
+ *bits = (*bits & ~PADDING_BOTTOM_MASK) |
+ (((type & 0x1) | (unit << 1)) << PADDING_BOTTOM_SHIFT);
+
+ style->padding[2] = length;
+
+ return CSS_OK;
+}
+#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 css_error set_padding_left(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[PADDING_LEFT_INDEX];
+
+ /* 5bits: uuuut : units | type */
+ *bits = (*bits & ~PADDING_LEFT_MASK) |
+ (((type & 0x1) | (unit << 1)) << PADDING_LEFT_SHIFT);
+
+ style->padding[3] = length;
+
+ return CSS_OK;
+}
+#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 css_error set_overflow(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[OVERFLOW_INDEX];
+
+ /* 3bits: type */
+ *bits = (*bits & ~OVERFLOW_MASK) |
+ ((type & 0x7) << OVERFLOW_SHIFT);
+
+ return CSS_OK;
+}
+#undef OVERFLOW_MASK
+#undef OVERFLOW_SHIFT
+#undef OVERFLOW_INDEX
+
+#define POSITION_INDEX 22
+#define POSITION_SHIFT 0
+#define POSITION_MASK 0x7
+static inline css_error set_position(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[POSITION_INDEX];
+
+ /* 3bits: type */
+ *bits = (*bits & ~POSITION_MASK) |
+ ((type & 0x7) << POSITION_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_text_align(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[TEXT_ALIGN_INDEX];
+
+ /* 3bits: type */
+ *bits = (*bits & ~TEXT_ALIGN_MASK) |
+ ((type & 0x7) << TEXT_ALIGN_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_text_transform(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[TEXT_TRANSFORM_INDEX];
+
+ /* 3bits: type */
+ *bits = (*bits & ~TEXT_TRANSFORM_MASK) |
+ ((type & 0x7) << TEXT_TRANSFORM_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_text_indent(
+ css_computed_style *style, uint8_t type,
+ css_fixed length, css_unit unit)
+{
+ uint8_t *bits = &style->bits[TEXT_INDENT_INDEX];
+
+ /* 5bits: uuuut : units | type */
+ *bits = (*bits & ~TEXT_INDENT_MASK) |
+ (((type & 0x1) | (unit << 1)) << TEXT_INDENT_SHIFT);
+
+ style->text_indent = length;
+
+ return CSS_OK;
+}
+#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 css_error set_white_space(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[WHITE_SPACE_INDEX];
+
+ /* 3bits: type */
+ *bits = (*bits & ~WHITE_SPACE_MASK) |
+ ((type & 0x7) << WHITE_SPACE_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_background_position(
+ css_computed_style *style, uint8_t type,
+ css_fixed hlength, css_unit hunit,
+ css_fixed vlength, css_unit vunit)
+{
+ uint8_t *bits;
+
+ bits = &style->bits[BACKGROUND_POSITION_INDEX];
+
+ /* 1 bit: type */
+ *bits = (*bits & ~BACKGROUND_POSITION_MASK) |
+ ((type & 0x1) << BACKGROUND_POSITION_SHIFT);
+
+ bits = &style->bits[BACKGROUND_POSITION_INDEX1];
+
+ /* 8bits: hhhhvvvv : hunit | vunit */
+ *bits = (*bits & ~BACKGROUND_POSITION_MASK1) |
+ (((hunit << 4) | vunit) << BACKGROUND_POSITION_SHIFT1);
+
+ style->background_position[0] = hlength;
+ style->background_position[1] = vlength;
+
+ return CSS_OK;
+}
+#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 css_error set_display(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[DISPLAY_INDEX];
+
+ /* 5bits: type */
+ *bits = (*bits & ~DISPLAY_MASK) |
+ ((type & 0x1f) << DISPLAY_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_font_variant(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[FONT_VARIANT_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~FONT_VARIANT_MASK) |
+ ((type & 0x3) << FONT_VARIANT_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_text_decoration(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[TEXT_DECORATION_INDEX];
+
+ /* 5bits: type */
+ *bits = (*bits & ~TEXT_DECORATION_MASK) |
+ ((type & 0x1f) << TEXT_DECORATION_SHIFT);
+
+ return CSS_OK;
+}
+#undef TEXT_DECORATION_MASK
+#undef TEXT_DECORATION_SHIFT
+#undef TEXT_DECORATION_INDEX
+
+#define LIST_STYLE_POSITION_INDEX 28
+#define LIST_STYLE_POSITION_SHIFT 1
+#define LIST_STYLE_POSITION_MASK 0x3
+static inline css_error set_list_style_position(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[LIST_STYLE_POSITION_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~LIST_STYLE_POSITION_MASK) |
+ ((type & 0x3) << LIST_STYLE_POSITION_SHIFT);
+
+ return CSS_OK;
+}
+#undef LIST_STYLE_POSITION_MASK
+#undef LIST_STYLE_POSITION_SHIFT
+#undef LIST_STYLE_POSITION_INDEX
+
+#define BORDER_TOP_STYLE_INDEX 29
+#define BORDER_TOP_STYLE_SHIFT 4
+#define BORDER_TOP_STYLE_MASK 0xf0
+static inline css_error set_border_top_style(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[BORDER_TOP_STYLE_INDEX];
+
+ /* 4bits: type */
+ *bits = (*bits & ~BORDER_TOP_STYLE_MASK) |
+ ((type & 0xf) << BORDER_TOP_STYLE_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_border_right_style(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[BORDER_RIGHT_STYLE_INDEX];
+
+ /* 4bits: type */
+ *bits = (*bits & ~BORDER_RIGHT_STYLE_MASK) |
+ ((type & 0xf) << BORDER_RIGHT_STYLE_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_border_bottom_style(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[BORDER_BOTTOM_STYLE_INDEX];
+
+ /* 4bits: type */
+ *bits = (*bits & ~BORDER_BOTTOM_STYLE_MASK) |
+ ((type & 0xf) << BORDER_BOTTOM_STYLE_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_border_left_style(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[BORDER_LEFT_STYLE_INDEX];
+
+ /* 4bits: type */
+ *bits = (*bits & ~BORDER_LEFT_STYLE_MASK) |
+ ((type & 0xf) << BORDER_LEFT_STYLE_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_font_weight(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[FONT_WEIGHT_INDEX];
+
+ /* 4bits: type */
+ *bits = (*bits & ~FONT_WEIGHT_MASK) |
+ ((type & 0xf) << FONT_WEIGHT_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_list_style_type(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[LIST_STYLE_TYPE_INDEX];
+
+ /* 4bits: type */
+ *bits = (*bits & ~LIST_STYLE_TYPE_MASK) |
+ ((type & 0xf) << LIST_STYLE_TYPE_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_outline_style(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[OUTLINE_STYLE_INDEX];
+
+ /* 4bits: type */
+ *bits = (*bits & ~OUTLINE_STYLE_MASK) |
+ ((type & 0xf) << OUTLINE_STYLE_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_table_layout(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[TABLE_LAYOUT_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~TABLE_LAYOUT_MASK) |
+ ((type & 0x3) << TABLE_LAYOUT_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_unicode_bidi(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[UNICODE_BIDI_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~UNICODE_BIDI_MASK) |
+ ((type & 0x3) << UNICODE_BIDI_SHIFT);
+
+ return CSS_OK;
+}
+#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 css_error set_visibility(
+ css_computed_style *style, uint8_t type)
+{
+ uint8_t *bits = &style->bits[VISIBILITY_INDEX];
+
+ /* 2bits: type */
+ *bits = (*bits & ~VISIBILITY_MASK) |
+ ((type & 0x3) << VISIBILITY_SHIFT);
+
+ return CSS_OK;
+}
+#undef VISIBILITY_MASK
+#undef VISIBILITY_SHIFT
+#undef VISIBILITY_INDEX
+
+#endif
diff --git a/src/select/select.c b/src/select/select.c
index 0a87d84..68c3279 100644
--- a/src/select/select.c
+++ b/src/select/select.c
@@ -7,11 +7,11 @@
#include <string.h>
-#include <libcss/computed.h>
#include <libcss/select.h>
#include "stylesheet.h"
#include "select/hash.h"
+#include "select/propset.h"
#include "utils/utils.h"
/**