From 9ed557ba18facc04fd9d9b35a5dac15844f161c3 Mon Sep 17 00:00:00 2001 From: John Mark Bell Date: Sat, 7 Feb 2009 01:40:12 +0000 Subject: Mutators for computed style svn path=/trunk/libcss/; revision=6388 --- src/select/propset.h | 1627 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/select/select.c | 2 +- 2 files changed, 1628 insertions(+), 1 deletion(-) create mode 100644 src/select/propset.h 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 + */ + +#ifndef css_select_propset_h_ +#define css_select_propset_h_ + +#include + +/* 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 -#include #include #include "stylesheet.h" #include "select/hash.h" +#include "select/propset.h" #include "utils/utils.h" /** -- cgit v1.2.3