css_error css__cascade_text_transform(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_TEXT_TRANSFORM_INHERIT;
UNUSED(style);
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case TEXT_TRANSFORM_CAPITALIZE:
value = CSS_TEXT_TRANSFORM_CAPITALIZE;
break;
case TEXT_TRANSFORM_UPPERCASE:
value = CSS_TEXT_TRANSFORM_UPPERCASE;
break;
case TEXT_TRANSFORM_LOWERCASE:
value = CSS_TEXT_TRANSFORM_LOWERCASE;
break;
case TEXT_TRANSFORM_NONE:
value = CSS_TEXT_TRANSFORM_NONE;
break;
}
}
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_text_transform(state->computed, value);
}
return CSS_OK;
}
css_error css__cascade_border_spacing(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_BORDER_SPACING_INHERIT;
css_fixed hlength = 0;
css_fixed vlength = 0;
uint32_t hunit = UNIT_PX;
uint32_t vunit = UNIT_PX;
if (isInherit(opv) == false) {
value = CSS_BORDER_SPACING_SET;
hlength = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(hlength));
hunit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(hunit));
vlength = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(vlength));
vunit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(vunit));
}
hunit = css__to_css_unit(hunit);
vunit = css__to_css_unit(vunit);
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_border_spacing(state->computed, value,
hlength, hunit, vlength, vunit);
}
return CSS_OK;
}
css_error css__cascade_table_layout(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_TABLE_LAYOUT_INHERIT;
UNUSED(style);
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case TABLE_LAYOUT_AUTO:
value = CSS_TABLE_LAYOUT_AUTO;
break;
case TABLE_LAYOUT_FIXED:
value = CSS_TABLE_LAYOUT_FIXED;
break;
}
}
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_table_layout(state->computed, value);
}
return CSS_OK;
}
css_error css__cascade_overflow_y(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_OVERFLOW_INHERIT;
UNUSED(style);
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case OVERFLOW_VISIBLE:
value = CSS_OVERFLOW_VISIBLE;
break;
case OVERFLOW_HIDDEN:
value = CSS_OVERFLOW_HIDDEN;
break;
case OVERFLOW_SCROLL:
value = CSS_OVERFLOW_SCROLL;
break;
case OVERFLOW_AUTO:
value = CSS_OVERFLOW_AUTO;
break;
}
}
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_overflow_y(state->computed, value);
}
return CSS_OK;
}
css_error css__cascade_column_rule_style(uint32_t opv, css_style *style,
css_select_state *state)
{
UNUSED(style);
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case COLUMN_RULE_STYLE_NONE:
case COLUMN_RULE_STYLE_HIDDEN:
case COLUMN_RULE_STYLE_DOTTED:
case COLUMN_RULE_STYLE_DASHED:
case COLUMN_RULE_STYLE_SOLID:
case COLUMN_RULE_STYLE_DOUBLE:
case COLUMN_RULE_STYLE_GROOVE:
case COLUMN_RULE_STYLE_RIDGE:
case COLUMN_RULE_STYLE_INSET:
case COLUMN_RULE_STYLE_OUTSET:
/** \todo convert to public values */
break;
}
}
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
/** \todo set computed elevation */
}
return CSS_OK;
}
css_error css__cascade_background_attachment(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_BACKGROUND_ATTACHMENT_INHERIT;
UNUSED(style);
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case BACKGROUND_ATTACHMENT_FIXED:
value = CSS_BACKGROUND_ATTACHMENT_FIXED;
break;
case BACKGROUND_ATTACHMENT_SCROLL:
value = CSS_BACKGROUND_ATTACHMENT_SCROLL;
break;
}
}
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_background_attachment(state->computed, value);
}
return CSS_OK;
}
css_error css__cascade_pitch(uint32_t opv, css_style *style,
css_select_state *state)
{
css_fixed freq = 0;
uint32_t unit = UNIT_HZ;
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case PITCH_FREQUENCY:
freq = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(freq));
unit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(unit));
break;
case PITCH_X_LOW:
case PITCH_LOW:
case PITCH_MEDIUM:
case PITCH_HIGH:
case PITCH_X_HIGH:
/** \todo convert to public values */
break;
}
}
unit = css__to_css_unit(unit);
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
/** \todo pitch */
}
return CSS_OK;
}
css_error css__cascade_visibility(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_VISIBILITY_INHERIT;
UNUSED(style);
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case VISIBILITY_VISIBLE:
value = CSS_VISIBILITY_VISIBLE;
break;
case VISIBILITY_HIDDEN:
value = CSS_VISIBILITY_HIDDEN;
break;
case VISIBILITY_COLLAPSE:
value = CSS_VISIBILITY_COLLAPSE;
break;
}
}
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_visibility(state->computed, value);
}
return CSS_OK;
}
css_error css__cascade_caption_side(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_CAPTION_SIDE_INHERIT;
UNUSED(style);
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case CAPTION_SIDE_TOP:
value = CSS_CAPTION_SIDE_TOP;
break;
case CAPTION_SIDE_BOTTOM:
value = CSS_CAPTION_SIDE_BOTTOM;
break;
}
}
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_caption_side(state->computed, value);
}
return CSS_OK;
}
css_error css__cascade_writing_mode(uint32_t opv, css_style *style,
css_select_state *state)
{
bool inherit = isInherit(opv);
uint16_t writing_mode = CSS_WRITING_MODE_INHERIT;
UNUSED(style);
if (inherit == false) {
switch (getValue(opv)) {
case WRITING_MODE_HORIZONTAL_TB:
writing_mode = CSS_WRITING_MODE_HORIZONTAL_TB;
break;
case WRITING_MODE_VERTICAL_RL:
writing_mode = CSS_WRITING_MODE_VERTICAL_RL;
break;
case WRITING_MODE_VERTICAL_LR:
writing_mode = CSS_WRITING_MODE_VERTICAL_LR;
break;
}
}
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
inherit)) {
return set_writing_mode(state->computed, writing_mode);
}
return CSS_OK;
}
css_error css__cascade_color(uint32_t opv, css_style *style,
css_select_state *state)
{
bool inherit = isInherit(opv);
uint16_t value = CSS_COLOR_INHERIT;
css_color color = 0;
if (inherit == false) {
switch (getValue(opv)) {
case COLOR_TRANSPARENT:
value = CSS_COLOR_COLOR;
break;
case COLOR_CURRENT_COLOR:
/* color: currentColor always computes to inherit */
value = CSS_COLOR_INHERIT;
inherit = true;
break;
case COLOR_SET:
value = CSS_COLOR_COLOR;
color = *((css_color *) style->bytecode);
advance_bytecode(style, sizeof(color));
break;
}
}
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
inherit)) {
return set_color(state->computed, value, color);
}
return CSS_OK;
}
css_error css__cascade_opacity(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_OPACITY_INHERIT;
css_fixed opacity = 0;
if (isInherit(opv) == false) {
value = CSS_Z_INDEX_SET;
opacity = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(opacity));
}
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_opacity(state->computed, value, opacity);
}
return CSS_OK;
}
css_error css__cascade_azimuth(uint32_t opv, css_style *style,
css_select_state *state)
{
css_fixed val = 0;
uint32_t unit = UNIT_DEG;
if (isInherit(opv) == false) {
switch (getValue(opv) & ~AZIMUTH_BEHIND) {
case AZIMUTH_ANGLE:
val = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(val));
unit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(unit));
break;
case AZIMUTH_LEFTWARDS:
case AZIMUTH_RIGHTWARDS:
case AZIMUTH_LEFT_SIDE:
case AZIMUTH_FAR_LEFT:
case AZIMUTH_LEFT:
case AZIMUTH_CENTER_LEFT:
case AZIMUTH_CENTER:
case AZIMUTH_CENTER_RIGHT:
case AZIMUTH_RIGHT:
case AZIMUTH_FAR_RIGHT:
case AZIMUTH_RIGHT_SIDE:
/** \todo azimuth values */
break;
}
/** \todo azimuth behind */
}
unit = css__to_css_unit(unit);
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
/** \todo set computed azimuth */
}
return CSS_OK;
}
css_error css__cascade_text_align(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_TEXT_ALIGN_INHERIT;
UNUSED(style);
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case TEXT_ALIGN_LEFT:
value = CSS_TEXT_ALIGN_LEFT;
break;
case TEXT_ALIGN_RIGHT:
value = CSS_TEXT_ALIGN_RIGHT;
break;
case TEXT_ALIGN_CENTER:
value = CSS_TEXT_ALIGN_CENTER;
break;
case TEXT_ALIGN_JUSTIFY:
value = CSS_TEXT_ALIGN_JUSTIFY;
break;
case TEXT_ALIGN_LIBCSS_LEFT:
value = CSS_TEXT_ALIGN_LIBCSS_LEFT;
break;
case TEXT_ALIGN_LIBCSS_CENTER:
value = CSS_TEXT_ALIGN_LIBCSS_CENTER;
break;
case TEXT_ALIGN_LIBCSS_RIGHT:
value = CSS_TEXT_ALIGN_LIBCSS_RIGHT;
break;
}
}
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_text_align(state->computed, value);
}
return CSS_OK;
}
css_error css__cascade_volume(uint32_t opv, css_style *style,
css_select_state *state)
{
css_fixed val = 0;
uint32_t unit = UNIT_PCT;
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case VOLUME_NUMBER:
val = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(val));
break;
case VOLUME_DIMENSION:
val = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(val));
unit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(unit));
break;
case VOLUME_SILENT:
case VOLUME_X_SOFT:
case VOLUME_SOFT:
case VOLUME_MEDIUM:
case VOLUME_LOUD:
case VOLUME_X_LOUD:
/** \todo convert to public values */
break;
}
}
unit = css__to_css_unit(unit);
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
/** \todo volume */
}
return CSS_OK;
}
css_error css__cascade_cursor(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_CURSOR_INHERIT;
lwc_string **uris = NULL;
uint32_t n_uris = 0;
if (isInherit(opv) == false) {
uint32_t v = getValue(opv);
while (v == CURSOR_URI) {
lwc_string *uri;
lwc_string **temp;
css__stylesheet_string_get(style->sheet,
*((css_code_t *) style->bytecode),
&uri);
advance_bytecode(style, sizeof(css_code_t));
temp = realloc(uris,
(n_uris + 1) * sizeof(lwc_string *));
if (temp == NULL) {
if (uris != NULL) {
free(uris);
}
return CSS_NOMEM;
}
uris = temp;
uris[n_uris] = uri;
n_uris++;
v = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(v));
}
switch (v) {
case CURSOR_AUTO:
value = CSS_CURSOR_AUTO;
break;
case CURSOR_CROSSHAIR:
value = CSS_CURSOR_CROSSHAIR;
break;
case CURSOR_DEFAULT:
value = CSS_CURSOR_DEFAULT;
break;
case CURSOR_POINTER:
value = CSS_CURSOR_POINTER;
break;
case CURSOR_MOVE:
value = CSS_CURSOR_MOVE;
break;
case CURSOR_E_RESIZE:
value = CSS_CURSOR_E_RESIZE;
break;
case CURSOR_NE_RESIZE:
value = CSS_CURSOR_NE_RESIZE;
break;
case CURSOR_NW_RESIZE:
value = CSS_CURSOR_NW_RESIZE;
break;
case CURSOR_N_RESIZE:
value = CSS_CURSOR_N_RESIZE;
break;
case CURSOR_SE_RESIZE:
value = CSS_CURSOR_SE_RESIZE;
break;
case CURSOR_SW_RESIZE:
value = CSS_CURSOR_SW_RESIZE;
break;
case CURSOR_S_RESIZE:
value = CSS_CURSOR_S_RESIZE;
break;
case CURSOR_W_RESIZE:
value = CSS_CURSOR_W_RESIZE;
break;
case CURSOR_TEXT:
value = CSS_CURSOR_TEXT;
break;
case CURSOR_WAIT:
value = CSS_CURSOR_WAIT;
break;
case CURSOR_HELP:
value = CSS_CURSOR_HELP;
break;
case CURSOR_PROGRESS:
value = CSS_CURSOR_PROGRESS;
break;
}
}
/* Terminate array with blank entry, if needed */
if (n_uris > 0) {
lwc_string **temp;
temp = realloc(uris,
(n_uris + 1) * sizeof(lwc_string *));
if (temp == NULL) {
free(uris);
return CSS_NOMEM;
}
uris = temp;
uris[n_uris] = NULL;
}
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
css_error error;
error = set_cursor(state->computed, value, uris);
if (error != CSS_OK && n_uris > 0)
free(uris);
return error;
} else {
if (n_uris > 0)
free(uris);
}
return CSS_OK;
}
/**
* Make a style important
*
* \param style The style to modify
*/
void css__make_style_important(css_style *style)
{
css_code_t *bytecode = style->bytecode;
uint32_t length = style->used;
uint32_t offset = 0;
while (offset < length) {
opcode_t op;
uint8_t flags;
uint32_t value;
css_code_t opv = bytecode[offset];
/* Extract opv components, setting important flag */
op = getOpcode(opv);
flags = getFlags(opv) | FLAG_IMPORTANT;
value = getValue(opv);
/* Write OPV back to bytecode */
bytecode[offset] = buildOPV(op, flags, value);
offset++;
/* Advance past any property-specific data */
if (isInherit(opv) == false) {
switch (op) {
case CSS_PROP_AZIMUTH:
if ((value & ~AZIMUTH_BEHIND) == AZIMUTH_ANGLE)
offset += 2; /* length + units */
break;
case CSS_PROP_BORDER_TOP_COLOR:
case CSS_PROP_BORDER_RIGHT_COLOR:
case CSS_PROP_BORDER_BOTTOM_COLOR:
case CSS_PROP_BORDER_LEFT_COLOR:
case CSS_PROP_BACKGROUND_COLOR:
case CSS_PROP_COLUMN_RULE_COLOR:
assert(BACKGROUND_COLOR_SET ==
(enum op_background_color)BORDER_COLOR_SET);
assert(BACKGROUND_COLOR_SET ==
(enum op_background_color)COLUMN_RULE_COLOR_SET);
if (value == BACKGROUND_COLOR_SET)
offset++; /* colour */
break;
case CSS_PROP_BACKGROUND_IMAGE:
case CSS_PROP_CUE_AFTER:
case CSS_PROP_CUE_BEFORE:
case CSS_PROP_LIST_STYLE_IMAGE:
assert(BACKGROUND_IMAGE_URI ==
(enum op_background_image)CUE_AFTER_URI);
assert(BACKGROUND_IMAGE_URI ==
(enum op_background_image)CUE_BEFORE_URI);
assert(BACKGROUND_IMAGE_URI ==
(enum op_background_image)LIST_STYLE_IMAGE_URI);
if (value == BACKGROUND_IMAGE_URI)
offset++; /* string table entry */
break;
case CSS_PROP_BACKGROUND_POSITION:
if ((value & 0xf0) == BACKGROUND_POSITION_HORZ_SET)
offset += 2; /* length + units */
if ((value & 0x0f) == BACKGROUND_POSITION_VERT_SET)
offset += 2; /* length + units */
break;
case CSS_PROP_BORDER_SPACING:
if (value == BORDER_SPACING_SET)
offset += 4; /* two length + units */
break;
case CSS_PROP_BORDER_TOP_WIDTH:
case CSS_PROP_BORDER_RIGHT_WIDTH:
case CSS_PROP_BORDER_BOTTOM_WIDTH:
case CSS_PROP_BORDER_LEFT_WIDTH:
case CSS_PROP_OUTLINE_WIDTH:
case CSS_PROP_COLUMN_RULE_WIDTH:
assert(BORDER_WIDTH_SET ==
(enum op_border_width)OUTLINE_WIDTH_SET);
assert(BORDER_WIDTH_SET ==
(enum op_border_width)COLUMN_RULE_WIDTH_SET);
if (value == BORDER_WIDTH_SET)
offset += 2; /* length + units */
break;
case CSS_PROP_MARGIN_TOP:
case CSS_PROP_MARGIN_RIGHT:
case CSS_PROP_MARGIN_BOTTOM:
case CSS_PROP_MARGIN_LEFT:
case CSS_PROP_BOTTOM:
case CSS_PROP_LEFT:
case CSS_PROP_RIGHT:
case CSS_PROP_TOP:
case CSS_PROP_HEIGHT:
case CSS_PROP_WIDTH:
case CSS_PROP_COLUMN_WIDTH:
case CSS_PROP_COLUMN_GAP:
assert(BOTTOM_SET == (enum op_bottom)LEFT_SET);
assert(BOTTOM_SET == (enum op_bottom)RIGHT_SET);
assert(BOTTOM_SET == (enum op_bottom)TOP_SET);
assert(BOTTOM_SET == (enum op_bottom)HEIGHT_SET);
assert(BOTTOM_SET == (enum op_bottom)MARGIN_SET);
assert(BOTTOM_SET == (enum op_bottom)WIDTH_SET);
assert(BOTTOM_SET == (enum op_bottom)COLUMN_WIDTH_SET);
assert(BOTTOM_SET == (enum op_bottom)COLUMN_GAP_SET);
if (value == BOTTOM_SET)
offset += 2; /* length + units */
break;
case CSS_PROP_CLIP:
if ((value & CLIP_SHAPE_MASK) == CLIP_SHAPE_RECT) {
if ((value & CLIP_RECT_TOP_AUTO) == 0)
offset += 2; /* length + units */
if ((value & CLIP_RECT_RIGHT_AUTO) == 0)
offset += 2; /* length + units */
if ((value & CLIP_RECT_BOTTOM_AUTO) == 0)
offset += 2; /* length + units */
if ((value & CLIP_RECT_LEFT_AUTO) == 0)
offset += 2; /* length + units */
}
break;
case CSS_PROP_COLOR:
if (value == COLOR_SET)
offset++; /* colour */
break;
case CSS_PROP_COLUMN_COUNT:
if (value == COLUMN_COUNT_SET)
offset++; /* colour */
break;
case CSS_PROP_CONTENT:
while (value != CONTENT_NORMAL &&
value != CONTENT_NONE) {
switch (value & 0xff) {
case CONTENT_COUNTER:
case CONTENT_URI:
case CONTENT_ATTR:
case CONTENT_STRING:
offset++; /* string table entry */
break;
case CONTENT_COUNTERS:
offset+=2; /* two string entries */
break;
case CONTENT_OPEN_QUOTE:
case CONTENT_CLOSE_QUOTE:
case CONTENT_NO_OPEN_QUOTE:
case CONTENT_NO_CLOSE_QUOTE:
break;
}
value = bytecode[offset];
offset++;
}
break;
case CSS_PROP_COUNTER_INCREMENT:
case CSS_PROP_COUNTER_RESET:
assert(COUNTER_INCREMENT_NONE ==
(enum op_counter_increment)COUNTER_RESET_NONE);
while (value != COUNTER_INCREMENT_NONE) {
offset+=2; /* string + integer */
value = bytecode[offset];
offset++;
}
break;
case CSS_PROP_CURSOR:
while (value == CURSOR_URI) {
offset++; /* string table entry */
value = bytecode[offset];
offset++;
}
break;
case CSS_PROP_ELEVATION:
if (value == ELEVATION_ANGLE)
offset += 2; /* length + units */
break;
case CSS_PROP_FONT_FAMILY:
while (value != FONT_FAMILY_END) {
switch (value) {
case FONT_FAMILY_STRING:
case FONT_FAMILY_IDENT_LIST:
offset++; /* string table entry */
break;
}
value = bytecode[offset];
offset++;
}
break;
case CSS_PROP_FONT_SIZE:
if (value == FONT_SIZE_DIMENSION)
offset += 2; /* length + units */
break;
case CSS_PROP_LETTER_SPACING:
case CSS_PROP_WORD_SPACING:
assert(LETTER_SPACING_SET ==
(enum op_letter_spacing)WORD_SPACING_SET);
if (value == LETTER_SPACING_SET)
offset += 2; /* length + units */
break;
case CSS_PROP_LINE_HEIGHT:
switch (value) {
case LINE_HEIGHT_NUMBER:
offset++; /* value */
break;
case LINE_HEIGHT_DIMENSION:
offset += 2; /* length + units */
break;
}
break;
case CSS_PROP_MAX_HEIGHT:
case CSS_PROP_MAX_WIDTH:
assert(MAX_HEIGHT_SET ==
(enum op_max_height)MAX_WIDTH_SET);
if (value == MAX_HEIGHT_SET)
offset += 2; /* length + units */
break;
case CSS_PROP_PADDING_TOP:
case CSS_PROP_PADDING_RIGHT:
case CSS_PROP_PADDING_BOTTOM:
case CSS_PROP_PADDING_LEFT:
case CSS_PROP_MIN_HEIGHT:
case CSS_PROP_MIN_WIDTH:
case CSS_PROP_PAUSE_AFTER:
case CSS_PROP_PAUSE_BEFORE:
case CSS_PROP_TEXT_INDENT:
assert(MIN_HEIGHT_SET == (enum op_min_height)MIN_WIDTH_SET);
assert(MIN_HEIGHT_SET == (enum op_min_height)PADDING_SET);
assert(MIN_HEIGHT_SET == (enum op_min_height)PAUSE_AFTER_SET);
assert(MIN_HEIGHT_SET == (enum op_min_height)PAUSE_BEFORE_SET);
assert(MIN_HEIGHT_SET == (enum op_min_height)TEXT_INDENT_SET);
if (value == MIN_HEIGHT_SET)
offset += 2; /* length + units */
break;
case CSS_PROP_OPACITY:
if (value == OPACITY_SET)
offset++; /* value */
break;
case CSS_PROP_ORPHANS:
case CSS_PROP_PITCH_RANGE:
case CSS_PROP_RICHNESS:
case CSS_PROP_STRESS:
case CSS_PROP_WIDOWS:
case CSS_PROP_FLEX_GROW:
case CSS_PROP_FLEX_SHRINK:
case CSS_PROP_FLEX_BASIS:
assert(ORPHANS_SET == (enum op_orphans)PITCH_RANGE_SET);
assert(ORPHANS_SET == (enum op_orphans)RICHNESS_SET);
assert(ORPHANS_SET == (enum op_orphans)STRESS_SET);
assert(ORPHANS_SET == (enum op_orphans)WIDOWS_SET);
assert(ORPHANS_SET == (enum op_orphans)FLEX_GROW_SET);
assert(ORPHANS_SET == (enum op_orphans)FLEX_SHRINK_SET);
assert(ORPHANS_SET == (enum op_orphans)FLEX_BASIS_SET);
if (value == ORPHANS_SET)
offset++; /* value */
break;
case CSS_PROP_OUTLINE_COLOR:
if (value == OUTLINE_COLOR_SET)
offset++; /* color */
break;
case CSS_PROP_PITCH:
if (value == PITCH_FREQUENCY)
offset += 2; /* length + units */
break;
case CSS_PROP_PLAY_DURING:
if (value & PLAY_DURING_URI)
offset++; /* string table entry */
break;
case CSS_PROP_QUOTES:
while (value != QUOTES_NONE) {
offset += 2; /* two string table entries */
value = bytecode[offset];
offset++;
}
break;
case CSS_PROP_SPEECH_RATE:
if (value == SPEECH_RATE_SET)
offset++; /* rate */
break;
case CSS_PROP_VERTICAL_ALIGN:
if (value == VERTICAL_ALIGN_SET)
offset += 2; /* length + units */
break;
case CSS_PROP_VOICE_FAMILY:
while (value != VOICE_FAMILY_END) {
switch (value) {
case VOICE_FAMILY_STRING:
case VOICE_FAMILY_IDENT_LIST:
offset++; /* string table entry */
break;
}
value = bytecode[offset];
offset++;
}
break;
case CSS_PROP_VOLUME:
switch (value) {
case VOLUME_NUMBER:
offset++; /* value */
break;
case VOLUME_DIMENSION:
offset += 2; /* value + units */
break;
}
break;
case CSS_PROP_Z_INDEX:
if (value == Z_INDEX_SET)
offset++; /* z index */
break;
default:
break;
}
}
}
}
css_error css__cascade_font_family(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_FONT_FAMILY_INHERIT;
lwc_string **fonts = NULL;
uint32_t n_fonts = 0;
if (isInherit(opv) == false) {
uint32_t v = getValue(opv);
while (v != FONT_FAMILY_END) {
lwc_string *font = NULL;
lwc_string **temp;
switch (v) {
case FONT_FAMILY_STRING:
case FONT_FAMILY_IDENT_LIST:
css__stylesheet_string_get(style->sheet,
*((css_code_t *) style->bytecode),
&font);
advance_bytecode(style, sizeof(css_code_t));
break;
case FONT_FAMILY_SERIF:
if (value == CSS_FONT_FAMILY_INHERIT)
value = CSS_FONT_FAMILY_SERIF;
break;
case FONT_FAMILY_SANS_SERIF:
if (value == CSS_FONT_FAMILY_INHERIT)
value = CSS_FONT_FAMILY_SANS_SERIF;
break;
case FONT_FAMILY_CURSIVE:
if (value == CSS_FONT_FAMILY_INHERIT)
value = CSS_FONT_FAMILY_CURSIVE;
break;
case FONT_FAMILY_FANTASY:
if (value == CSS_FONT_FAMILY_INHERIT)
value = CSS_FONT_FAMILY_FANTASY;
break;
case FONT_FAMILY_MONOSPACE:
if (value == CSS_FONT_FAMILY_INHERIT)
value = CSS_FONT_FAMILY_MONOSPACE;
break;
}
/* Only use family-names which occur before the first
* generic-family. Any values which occur after the
* first generic-family are ignored. */
/** \todo Do this at bytecode generation time? */
if (value == CSS_FONT_FAMILY_INHERIT && font != NULL) {
temp = state->computed->alloc(fonts,
(n_fonts + 1) * sizeof(lwc_string *),
state->computed->pw);
if (temp == NULL) {
if (fonts != NULL) {
state->computed->alloc(fonts, 0,
state->computed->pw);
}
return CSS_NOMEM;
}
fonts = temp;
fonts[n_fonts] = font;
n_fonts++;
}
v = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(v));
}
}
/* Terminate array with blank entry, if needed */
if (n_fonts > 0) {
lwc_string **temp;
temp = state->computed->alloc(fonts,
(n_fonts + 1) * sizeof(lwc_string *),
state->computed->pw);
if (temp == NULL) {
state->computed->alloc(fonts, 0, state->computed->pw);
return CSS_NOMEM;
}
fonts = temp;
fonts[n_fonts] = NULL;
if (value == CSS_FONT_FAMILY_INHERIT) {
/* The stylesheet doesn't specify a generic family,
* but it has specified named fonts.
* Fall back to the user agent's default family.
* We don't want to inherit, because that will
* incorrectly overwrite the named fonts list too.
*/
css_hint hint;
css_error error;
error = state->handler->ua_default_for_property(
state->pw, CSS_PROP_FONT_FAMILY, &hint);
if (error == CSS_OK) {
lwc_string **item;
value = hint.status;
for (item = hint.data.strings;
item != NULL && (*item) != NULL;
item++) {
lwc_string_unref(*item);
}
if (hint.data.strings != NULL) {
state->computed->alloc(
hint.data.strings,
0, state->computed->pw);
}
}
if (value == CSS_FONT_FAMILY_INHERIT) {
/* No sane UA default: assume sans-serif */
value = CSS_FONT_FAMILY_SANS_SERIF;
}
}
}
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
css_error error;
error = set_font_family(state->computed, value, fonts);
if (error != CSS_OK && n_fonts > 0)
state->computed->alloc(fonts, 0, state->computed->pw);
return error;
} else {
if (n_fonts > 0)
state->computed->alloc(fonts, 0, state->computed->pw);
}
return CSS_OK;
}
