Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 3583 → Rev 3584

/programs/network/netsurf/libcss/src/select/properties/Makefile
0,0 → 1,120
 
OUTFILE = libo.o
 
CFLAGS += -I ../../../include/ -I ../../../../ -I ../../ -I /home/sourcerer/kos_src/newenginek/kolibri/include
 
 
OBJS = helpers.o \
azimuth.o \
background_attachment.o \
background_color.o \
background_image.o \
background_position.o \
background_repeat.o \
border_bottom_color.o \
border_bottom_style.o \
border_bottom_width.o \
border_collapse.o \
border_left_color.o \
border_left_style.o \
border_left_width.o \
border_right_color.o \
border_right_style.o \
border_right_width.o \
border_spacing.o \
border_top_color.o \
border_top_style.o \
border_top_width.o \
bottom.o \
break_after.o \
break_before.o \
break_inside.o \
caption_side.o \
clear.o \
clip.o \
color.o \
column_count.o \
column_fill.o \
column_gap.o \
column_rule_color.o \
column_rule_style.o \
column_rule_width.o \
column_span.o \
column_width.o \
content.o \
counter_increment.o \
counter_reset.o \
cue_after.o \
cue_before.o \
cursor.o \
direction.o \
display.o \
elevation.o \
empty_cells.o \
float.o \
font_family.o \
font_size.o \
font_style.o \
font_variant.o \
font_weight.o \
height.o \
left.o \
letter_spacing.o \
line_height.o \
list_style_image.o \
list_style_position.o \
list_style_type.o \
margin_bottom.o \
margin_left.o \
margin_right.o \
margin_top.o \
max_height.o \
max_width.o \
min_height.o \
min_width.o \
opacity.o \
orphans.o \
outline_color.o \
outline_style.o \
outline_width.o \
overflow.o \
padding_bottom.o \
padding_left.o \
padding_right.o \
padding_top.o \
page_break_after.o \
page_break_before.o \
page_break_inside.o \
pause_after.o \
pause_before.o \
pitch.o \
pitch_range.o \
play_during.o \
position.o \
quotes.o \
richness.o \
right.o \
speech_rate.o \
speak.o \
speak_header.o \
speak_numeral.o \
speak_punctuation.o \
stress.o \
table_layout.o \
text_align.o \
text_decoration.o \
text_indent.o \
text_transform.o \
top.o \
unicode_bidi.o \
vertical_align.o \
visibility.o \
voice_family.o \
volume.o \
white_space.o \
width.o \
windows.o \
word_spacing.o \
z_index.o
 
include $(MENUETDEV)/makefiles/Makefile_for_o_lib
/programs/network/netsurf/libcss/src/select/properties/azimuth.c
0,0 → 1,83
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
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__set_azimuth_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_azimuth(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_azimuth(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/background_attachment.c
0,0 → 1,67
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
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__set_background_attachment_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_background_attachment(style, hint->status);
}
 
css_error css__initial_background_attachment(css_select_state *state)
{
return set_background_attachment(state->computed,
CSS_BACKGROUND_ATTACHMENT_SCROLL);
}
 
css_error css__compose_background_attachment(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_background_attachment(child);
 
if (type == CSS_BACKGROUND_ATTACHMENT_INHERIT) {
type = get_background_attachment(parent);
}
 
return set_background_attachment(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/background_color.c
0,0 → 1,48
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_background_color(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_bg_border_color(opv, style, state, set_background_color);
}
 
css_error css__set_background_color_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_background_color(style, hint->status, hint->data.color);
}
 
css_error css__initial_background_color(css_select_state *state)
{
return set_background_color(state->computed,
CSS_BACKGROUND_COLOR_COLOR, 0);
}
 
css_error css__compose_background_color(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_color color;
uint8_t type = get_background_color(child, &color);
 
if (type == CSS_BACKGROUND_COLOR_INHERIT) {
type = get_background_color(parent, &color);
}
 
return set_background_color(result, type, color);
}
 
/programs/network/netsurf/libcss/src/select/properties/background_image.c
0,0 → 1,55
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_background_image(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_uri_none(opv, style, state, set_background_image);
}
 
css_error css__set_background_image_from_hint(const css_hint *hint,
css_computed_style *style)
{
css_error error;
 
error = set_background_image(style, hint->status, hint->data.string);
 
if (hint->data.string != NULL)
lwc_string_unref(hint->data.string);
 
return error;
}
 
css_error css__initial_background_image(css_select_state *state)
{
return set_background_image(state->computed,
CSS_BACKGROUND_IMAGE_NONE, NULL);
}
 
css_error css__compose_background_image(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
lwc_string *url;
uint8_t type = get_background_image(child, &url);
 
if (type == CSS_BACKGROUND_IMAGE_INHERIT) {
type = get_background_image(parent, &url);
}
 
return set_background_image(result, type, url);
}
 
/programs/network/netsurf/libcss/src/select/properties/background_position.c
0,0 → 1,116
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_background_position(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_BACKGROUND_POSITION_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_BACKGROUND_POSITION_SET;
 
switch (getValue(opv) & 0xf0) {
case BACKGROUND_POSITION_HORZ_SET:
hlength = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(hlength));
hunit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(hunit));
break;
case BACKGROUND_POSITION_HORZ_CENTER:
hlength = INTTOFIX(50);
hunit = UNIT_PCT;
break;
case BACKGROUND_POSITION_HORZ_RIGHT:
hlength = INTTOFIX(100);
hunit = UNIT_PCT;
break;
case BACKGROUND_POSITION_HORZ_LEFT:
hlength = INTTOFIX(0);
hunit = UNIT_PCT;
break;
}
 
switch (getValue(opv) & 0x0f) {
case BACKGROUND_POSITION_VERT_SET:
vlength = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(vlength));
vunit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(vunit));
break;
case BACKGROUND_POSITION_VERT_CENTER:
vlength = INTTOFIX(50);
vunit = UNIT_PCT;
break;
case BACKGROUND_POSITION_VERT_BOTTOM:
vlength = INTTOFIX(100);
vunit = UNIT_PCT;
break;
case BACKGROUND_POSITION_VERT_TOP:
vlength = INTTOFIX(0);
vunit = UNIT_PCT;
break;
}
}
 
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_background_position(state->computed, value,
hlength, hunit, vlength, vunit);
}
 
return CSS_OK;
}
 
css_error css__set_background_position_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_background_position(style, hint->status,
hint->data.position.h.value, hint->data.position.h.unit,
hint->data.position.v.value, hint->data.position.v.unit);
}
 
css_error css__initial_background_position(css_select_state *state)
{
return set_background_position(state->computed,
CSS_BACKGROUND_POSITION_SET,
0, CSS_UNIT_PCT, 0, CSS_UNIT_PCT);
}
 
css_error css__compose_background_position(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed hlength = 0, vlength = 0;
css_unit hunit = CSS_UNIT_PX, vunit = CSS_UNIT_PX;
uint8_t type = get_background_position(child, &hlength, &hunit,
&vlength, &vunit);
 
if (type == CSS_BACKGROUND_POSITION_INHERIT) {
type = get_background_position(parent,
&hlength, &hunit, &vlength, &vunit);
}
 
return set_background_position(result, type, hlength, hunit,
vlength, vunit);
}
 
/programs/network/netsurf/libcss/src/select/properties/background_repeat.c
0,0 → 1,73
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_background_repeat(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_BACKGROUND_REPEAT_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case BACKGROUND_REPEAT_NO_REPEAT:
value = CSS_BACKGROUND_REPEAT_NO_REPEAT;
break;
case BACKGROUND_REPEAT_REPEAT_X:
value = CSS_BACKGROUND_REPEAT_REPEAT_X;
break;
case BACKGROUND_REPEAT_REPEAT_Y:
value = CSS_BACKGROUND_REPEAT_REPEAT_Y;
break;
case BACKGROUND_REPEAT_REPEAT:
value = CSS_BACKGROUND_REPEAT_REPEAT;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_background_repeat(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_background_repeat_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_background_repeat(style, hint->status);
}
 
css_error css__initial_background_repeat(css_select_state *state)
{
return set_background_repeat(state->computed,
CSS_BACKGROUND_REPEAT_REPEAT);
}
 
css_error css__compose_background_repeat(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_background_repeat(child);
 
if (type == CSS_BACKGROUND_REPEAT_INHERIT) {
type = get_background_repeat(parent);
}
 
return set_background_repeat(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/border_bottom_color.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_border_bottom_color(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_bg_border_color(opv, style, state,
set_border_bottom_color);
}
 
css_error css__set_border_bottom_color_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_border_bottom_color(style, hint->status, hint->data.color);
}
 
css_error css__initial_border_bottom_color(css_select_state *state)
{
return set_border_bottom_color(state->computed,
CSS_BORDER_COLOR_CURRENT_COLOR, 0);
}
 
css_error css__compose_border_bottom_color(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_color color;
uint8_t type = get_border_bottom_color(child, &color);
 
if (type == CSS_BORDER_COLOR_INHERIT) {
type = get_border_bottom_color(parent, &color);
}
 
return set_border_bottom_color(result, type, color);
}
 
/programs/network/netsurf/libcss/src/select/properties/border_bottom_style.c
0,0 → 1,46
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_border_bottom_style(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_border_style(opv, style, state, set_border_bottom_style);
}
 
css_error css__set_border_bottom_style_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_border_bottom_style(style, hint->status);
}
 
css_error css__initial_border_bottom_style(css_select_state *state)
{
return set_border_bottom_style(state->computed, CSS_BORDER_STYLE_NONE);
}
 
css_error css__compose_border_bottom_style(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_border_bottom_style(child);
 
if (type == CSS_BORDER_STYLE_INHERIT) {
type = get_border_bottom_style(parent);
}
 
return set_border_bottom_style(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/border_bottom_width.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_border_bottom_width(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_border_width(opv, style, state, set_border_bottom_width);
}
 
css_error css__set_border_bottom_width_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_border_bottom_width(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_border_bottom_width(css_select_state *state)
{
return set_border_bottom_width(state->computed, CSS_BORDER_WIDTH_MEDIUM,
0, CSS_UNIT_PX);
}
 
css_error css__compose_border_bottom_width(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_border_bottom_width(child, &length, &unit);
 
if (type == CSS_BORDER_WIDTH_INHERIT) {
type = get_border_bottom_width(parent, &length, &unit);
}
 
return set_border_bottom_width(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/border_collapse.c
0,0 → 1,66
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_border_collapse(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_BORDER_COLLAPSE_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case BORDER_COLLAPSE_SEPARATE:
value = CSS_BORDER_COLLAPSE_SEPARATE;
break;
case BORDER_COLLAPSE_COLLAPSE:
value = CSS_BORDER_COLLAPSE_COLLAPSE;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_border_collapse(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_border_collapse_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_border_collapse(style, hint->status);
}
 
css_error css__initial_border_collapse(css_select_state *state)
{
return set_border_collapse(state->computed, CSS_BORDER_COLLAPSE_SEPARATE);
}
 
css_error css__compose_border_collapse(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_border_collapse(child);
 
if (type == CSS_BORDER_COLLAPSE_INHERIT) {
type = get_border_collapse(parent);
}
return set_border_collapse(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/border_left_color.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_border_left_color(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_bg_border_color(opv, style, state,
set_border_left_color);
}
 
css_error css__set_border_left_color_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_border_left_color(style, hint->status, hint->data.color);
}
 
css_error css__initial_border_left_color(css_select_state *state)
{
return set_border_left_color(state->computed,
CSS_BORDER_COLOR_CURRENT_COLOR, 0);
}
 
css_error css__compose_border_left_color(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_color color;
uint8_t type = get_border_left_color(child, &color);
 
if (type == CSS_BORDER_COLOR_INHERIT) {
type = get_border_left_color(parent, &color);
}
 
return set_border_left_color(result, type, color);
}
 
/programs/network/netsurf/libcss/src/select/properties/border_left_style.c
0,0 → 1,46
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_border_left_style(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_border_style(opv, style, state, set_border_left_style);
}
 
css_error css__set_border_left_style_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_border_left_style(style, hint->status);
}
 
css_error css__initial_border_left_style(css_select_state *state)
{
return set_border_left_style(state->computed, CSS_BORDER_STYLE_NONE);
}
 
css_error css__compose_border_left_style(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_border_left_style(child);
 
if (type == CSS_BORDER_STYLE_INHERIT) {
type = get_border_left_style(parent);
}
 
return set_border_left_style(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/border_left_width.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_border_left_width(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_border_width(opv, style, state, set_border_left_width);
}
 
css_error css__set_border_left_width_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_border_left_width(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_border_left_width(css_select_state *state)
{
return set_border_left_width(state->computed, CSS_BORDER_WIDTH_MEDIUM,
0, CSS_UNIT_PX);
}
 
css_error css__compose_border_left_width(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_border_left_width(child, &length, &unit);
 
if (type == CSS_BORDER_WIDTH_INHERIT) {
type = get_border_left_width(parent, &length, &unit);
}
 
return set_border_left_width(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/border_right_color.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_border_right_color(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_bg_border_color(opv, style, state,
set_border_right_color);
}
 
css_error css__set_border_right_color_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_border_right_color(style, hint->status, hint->data.color);
}
 
css_error css__initial_border_right_color(css_select_state *state)
{
return set_border_right_color(state->computed,
CSS_BORDER_COLOR_CURRENT_COLOR, 0);
}
 
css_error css__compose_border_right_color(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_color color;
uint8_t type = get_border_right_color(child, &color);
 
if (type == CSS_BORDER_COLOR_INHERIT) {
type = get_border_right_color(parent, &color);
}
 
return set_border_right_color(result, type, color);
}
 
/programs/network/netsurf/libcss/src/select/properties/border_right_style.c
0,0 → 1,46
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_border_right_style(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_border_style(opv, style, state, set_border_right_style);
}
 
css_error css__set_border_right_style_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_border_right_style(style, hint->status);
}
 
css_error css__initial_border_right_style(css_select_state *state)
{
return set_border_right_style(state->computed, CSS_BORDER_STYLE_NONE);
}
 
css_error css__compose_border_right_style(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_border_right_style(child);
 
if (type == CSS_BORDER_STYLE_INHERIT) {
type = get_border_right_style(parent);
}
 
return set_border_right_style(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/border_right_width.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_border_right_width(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_border_width(opv, style, state, set_border_right_width);
}
 
css_error css__set_border_right_width_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_border_right_width(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_border_right_width(css_select_state *state)
{
return set_border_right_width(state->computed, CSS_BORDER_WIDTH_MEDIUM,
0, CSS_UNIT_PX);
}
 
css_error css__compose_border_right_width(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_border_right_width(child, &length, &unit);
 
if (type == CSS_BORDER_WIDTH_INHERIT) {
type = get_border_right_width(parent, &length, &unit);
}
 
return set_border_right_width(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/border_spacing.c
0,0 → 1,89
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
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__set_border_spacing_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_border_spacing(style, hint->status,
hint->data.position.h.value, hint->data.position.h.unit,
hint->data.position.v.value, hint->data.position.v.unit);
}
 
css_error css__initial_border_spacing(css_select_state *state)
{
return set_border_spacing(state->computed, CSS_BORDER_SPACING_SET,
0, CSS_UNIT_PX, 0, CSS_UNIT_PX);
}
 
css_error css__compose_border_spacing(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed hlength = 0, vlength = 0;
css_unit hunit = CSS_UNIT_PX, vunit = CSS_UNIT_PX;
uint8_t type = get_border_spacing(child, &hlength, &hunit,
&vlength, &vunit);
 
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_BORDER_SPACING_INHERIT ||
(child->uncommon != NULL && result != child)) {
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_BORDER_SPACING_INHERIT) {
type = get_border_spacing(parent,
&hlength, &hunit, &vlength, &vunit);
}
 
return set_border_spacing(result, type, hlength, hunit,
vlength, vunit);
}
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/border_top_color.c
0,0 → 1,47
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_border_top_color(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_bg_border_color(opv, style, state, set_border_top_color);
}
 
css_error css__set_border_top_color_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_border_top_color(style, hint->status, hint->data.color);
}
 
css_error css__initial_border_top_color(css_select_state *state)
{
return set_border_top_color(state->computed, CSS_BORDER_COLOR_CURRENT_COLOR, 0);
}
 
css_error css__compose_border_top_color(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_color color;
uint8_t type = get_border_top_color(child, &color);
 
if (type == CSS_BORDER_COLOR_INHERIT) {
type = get_border_top_color(parent, &color);
}
 
return set_border_top_color(result, type, color);
}
 
/programs/network/netsurf/libcss/src/select/properties/border_top_style.c
0,0 → 1,46
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_border_top_style(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_border_style(opv, style, state, set_border_top_style);
}
 
css_error css__set_border_top_style_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_border_top_style(style, hint->status);
}
 
css_error css__initial_border_top_style(css_select_state *state)
{
return set_border_top_style(state->computed, CSS_BORDER_STYLE_NONE);
}
 
css_error css__compose_border_top_style(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_border_top_style(child);
 
if (type == CSS_BORDER_STYLE_INHERIT) {
type = get_border_top_style(parent);
}
 
return set_border_top_style(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/border_top_width.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_border_top_width(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_border_width(opv, style, state, set_border_top_width);
}
 
css_error css__set_border_top_width_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_border_top_width(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_border_top_width(css_select_state *state)
{
return set_border_top_width(state->computed, CSS_BORDER_WIDTH_MEDIUM,
0, CSS_UNIT_PX);
}
 
css_error css__compose_border_top_width(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_border_top_width(child, &length, &unit);
 
if (type == CSS_BORDER_WIDTH_INHERIT) {
type = get_border_top_width(parent, &length, &unit);
}
 
return set_border_top_width(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/bottom.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_bottom(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length_auto(opv, style, state, set_bottom);
}
 
css_error css__set_bottom_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_bottom(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_bottom(css_select_state *state)
{
return set_bottom(state->computed, CSS_BOTTOM_AUTO, 0, CSS_UNIT_PX);
}
 
css_error css__compose_bottom(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_bottom(child, &length, &unit);
 
if (type == CSS_BOTTOM_INHERIT) {
type = get_bottom(parent, &length, &unit);
}
 
return set_bottom(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/break_after.c
0,0 → 1,72
/*
* This file is part of LibCSS
* Licensed under the MIT License,
* http://www.opensource.org/licenses/mit-license.php
* Copyright 2012 Michael Drake <tlsa@netsurf-browser.org>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_break_after(uint32_t opv, css_style *style,
css_select_state *state)
{
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case BREAK_AFTER_AUTO:
case BREAK_AFTER_ALWAYS:
case BREAK_AFTER_AVOID:
case BREAK_AFTER_LEFT:
case BREAK_AFTER_RIGHT:
case BREAK_AFTER_PAGE:
case BREAK_AFTER_COLUMN:
case BREAK_AFTER_AVOID_PAGE:
case BREAK_AFTER_AVOID_COLUMN:
/** \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__set_break_after_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_break_after(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_break_after(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/break_before.c
0,0 → 1,72
/*
* This file is part of LibCSS
* Licensed under the MIT License,
* http://www.opensource.org/licenses/mit-license.php
* Copyright 2012 Michael Drake <tlsa@netsurf-browser.org>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_break_before(uint32_t opv, css_style *style,
css_select_state *state)
{
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case BREAK_BEFORE_AUTO:
case BREAK_BEFORE_ALWAYS:
case BREAK_BEFORE_AVOID:
case BREAK_BEFORE_LEFT:
case BREAK_BEFORE_RIGHT:
case BREAK_BEFORE_PAGE:
case BREAK_BEFORE_COLUMN:
case BREAK_BEFORE_AVOID_PAGE:
case BREAK_BEFORE_AVOID_COLUMN:
/** \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__set_break_before_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_break_before(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_break_before(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/break_inside.c
0,0 → 1,67
/*
* This file is part of LibCSS
* Licensed under the MIT License,
* http://www.opensource.org/licenses/mit-license.php
* Copyright 2012 Michael Drake <tlsa@netsurf-browser.org>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_break_inside(uint32_t opv, css_style *style,
css_select_state *state)
{
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case BREAK_INSIDE_AUTO:
case BREAK_INSIDE_AVOID:
case BREAK_INSIDE_AVOID_PAGE:
case BREAK_INSIDE_AVOID_COLUMN:
/** \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__set_break_inside_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_break_inside(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_break_inside(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/caption_side.c
0,0 → 1,66
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
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__set_caption_side_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_caption_side(style, hint->status);
}
 
css_error css__initial_caption_side(css_select_state *state)
{
return set_caption_side(state->computed, CSS_CAPTION_SIDE_TOP);
}
 
css_error css__compose_caption_side(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_caption_side(child);
 
if (type == CSS_CAPTION_SIDE_INHERIT) {
type = get_caption_side(parent);
}
return set_caption_side(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/clear.c
0,0 → 1,72
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_clear(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_CLEAR_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case CLEAR_NONE:
value = CSS_CLEAR_NONE;
break;
case CLEAR_LEFT:
value = CSS_CLEAR_LEFT;
break;
case CLEAR_RIGHT:
value = CSS_CLEAR_RIGHT;
break;
case CLEAR_BOTH:
value = CSS_CLEAR_BOTH;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_clear(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_clear_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_clear(style, hint->status);
}
 
css_error css__initial_clear(css_select_state *state)
{
return set_clear(state->computed, CSS_CLEAR_NONE);
}
 
css_error css__compose_clear(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_clear(child);
 
if (type == CSS_CLEAR_INHERIT) {
type = get_clear(parent);
}
 
return set_clear(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/clip.c
0,0 → 1,118
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_clip(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_CLIP_INHERIT;
css_computed_clip_rect rect = { 0, 0, 0, 0,
CSS_UNIT_PX, CSS_UNIT_PX, CSS_UNIT_PX, CSS_UNIT_PX,
false, false, false, false };
 
if (isInherit(opv) == false) {
switch (getValue(opv) & CLIP_SHAPE_MASK) {
case CLIP_SHAPE_RECT:
if (getValue(opv) & CLIP_RECT_TOP_AUTO) {
rect.top_auto = true;
} else {
rect.top = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(css_fixed));
rect.tunit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(uint32_t));
}
if (getValue(opv) & CLIP_RECT_RIGHT_AUTO) {
rect.right_auto = true;
} else {
rect.right = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(css_fixed));
rect.runit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(uint32_t));
}
if (getValue(opv) & CLIP_RECT_BOTTOM_AUTO) {
rect.bottom_auto = true;
} else {
rect.bottom = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(css_fixed));
rect.bunit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(uint32_t));
}
if (getValue(opv) & CLIP_RECT_LEFT_AUTO) {
rect.left_auto = true;
} else {
rect.left = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(css_fixed));
rect.lunit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(uint32_t));
}
value = CSS_CLIP_RECT;
break;
case CLIP_AUTO:
value = CSS_CLIP_AUTO;
break;
}
}
 
rect.tunit = css__to_css_unit(rect.tunit);
rect.runit = css__to_css_unit(rect.runit);
rect.bunit = css__to_css_unit(rect.bunit);
rect.lunit = css__to_css_unit(rect.lunit);
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_clip(state->computed, value, &rect);
}
 
return CSS_OK;
}
 
css_error css__set_clip_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_clip(style, hint->status, hint->data.clip);
}
 
css_error css__initial_clip(css_select_state *state)
{
css_computed_clip_rect rect = { 0, 0, 0, 0,
CSS_UNIT_PX, CSS_UNIT_PX, CSS_UNIT_PX, CSS_UNIT_PX,
false, false, false, false };
 
return set_clip(state->computed, CSS_CLIP_AUTO, &rect);
}
 
css_error css__compose_clip(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_computed_clip_rect rect = { 0, 0, 0, 0,
CSS_UNIT_PX, CSS_UNIT_PX, CSS_UNIT_PX, CSS_UNIT_PX,
false, false, false, false };
uint8_t type = get_clip(child, &rect);
 
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_CLIP_INHERIT ||
(child->uncommon != NULL && result != child)) {
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_CLIP_INHERIT) {
type = get_clip(parent, &rect);
}
 
return set_clip(result, type, &rect);
}
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/color.c
0,0 → 1,82
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
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__set_color_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_color(style, hint->status, hint->data.color);
}
 
css_error css__initial_color(css_select_state *state)
{
css_hint hint;
css_error error;
 
error = state->handler->ua_default_for_property(state->pw,
CSS_PROP_COLOR, &hint);
if (error != CSS_OK)
return error;
 
return css__set_color_from_hint(&hint, state->computed);
}
 
css_error css__compose_color(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_color color;
uint8_t type = get_color(child, &color);
 
if (type == CSS_COLOR_INHERIT) {
type = get_color(parent, &color);
}
 
return set_color(result, type, color);
}
 
/programs/network/netsurf/libcss/src/select/properties/column_count.c
0,0 → 1,68
/*
* This file is part of LibCSS
* Licensed under the MIT License,
* http://www.opensource.org/licenses/mit-license.php
* Copyright 2012 Michael Drake <tlsa@netsurf-browser.org>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_column_count(uint32_t opv, css_style *style,
css_select_state *state)
{
css_fixed count = 0;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case COLUMN_COUNT_SET:
count = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(count));
break;
case COLUMN_COUNT_AUTO:
/** \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__set_column_count_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_column_count(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_column_count(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/column_fill.c
0,0 → 1,65
/*
* This file is part of LibCSS
* Licensed under the MIT License,
* http://www.opensource.org/licenses/mit-license.php
* Copyright 2012 Michael Drake <tlsa@netsurf-browser.org>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_column_fill(uint32_t opv, css_style *style,
css_select_state *state)
{
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case COLUMN_FILL_BALANCE:
case COLUMN_FILL_AUTO:
/** \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__set_column_fill_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_column_fill(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_column_fill(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/column_gap.c
0,0 → 1,71
/*
* This file is part of LibCSS
* Licensed under the MIT License,
* http://www.opensource.org/licenses/mit-license.php
* Copyright 2012 Michael Drake <tlsa@netsurf-browser.org>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_column_gap(uint32_t opv, css_style *style,
css_select_state *state)
{
css_fixed length = 0;
uint32_t unit = UNIT_PX;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case COLUMN_GAP_SET:
length = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(length));
unit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(unit));
break;
case COLUMN_GAP_NORMAL:
/** \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__set_column_gap_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_column_gap(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_column_gap(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/column_rule_color.c
0,0 → 1,69
/*
* This file is part of LibCSS
* Licensed under the MIT License,
* http://www.opensource.org/licenses/mit-license.php
* Copyright 2012 Michael Drake <tlsa@netsurf-browser.org>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_column_rule_color(uint32_t opv, css_style *style,
css_select_state *state)
{
css_color color = 0;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case COLUMN_RULE_COLOR_SET:
color = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(color));
break;
case COLUMN_RULE_COLOR_TRANSPARENT:
case COLUMN_RULE_COLOR_CURRENT_COLOR:
/** \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__set_column_rule_color_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_column_rule_color(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_column_rule_color(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/column_rule_style.c
0,0 → 1,73
/*
* This file is part of LibCSS
* Licensed under the MIT License,
* http://www.opensource.org/licenses/mit-license.php
* Copyright 2012 Michael Drake <tlsa@netsurf-browser.org>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
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__set_column_rule_style_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_column_rule_style(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_column_rule_style(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/column_rule_width.c
0,0 → 1,73
/*
* This file is part of LibCSS
* Licensed under the MIT License,
* http://www.opensource.org/licenses/mit-license.php
* Copyright 2012 Michael Drake <tlsa@netsurf-browser.org>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_column_rule_width(uint32_t opv, css_style *style,
css_select_state *state)
{
css_fixed length = 0;
uint32_t unit = UNIT_PX;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case COLUMN_RULE_WIDTH_SET:
length = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(length));
unit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(unit));
break;
case COLUMN_RULE_WIDTH_THIN:
case COLUMN_RULE_WIDTH_MEDIUM:
case COLUMN_RULE_WIDTH_THICK:
/** \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__set_column_rule_width_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_column_rule_width(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_column_rule_width(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/column_span.c
0,0 → 1,65
/*
* This file is part of LibCSS
* Licensed under the MIT License,
* http://www.opensource.org/licenses/mit-license.php
* Copyright 2012 Michael Drake <tlsa@netsurf-browser.org>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_column_span(uint32_t opv, css_style *style,
css_select_state *state)
{
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case COLUMN_SPAN_NONE:
case COLUMN_SPAN_ALL:
/** \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__set_column_span_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_column_span(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_column_span(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/column_width.c
0,0 → 1,71
/*
* This file is part of LibCSS
* Licensed under the MIT License,
* http://www.opensource.org/licenses/mit-license.php
* Copyright 2012 Michael Drake <tlsa@netsurf-browser.org>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_column_width(uint32_t opv, css_style *style,
css_select_state *state)
{
css_fixed length = 0;
uint32_t unit = UNIT_PX;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case COLUMN_WIDTH_SET:
length = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(length));
unit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(unit));
break;
case COLUMN_WIDTH_AUTO:
/** \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__set_column_width_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_column_width(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_column_width(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/content.c
0,0 → 1,248
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_content(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_CONTENT_INHERIT;
css_computed_content_item *content = NULL;
uint32_t n_contents = 0;
 
if (isInherit(opv) == false) {
uint32_t v = getValue(opv);
 
if (v == CONTENT_NORMAL) {
value = CSS_CONTENT_NORMAL;
} else if (v == CONTENT_NONE) {
value = CSS_CONTENT_NONE;
} else {
value = CSS_CONTENT_SET;
while (v != CONTENT_NORMAL) {
lwc_string *he;
css_computed_content_item *temp;
 
css__stylesheet_string_get(style->sheet, *((css_code_t *) style->bytecode), &he);
temp = state->computed->alloc(content,
(n_contents + 1) *
sizeof(css_computed_content_item),
state->computed->pw);
if (temp == NULL) {
if (content != NULL) {
state->computed->alloc(content,
0, state->computed->pw);
}
return CSS_NOMEM;
}
 
content = temp;
 
switch (v & 0xff) {
case CONTENT_COUNTER:
advance_bytecode(style, sizeof(css_code_t));
 
content[n_contents].type =
CSS_COMPUTED_CONTENT_COUNTER;
content[n_contents].data.counter.name = he;
content[n_contents].data.counter.style = v >> CONTENT_COUNTER_STYLE_SHIFT;
break;
case CONTENT_COUNTERS:
{
lwc_string *sep;
advance_bytecode(style, sizeof(css_code_t));
 
css__stylesheet_string_get(style->sheet, *((css_code_t *) style->bytecode), &sep);
advance_bytecode(style, sizeof(css_code_t));
 
content[n_contents].type =
CSS_COMPUTED_CONTENT_COUNTERS;
content[n_contents].data.counters.name = he;
content[n_contents].data.counters.sep = sep;
content[n_contents].data.counters.style = v >> CONTENT_COUNTERS_STYLE_SHIFT;
}
break;
case CONTENT_URI:
advance_bytecode(style, sizeof(css_code_t));
 
content[n_contents].type =
CSS_COMPUTED_CONTENT_URI;
content[n_contents].data.uri = he;
break;
case CONTENT_ATTR:
advance_bytecode(style, sizeof(css_code_t));
 
content[n_contents].type =
CSS_COMPUTED_CONTENT_ATTR;
content[n_contents].data.attr = he;
break;
case CONTENT_STRING:
advance_bytecode(style, sizeof(css_code_t));
 
content[n_contents].type =
CSS_COMPUTED_CONTENT_STRING;
content[n_contents].data.string = he;
break;
case CONTENT_OPEN_QUOTE:
content[n_contents].type =
CSS_COMPUTED_CONTENT_OPEN_QUOTE;
break;
case CONTENT_CLOSE_QUOTE:
content[n_contents].type =
CSS_COMPUTED_CONTENT_CLOSE_QUOTE;
break;
case CONTENT_NO_OPEN_QUOTE:
content[n_contents].type =
CSS_COMPUTED_CONTENT_NO_OPEN_QUOTE;
break;
case CONTENT_NO_CLOSE_QUOTE:
content[n_contents].type =
CSS_COMPUTED_CONTENT_NO_CLOSE_QUOTE;
break;
}
 
n_contents++;
 
v = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(v));
}
}
}
 
/* If we have some content, terminate the array with a blank entry */
if (n_contents > 0) {
css_computed_content_item *temp;
 
temp = state->computed->alloc(content,
(n_contents + 1) * sizeof(css_computed_content_item),
state->computed->pw);
if (temp == NULL) {
state->computed->alloc(content, 0, state->computed->pw);
return CSS_NOMEM;
}
 
content = temp;
 
content[n_contents].type = CSS_COMPUTED_CONTENT_NONE;
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
css_error error;
 
error = set_content(state->computed, value, content);
if (error != CSS_OK && content != NULL)
state->computed->alloc(content, 0, state->computed->pw);
 
return error;
} else if (content != NULL) {
state->computed->alloc(content, 0, state->computed->pw);
}
 
return CSS_OK;
}
 
css_error css__set_content_from_hint(const css_hint *hint,
css_computed_style *style)
{
css_computed_content_item *item;
css_error error;
 
error = set_content(style, hint->status, hint->data.content);
 
for (item = hint->data.content; item != NULL &&
item->type != CSS_COMPUTED_CONTENT_NONE;
item++) {
switch (item->type) {
case CSS_COMPUTED_CONTENT_STRING:
lwc_string_unref(item->data.string);
break;
case CSS_COMPUTED_CONTENT_URI:
lwc_string_unref(item->data.uri);
break;
case CSS_COMPUTED_CONTENT_COUNTER:
lwc_string_unref(item->data.counter.name);
break;
case CSS_COMPUTED_CONTENT_COUNTERS:
lwc_string_unref(item->data.counters.name);
lwc_string_unref(item->data.counters.sep);
break;
case CSS_COMPUTED_CONTENT_ATTR:
lwc_string_unref(item->data.attr);
break;
default:
break;
}
}
 
if (error != CSS_OK && hint->data.content != NULL)
style->alloc(hint->data.content, 0, style->pw);
 
return error;
}
 
css_error css__initial_content(css_select_state *state)
{
return set_content(state->computed, CSS_CONTENT_NORMAL, NULL);
}
 
css_error css__compose_content(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_error error;
const css_computed_content_item *items = NULL;
uint8_t type = get_content(child, &items);
 
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_CONTENT_INHERIT ||
(child->uncommon != NULL && result != child)) {
size_t n_items = 0;
css_computed_content_item *copy = NULL;
 
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_CONTENT_INHERIT) {
type = get_content(parent, &items);
}
 
if (type == CSS_CONTENT_SET) {
const css_computed_content_item *i;
 
for (i = items; i->type != CSS_COMPUTED_CONTENT_NONE;
i++)
n_items++;
 
copy = result->alloc(NULL, (n_items + 1) *
sizeof(css_computed_content_item),
result->pw);
if (copy == NULL)
return CSS_NOMEM;
 
memcpy(copy, items, (n_items + 1) *
sizeof(css_computed_content_item));
}
 
error = set_content(result, type, copy);
if (error != CSS_OK && copy != NULL)
result->alloc(copy, 0, result->pw);
 
return error;
}
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/counter_increment.c
0,0 → 1,95
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_counter_increment(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_counter_increment_reset(opv, style, state,
set_counter_increment);
}
 
css_error css__set_counter_increment_from_hint(const css_hint *hint,
css_computed_style *style)
{
css_computed_counter *item;
css_error error;
 
error = set_counter_increment(style, hint->status, hint->data.counter);
 
if (hint->status == CSS_COUNTER_INCREMENT_NAMED &&
hint->data.counter != NULL) {
for (item = hint->data.counter; item->name != NULL; item++) {
lwc_string_unref(item->name);
}
}
 
if (error != CSS_OK && hint->data.counter != NULL)
style->alloc(hint->data.counter, 0, style->pw);
 
return error;
}
 
css_error css__initial_counter_increment(css_select_state *state)
{
return set_counter_increment(state->computed,
CSS_COUNTER_INCREMENT_NONE, NULL);
}
 
css_error css__compose_counter_increment(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_error error;
const css_computed_counter *items = NULL;
uint8_t type = get_counter_increment(child, &items);
 
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_COUNTER_INCREMENT_INHERIT ||
(child->uncommon != NULL && result != child)) {
size_t n_items = 0;
css_computed_counter *copy = NULL;
 
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_COUNTER_INCREMENT_INHERIT) {
type = get_counter_increment(parent, &items);
}
 
if (type == CSS_COUNTER_INCREMENT_NAMED && items != NULL) {
const css_computed_counter *i;
 
for (i = items; i->name != NULL; i++)
n_items++;
 
copy = result->alloc(NULL, (n_items + 1) *
sizeof(css_computed_counter),
result->pw);
if (copy == NULL)
return CSS_NOMEM;
 
memcpy(copy, items, (n_items + 1) *
sizeof(css_computed_counter));
}
 
error = set_counter_increment(result, type, copy);
if (error != CSS_OK && copy != NULL)
result->alloc(copy, 0, result->pw);
 
return error;
}
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/counter_reset.c
0,0 → 1,93
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_counter_reset(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_counter_increment_reset(opv, style, state,
set_counter_reset);
}
 
css_error css__set_counter_reset_from_hint(const css_hint *hint,
css_computed_style *style)
{
css_computed_counter *item;
css_error error;
 
error = set_counter_reset(style, hint->status, hint->data.counter);
 
if (hint->status == CSS_COUNTER_RESET_NAMED &&
hint->data.counter != NULL) {
for (item = hint->data.counter; item->name != NULL; item++) {
lwc_string_unref(item->name);
}
}
 
if (error != CSS_OK && hint->data.counter != NULL)
style->alloc(hint->data.counter, 0, style->pw);
 
return error;
}
 
css_error css__initial_counter_reset(css_select_state *state)
{
return set_counter_reset(state->computed, CSS_COUNTER_RESET_NONE, NULL);
}
 
css_error css__compose_counter_reset(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_error error;
const css_computed_counter *items = NULL;
uint8_t type = get_counter_reset(child, &items);
 
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_COUNTER_RESET_INHERIT ||
(child->uncommon != NULL && result != child)) {
size_t n_items = 0;
css_computed_counter *copy = NULL;
 
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_COUNTER_RESET_INHERIT) {
type = get_counter_reset(parent, &items);
}
 
if (type == CSS_COUNTER_RESET_NAMED && items != NULL) {
const css_computed_counter *i;
 
for (i = items; i->name != NULL; i++)
n_items++;
 
copy = result->alloc(NULL, (n_items + 1) *
sizeof(css_computed_counter),
result->pw);
if (copy == NULL)
return CSS_NOMEM;
 
memcpy(copy, items, (n_items + 1) *
sizeof(css_computed_counter));
}
 
error = set_counter_reset(result, type, copy);
if (error != CSS_OK && copy != NULL)
result->alloc(copy, 0, result->pw);
 
return error;
}
 
return CSS_OK;
}
/programs/network/netsurf/libcss/src/select/properties/cue_after.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_cue_after(uint32_t opv, css_style *style,
css_select_state *state)
{
/** \todo cue-after */
return css__cascade_uri_none(opv, style, state, NULL);
}
 
css_error css__set_cue_after_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_cue_after(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_cue_after(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/cue_before.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_cue_before(uint32_t opv, css_style *style,
css_select_state *state)
{
/** \todo cue-before */
return css__cascade_uri_none(opv, style, state, NULL);
}
 
css_error css__set_cue_before_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_cue_before(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_cue_before(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/cursor.c
0,0 → 1,212
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
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 = state->computed->alloc(uris,
(n_uris + 1) * sizeof(lwc_string *),
state->computed->pw);
if (temp == NULL) {
if (uris != NULL) {
state->computed->alloc(uris, 0,
state->computed->pw);
}
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 = state->computed->alloc(uris,
(n_uris + 1) * sizeof(lwc_string *),
state->computed->pw);
if (temp == NULL) {
state->computed->alloc(uris, 0, state->computed->pw);
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)
state->computed->alloc(uris, 0, state->computed->pw);
 
return error;
} else {
if (n_uris > 0)
state->computed->alloc(uris, 0, state->computed->pw);
}
 
return CSS_OK;
}
 
css_error css__set_cursor_from_hint(const css_hint *hint,
css_computed_style *style)
{
lwc_string **item;
css_error error;
 
error = set_cursor(style, hint->status, hint->data.strings);
 
for (item = hint->data.strings;
item != NULL && (*item) != NULL; item++) {
lwc_string_unref(*item);
}
 
if (error != CSS_OK && hint->data.strings != NULL)
style->alloc(hint->data.strings, 0, style->pw);
 
return error;
}
 
css_error css__initial_cursor(css_select_state *state)
{
return set_cursor(state->computed, CSS_CURSOR_AUTO, NULL);
}
 
css_error css__compose_cursor(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_error error;
lwc_string **urls = NULL;
uint8_t type = get_cursor(child, &urls);
 
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_CURSOR_INHERIT ||
(child->uncommon != NULL && result != child)) {
size_t n_urls = 0;
lwc_string **copy = NULL;
 
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_CURSOR_INHERIT) {
type = get_cursor(parent, &urls);
}
 
if (urls != NULL) {
lwc_string **i;
 
for (i = urls; (*i) != NULL; i++)
n_urls++;
 
copy = result->alloc(NULL, (n_urls + 1) *
sizeof(lwc_string *),
result->pw);
if (copy == NULL)
return CSS_NOMEM;
 
memcpy(copy, urls, (n_urls + 1) *
sizeof(lwc_string *));
}
 
error = set_cursor(result, type, copy);
if (error != CSS_OK && copy != NULL)
result->alloc(copy, 0, result->pw);
 
return error;
}
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/direction.c
0,0 → 1,66
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_direction(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_DIRECTION_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case DIRECTION_LTR:
value = CSS_DIRECTION_LTR;
break;
case DIRECTION_RTL:
value = CSS_DIRECTION_RTL;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_direction(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_direction_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_direction(style, hint->status);
}
 
css_error css__initial_direction(css_select_state *state)
{
return set_direction(state->computed, CSS_DIRECTION_LTR);
}
 
css_error css__compose_direction(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_direction(child);
 
if (type == CSS_DIRECTION_INHERIT) {
type = get_direction(parent);
}
 
return set_direction(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/display.c
0,0 → 1,108
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_display(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_DISPLAY_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case DISPLAY_INLINE:
value = CSS_DISPLAY_INLINE;
break;
case DISPLAY_BLOCK:
value = CSS_DISPLAY_BLOCK;
break;
case DISPLAY_LIST_ITEM:
value = CSS_DISPLAY_LIST_ITEM;
break;
case DISPLAY_RUN_IN:
value = CSS_DISPLAY_RUN_IN;
break;
case DISPLAY_INLINE_BLOCK:
value = CSS_DISPLAY_INLINE_BLOCK;
break;
case DISPLAY_TABLE:
value = CSS_DISPLAY_TABLE;
break;
case DISPLAY_INLINE_TABLE:
value = CSS_DISPLAY_INLINE_TABLE;
break;
case DISPLAY_TABLE_ROW_GROUP:
value = CSS_DISPLAY_TABLE_ROW_GROUP;
break;
case DISPLAY_TABLE_HEADER_GROUP:
value = CSS_DISPLAY_TABLE_HEADER_GROUP;
break;
case DISPLAY_TABLE_FOOTER_GROUP:
value = CSS_DISPLAY_TABLE_FOOTER_GROUP;
break;
case DISPLAY_TABLE_ROW:
value = CSS_DISPLAY_TABLE_ROW;
break;
case DISPLAY_TABLE_COLUMN_GROUP:
value = CSS_DISPLAY_TABLE_COLUMN_GROUP;
break;
case DISPLAY_TABLE_COLUMN:
value = CSS_DISPLAY_TABLE_COLUMN;
break;
case DISPLAY_TABLE_CELL:
value = CSS_DISPLAY_TABLE_CELL;
break;
case DISPLAY_TABLE_CAPTION:
value = CSS_DISPLAY_TABLE_CAPTION;
break;
case DISPLAY_NONE:
value = CSS_DISPLAY_NONE;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_display(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_display_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_display(style, hint->status);
}
 
css_error css__initial_display(css_select_state *state)
{
return set_display(state->computed, CSS_DISPLAY_INLINE);
}
 
css_error css__compose_display(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_display_static(child);
 
if (type == CSS_DISPLAY_INHERIT) {
type = get_display_static(parent);
}
 
return set_display(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/elevation.c
0,0 → 1,78
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_elevation(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)) {
case ELEVATION_ANGLE:
val = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(val));
 
unit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(unit));
break;
case ELEVATION_BELOW:
case ELEVATION_LEVEL:
case ELEVATION_ABOVE:
case ELEVATION_HIGHER:
case ELEVATION_LOWER:
/** \todo convert to public values */
break;
}
}
 
unit = css__to_css_unit(unit);
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
/** \todo set computed elevation */
}
 
return CSS_OK;
}
 
css_error css__set_elevation_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_elevation(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_elevation(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/empty_cells.c
0,0 → 1,66
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_empty_cells(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_EMPTY_CELLS_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case EMPTY_CELLS_SHOW:
value = CSS_EMPTY_CELLS_SHOW;
break;
case EMPTY_CELLS_HIDE:
value = CSS_EMPTY_CELLS_HIDE;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_empty_cells(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_empty_cells_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_empty_cells(style, hint->status);
}
 
css_error css__initial_empty_cells(css_select_state *state)
{
return set_empty_cells(state->computed, CSS_EMPTY_CELLS_SHOW);
}
 
css_error css__compose_empty_cells(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_empty_cells(child);
 
if (type == CSS_EMPTY_CELLS_INHERIT) {
type = get_empty_cells(parent);
}
 
return set_empty_cells(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/float.c
0,0 → 1,69
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_float(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_FLOAT_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case FLOAT_LEFT:
value = CSS_FLOAT_LEFT;
break;
case FLOAT_RIGHT:
value = CSS_FLOAT_RIGHT;
break;
case FLOAT_NONE:
value = CSS_FLOAT_NONE;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_float(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_float_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_float(style, hint->status);
}
 
css_error css__initial_float(css_select_state *state)
{
return set_float(state->computed, CSS_FLOAT_NONE);
}
 
css_error css__compose_float(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_float(child);
 
if (type == CSS_FLOAT_INHERIT) {
type = get_float(parent);
}
 
return set_float(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/font_family.c
0,0 → 1,231
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
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;
}
 
css_error css__set_font_family_from_hint(const css_hint *hint,
css_computed_style *style)
{
lwc_string **item;
css_error error;
 
error = set_font_family(style, hint->status, hint->data.strings);
 
for (item = hint->data.strings;
item != NULL && (*item) != NULL; item++) {
lwc_string_unref(*item);
}
 
if (error != CSS_OK && hint->data.strings != NULL)
style->alloc(hint->data.strings, 0, style->pw);
 
return error;
}
 
css_error css__initial_font_family(css_select_state *state)
{
css_hint hint;
css_error error;
 
error = state->handler->ua_default_for_property(state->pw,
CSS_PROP_FONT_FAMILY, &hint);
if (error != CSS_OK)
return error;
 
return css__set_font_family_from_hint(&hint, state->computed);
}
 
css_error css__compose_font_family(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_error error;
lwc_string **names = NULL;
uint8_t type = get_font_family(child, &names);
 
if (type == CSS_FONT_FAMILY_INHERIT || result != child) {
size_t n_names = 0;
lwc_string **copy = NULL;
 
if (type == CSS_FONT_FAMILY_INHERIT)
type = get_font_family(parent, &names);
 
if (names != NULL) {
lwc_string **i;
 
for (i = names; (*i) != NULL; i++)
n_names++;
 
copy = result->alloc(NULL, (n_names + 1) *
sizeof(lwc_string *),
result->pw);
if (copy == NULL)
return CSS_NOMEM;
 
memcpy(copy, names, (n_names + 1) *
sizeof(lwc_string *));
}
 
error = set_font_family(result, type, copy);
if (error != CSS_OK && copy != NULL)
result->alloc(copy, 0, result->pw);
 
return error;
}
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/font_size.c
0,0 → 1,102
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_font_size(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_FONT_SIZE_INHERIT;
css_fixed size = 0;
uint32_t unit = UNIT_PX;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case FONT_SIZE_DIMENSION:
value = CSS_FONT_SIZE_DIMENSION;
 
size = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(size));
 
unit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(unit));
break;
case FONT_SIZE_XX_SMALL:
value = CSS_FONT_SIZE_XX_SMALL;
break;
case FONT_SIZE_X_SMALL:
value = CSS_FONT_SIZE_X_SMALL;
break;
case FONT_SIZE_SMALL:
value = CSS_FONT_SIZE_SMALL;
break;
case FONT_SIZE_MEDIUM:
value = CSS_FONT_SIZE_MEDIUM;
break;
case FONT_SIZE_LARGE:
value = CSS_FONT_SIZE_LARGE;
break;
case FONT_SIZE_X_LARGE:
value = CSS_FONT_SIZE_X_LARGE;
break;
case FONT_SIZE_XX_LARGE:
value = CSS_FONT_SIZE_XX_LARGE;
break;
case FONT_SIZE_LARGER:
value = CSS_FONT_SIZE_LARGER;
break;
case FONT_SIZE_SMALLER:
value = CSS_FONT_SIZE_SMALLER;
break;
}
}
 
unit = css__to_css_unit(unit);
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_font_size(state->computed, value, size, unit);
}
 
return CSS_OK;
}
 
css_error css__set_font_size_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_font_size(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_font_size(css_select_state *state)
{
return set_font_size(state->computed, CSS_FONT_SIZE_MEDIUM,
0, CSS_UNIT_PX);
}
 
css_error css__compose_font_size(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed size = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_font_size(child, &size, &unit);
 
if (type == CSS_FONT_SIZE_INHERIT) {
type = get_font_size(parent, &size, &unit);
}
 
return set_font_size(result, type, size, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/font_style.c
0,0 → 1,69
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_font_style(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_FONT_STYLE_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case FONT_STYLE_NORMAL:
value = CSS_FONT_STYLE_NORMAL;
break;
case FONT_STYLE_ITALIC:
value = CSS_FONT_STYLE_ITALIC;
break;
case FONT_STYLE_OBLIQUE:
value = CSS_FONT_STYLE_OBLIQUE;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_font_style(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_font_style_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_font_style(style, hint->status);
}
 
css_error css__initial_font_style(css_select_state *state)
{
return set_font_style(state->computed, CSS_FONT_STYLE_NORMAL);
}
 
css_error css__compose_font_style(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_font_style(child);
 
if (type == CSS_FONT_STYLE_INHERIT) {
type= get_font_style(parent);
}
return set_font_style(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/font_variant.c
0,0 → 1,66
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_font_variant(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_FONT_VARIANT_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case FONT_VARIANT_NORMAL:
value = CSS_FONT_VARIANT_NORMAL;
break;
case FONT_VARIANT_SMALL_CAPS:
value = CSS_FONT_VARIANT_SMALL_CAPS;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_font_variant(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_font_variant_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_font_variant(style, hint->status);
}
 
css_error css__initial_font_variant(css_select_state *state)
{
return set_font_variant(state->computed, CSS_FONT_VARIANT_NORMAL);
}
 
css_error css__compose_font_variant(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_font_variant(child);
 
if (type == CSS_FONT_VARIANT_INHERIT) {
type = get_font_variant(parent);
}
 
return set_font_variant(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/font_weight.c
0,0 → 1,99
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_font_weight(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_FONT_WEIGHT_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case FONT_WEIGHT_NORMAL:
value = CSS_FONT_WEIGHT_NORMAL;
break;
case FONT_WEIGHT_BOLD:
value = CSS_FONT_WEIGHT_BOLD;
break;
case FONT_WEIGHT_BOLDER:
value = CSS_FONT_WEIGHT_BOLDER;
break;
case FONT_WEIGHT_LIGHTER:
value = CSS_FONT_WEIGHT_LIGHTER;
break;
case FONT_WEIGHT_100:
value = CSS_FONT_WEIGHT_100;
break;
case FONT_WEIGHT_200:
value = CSS_FONT_WEIGHT_200;
break;
case FONT_WEIGHT_300:
value = CSS_FONT_WEIGHT_300;
break;
case FONT_WEIGHT_400:
value = CSS_FONT_WEIGHT_400;
break;
case FONT_WEIGHT_500:
value = CSS_FONT_WEIGHT_500;
break;
case FONT_WEIGHT_600:
value = CSS_FONT_WEIGHT_600;
break;
case FONT_WEIGHT_700:
value = CSS_FONT_WEIGHT_700;
break;
case FONT_WEIGHT_800:
value = CSS_FONT_WEIGHT_800;
break;
case FONT_WEIGHT_900:
value = CSS_FONT_WEIGHT_900;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_font_weight(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_font_weight_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_font_weight(style, hint->status);
}
 
css_error css__initial_font_weight(css_select_state *state)
{
return set_font_weight(state->computed, CSS_FONT_WEIGHT_NORMAL);
}
 
css_error css__compose_font_weight(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_font_weight(child);
 
if (type == CSS_FONT_WEIGHT_INHERIT) {
type = get_font_weight(parent);
}
 
return set_font_weight(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/height.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_height(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length_auto(opv, style, state, set_height);
}
 
css_error css__set_height_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_height(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_height(css_select_state *state)
{
return set_height(state->computed, CSS_HEIGHT_AUTO, 0, CSS_UNIT_PX);
}
 
css_error css__compose_height(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_height(child, &length, &unit);
 
if (type == CSS_HEIGHT_INHERIT) {
type = get_height(parent, &length, &unit);
}
 
return set_height(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/helpers.c
0,0 → 1,487
/*
* 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>
*/
 
#include <assert.h>
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/properties/properties.h"
#include "select/propget.h"
#include "select/propset.h"
#include "utils/utils.h"
 
#include "select/properties/helpers.h"
 
/* Useful helpers */
 
css_unit css__to_css_unit(uint32_t u)
{
switch (u) {
case UNIT_PX: return CSS_UNIT_PX;
case UNIT_EX: return CSS_UNIT_EX;
case UNIT_EM: return CSS_UNIT_EM;
case UNIT_IN: return CSS_UNIT_IN;
case UNIT_CM: return CSS_UNIT_CM;
case UNIT_MM: return CSS_UNIT_MM;
case UNIT_PT: return CSS_UNIT_PT;
case UNIT_PC: return CSS_UNIT_PC;
case UNIT_PCT: return CSS_UNIT_PCT;
case UNIT_DEG: return CSS_UNIT_DEG;
case UNIT_GRAD: return CSS_UNIT_GRAD;
case UNIT_RAD: return CSS_UNIT_RAD;
case UNIT_MS: return CSS_UNIT_MS;
case UNIT_S: return CSS_UNIT_S;
case UNIT_HZ: return CSS_UNIT_HZ;
case UNIT_KHZ: return CSS_UNIT_KHZ;
}
 
return 0;
}
 
/******************************************************************************
* Utilities below here *
******************************************************************************/
css_error css__cascade_bg_border_color(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t, css_color))
{
uint16_t value = CSS_BACKGROUND_COLOR_INHERIT;
css_color color = 0;
 
assert(CSS_BACKGROUND_COLOR_INHERIT ==
(enum css_background_color_e)CSS_BORDER_COLOR_INHERIT);
assert(CSS_BACKGROUND_COLOR_COLOR ==
(enum css_background_color_e)CSS_BORDER_COLOR_COLOR);
assert(CSS_BACKGROUND_COLOR_CURRENT_COLOR ==
(enum css_background_color_e)CSS_BORDER_COLOR_CURRENT_COLOR);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case BACKGROUND_COLOR_TRANSPARENT:
value = CSS_BACKGROUND_COLOR_COLOR;
break;
case BACKGROUND_COLOR_CURRENT_COLOR:
value = CSS_BACKGROUND_COLOR_CURRENT_COLOR;
break;
case BACKGROUND_COLOR_SET:
value = CSS_BACKGROUND_COLOR_COLOR;
color = *((css_color *) style->bytecode);
advance_bytecode(style, sizeof(color));
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return fun(state->computed, value, color);
}
 
return CSS_OK;
}
 
css_error css__cascade_uri_none(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t,
lwc_string *))
{
uint16_t value = CSS_BACKGROUND_IMAGE_INHERIT;
lwc_string *uri = NULL;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case BACKGROUND_IMAGE_NONE:
value = CSS_BACKGROUND_IMAGE_NONE;
break;
case BACKGROUND_IMAGE_URI:
value = CSS_BACKGROUND_IMAGE_IMAGE;
css__stylesheet_string_get(style->sheet, *((css_code_t *) style->bytecode), &uri);
advance_bytecode(style, sizeof(css_code_t));
break;
}
}
 
/** \todo lose fun != NULL once all properties have set routines */
if (fun != NULL && css__outranks_existing(getOpcode(opv),
isImportant(opv), state, isInherit(opv))) {
return fun(state->computed, value, uri);
}
 
return CSS_OK;
}
 
css_error css__cascade_border_style(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t))
{
uint16_t value = CSS_BORDER_STYLE_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case BORDER_STYLE_NONE:
value = CSS_BORDER_STYLE_NONE;
break;
case BORDER_STYLE_HIDDEN:
value = CSS_BORDER_STYLE_HIDDEN;
break;
case BORDER_STYLE_DOTTED:
value = CSS_BORDER_STYLE_DOTTED;
break;
case BORDER_STYLE_DASHED:
value = CSS_BORDER_STYLE_DASHED;
break;
case BORDER_STYLE_SOLID:
value = CSS_BORDER_STYLE_SOLID;
break;
case BORDER_STYLE_DOUBLE:
value = CSS_BORDER_STYLE_DOUBLE;
break;
case BORDER_STYLE_GROOVE:
value = CSS_BORDER_STYLE_GROOVE;
break;
case BORDER_STYLE_RIDGE:
value = CSS_BORDER_STYLE_RIDGE;
break;
case BORDER_STYLE_INSET:
value = CSS_BORDER_STYLE_INSET;
break;
case BORDER_STYLE_OUTSET:
value = CSS_BORDER_STYLE_OUTSET;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return fun(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__cascade_border_width(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t, css_fixed,
css_unit))
{
uint16_t value = CSS_BORDER_WIDTH_INHERIT;
css_fixed length = 0;
uint32_t unit = UNIT_PX;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case BORDER_WIDTH_SET:
value = CSS_BORDER_WIDTH_WIDTH;
length = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(length));
unit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(unit));
break;
case BORDER_WIDTH_THIN:
value = CSS_BORDER_WIDTH_THIN;
break;
case BORDER_WIDTH_MEDIUM:
value = CSS_BORDER_WIDTH_MEDIUM;
break;
case BORDER_WIDTH_THICK:
value = CSS_BORDER_WIDTH_THICK;
break;
}
}
 
unit = css__to_css_unit(unit);
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return fun(state->computed, value, length, unit);
}
 
return CSS_OK;
}
 
css_error css__cascade_length_auto(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t, css_fixed,
css_unit))
{
uint16_t value = CSS_BOTTOM_INHERIT;
css_fixed length = 0;
uint32_t unit = UNIT_PX;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case BOTTOM_SET:
value = CSS_BOTTOM_SET;
length = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(length));
unit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(unit));
break;
case BOTTOM_AUTO:
value = CSS_BOTTOM_AUTO;
break;
}
}
 
unit = css__to_css_unit(unit);
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return fun(state->computed, value, length, unit);
}
 
return CSS_OK;
}
 
css_error css__cascade_length_normal(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t, css_fixed,
css_unit))
{
uint16_t value = CSS_LETTER_SPACING_INHERIT;
css_fixed length = 0;
uint32_t unit = UNIT_PX;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case LETTER_SPACING_SET:
value = CSS_LETTER_SPACING_SET;
length = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(length));
unit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(unit));
break;
case LETTER_SPACING_NORMAL:
value = CSS_LETTER_SPACING_NORMAL;
break;
}
}
 
unit = css__to_css_unit(unit);
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return fun(state->computed, value, length, unit);
}
 
return CSS_OK;
}
 
css_error css__cascade_length_none(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t, css_fixed,
css_unit))
{
uint16_t value = CSS_MAX_HEIGHT_INHERIT;
css_fixed length = 0;
uint32_t unit = UNIT_PX;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case MAX_HEIGHT_SET:
value = CSS_MAX_HEIGHT_SET;
length = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(length));
unit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(unit));
break;
case MAX_HEIGHT_NONE:
value = CSS_MAX_HEIGHT_NONE;
break;
}
}
 
unit = css__to_css_unit(unit);
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return fun(state->computed, value, length, unit);
}
 
return CSS_OK;
}
 
css_error css__cascade_length(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t, css_fixed,
css_unit))
{
uint16_t value = CSS_MIN_HEIGHT_INHERIT;
css_fixed length = 0;
uint32_t unit = UNIT_PX;
 
if (isInherit(opv) == false) {
value = CSS_MIN_HEIGHT_SET;
length = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(length));
unit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(unit));
}
 
unit = css__to_css_unit(unit);
 
/** \todo lose fun != NULL once all properties have set routines */
if (fun != NULL && css__outranks_existing(getOpcode(opv),
isImportant(opv), state, isInherit(opv))) {
return fun(state->computed, value, length, unit);
}
 
return CSS_OK;
}
 
css_error css__cascade_number(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t, css_fixed))
{
uint16_t value = 0;
css_fixed length = 0;
 
/** \todo values */
 
if (isInherit(opv) == false) {
value = 0;
length = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(length));
}
 
/** \todo lose fun != NULL once all properties have set routines */
if (fun != NULL && css__outranks_existing(getOpcode(opv),
isImportant(opv), state, isInherit(opv))) {
return fun(state->computed, value, length);
}
 
return CSS_OK;
}
 
css_error css__cascade_page_break_after_before_inside(uint32_t opv,
css_style *style, css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t))
{
uint16_t value = CSS_PAGE_BREAK_AFTER_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case PAGE_BREAK_AFTER_AUTO:
value = CSS_PAGE_BREAK_AFTER_AUTO;
break;
case PAGE_BREAK_AFTER_ALWAYS:
value = CSS_PAGE_BREAK_AFTER_ALWAYS;
break;
case PAGE_BREAK_AFTER_AVOID:
value = CSS_PAGE_BREAK_AFTER_AVOID;
break;
case PAGE_BREAK_AFTER_LEFT:
value = CSS_PAGE_BREAK_AFTER_LEFT;
break;
case PAGE_BREAK_AFTER_RIGHT:
value = CSS_PAGE_BREAK_AFTER_RIGHT;
break;
}
}
 
/** \todo lose fun != NULL */
if (fun != NULL && css__outranks_existing(getOpcode(opv),
isImportant(opv), state, isInherit(opv))) {
return fun(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__cascade_counter_increment_reset(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t,
css_computed_counter *))
{
uint16_t value = CSS_COUNTER_INCREMENT_INHERIT;
css_computed_counter *counters = NULL;
uint32_t n_counters = 0;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case COUNTER_INCREMENT_NAMED:
{
uint32_t v = getValue(opv);
 
while (v != COUNTER_INCREMENT_NONE) {
css_computed_counter *temp;
lwc_string *name;
css_fixed val = 0;
 
css__stylesheet_string_get(style->sheet, *((css_code_t *) style->bytecode), &name);
advance_bytecode(style, sizeof(css_code_t));
 
val = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(css_code_t));
 
temp = state->computed->alloc(counters,
(n_counters + 1) *
sizeof(css_computed_counter),
state->computed->pw);
if (temp == NULL) {
if (counters != NULL) {
state->computed->alloc(counters,
0, state->computed->pw);
}
return CSS_NOMEM;
}
 
counters = temp;
 
counters[n_counters].name = name;
counters[n_counters].value = val;
 
n_counters++;
 
v = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(css_code_t));
}
}
break;
case COUNTER_INCREMENT_NONE:
value = CSS_COUNTER_INCREMENT_NONE;
break;
}
}
 
/* If we have some counters, terminate the array with a blank entry */
if (n_counters > 0) {
css_computed_counter *temp;
 
temp = state->computed->alloc(counters,
(n_counters + 1) * sizeof(css_computed_counter),
state->computed->pw);
if (temp == NULL) {
state->computed->alloc(counters, 0, state->computed->pw);
return CSS_NOMEM;
}
 
counters = temp;
 
counters[n_counters].name = NULL;
counters[n_counters].value = 0;
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
css_error error;
 
error = fun(state->computed, value, counters);
if (error != CSS_OK && n_counters > 0)
state->computed->alloc(counters, 0, state->computed->pw);
 
return error;
} else if (n_counters > 0) {
state->computed->alloc(counters, 0, state->computed->pw);
}
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/helpers.h
0,0 → 1,59
/*
* 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_properties_helpers_h_
#define css_select_properties_helpers_h_
 
uint32_t generic_destroy_color(void *bytecode);
uint32_t generic_destroy_uri(void *bytecode);
uint32_t generic_destroy_length(void *bytecode);
uint32_t generic_destroy_number(void *bytecode);
 
css_unit css__to_css_unit(uint32_t u);
 
css_error css__cascade_bg_border_color(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t, css_color));
css_error css__cascade_uri_none(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t,
lwc_string *));
css_error css__cascade_border_style(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t));
css_error css__cascade_border_width(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t, css_fixed,
css_unit));
css_error css__cascade_length_auto(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t, css_fixed,
css_unit));
css_error css__cascade_length_normal(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t, css_fixed,
css_unit));
css_error css__cascade_length_none(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t, css_fixed,
css_unit));
css_error css__cascade_length(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t, css_fixed,
css_unit));
css_error css__cascade_number(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t, css_fixed));
css_error css__cascade_page_break_after_before_inside(uint32_t opv,
css_style *style, css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t));
css_error css__cascade_counter_increment_reset(uint32_t opv, css_style *style,
css_select_state *state,
css_error (*fun)(css_computed_style *, uint8_t,
css_computed_counter *));
 
#endif
/programs/network/netsurf/libcss/src/select/properties/left.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_left(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length_auto(opv, style, state, set_left);
}
 
css_error css__set_left_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_left(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_left(css_select_state *state)
{
return set_left(state->computed, CSS_LEFT_AUTO, 0, CSS_UNIT_PX);
}
 
css_error css__compose_left(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_left(child, &length, &unit);
 
if (type == CSS_LEFT_INHERIT) {
type = get_left(parent, &length, &unit);
}
 
return set_left(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/letter_spacing.c
0,0 → 1,57
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_letter_spacing(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length_normal(opv, style, state, set_letter_spacing);
}
 
css_error css__set_letter_spacing_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_letter_spacing(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_letter_spacing(css_select_state *state)
{
return set_letter_spacing(state->computed, CSS_LETTER_SPACING_NORMAL,
0, CSS_UNIT_PX);
}
 
css_error css__compose_letter_spacing(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_letter_spacing(child, &length, &unit);
 
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_LETTER_SPACING_INHERIT ||
(child->uncommon != NULL && result != child)) {
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_LETTER_SPACING_INHERIT) {
type = get_letter_spacing(parent, &length, &unit);
}
 
return set_letter_spacing(result, type, length, unit);
}
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/line_height.c
0,0 → 1,81
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_line_height(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_LINE_HEIGHT_INHERIT;
css_fixed val = 0;
uint32_t unit = UNIT_PX;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case LINE_HEIGHT_NUMBER:
value = CSS_LINE_HEIGHT_NUMBER;
val = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(val));
break;
case LINE_HEIGHT_DIMENSION:
value = CSS_LINE_HEIGHT_DIMENSION;
val = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(val));
unit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(unit));
break;
case LINE_HEIGHT_NORMAL:
value = CSS_LINE_HEIGHT_NORMAL;
break;
}
}
 
unit = css__to_css_unit(unit);
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_line_height(state->computed, value, val, unit);
}
 
return CSS_OK;
}
 
css_error css__set_line_height_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_line_height(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_line_height(css_select_state *state)
{
return set_line_height(state->computed, CSS_LINE_HEIGHT_NORMAL,
0, CSS_UNIT_PX);
}
 
css_error css__compose_line_height(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_line_height(child, &length, &unit);
 
if (type == CSS_LINE_HEIGHT_INHERIT) {
type = get_line_height(parent, &length, &unit);
}
 
return set_line_height(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/list_style_image.c
0,0 → 1,55
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_list_style_image(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_uri_none(opv, style, state, set_list_style_image);
}
 
css_error css__set_list_style_image_from_hint(const css_hint *hint,
css_computed_style *style)
{
css_error error;
 
error = set_list_style_image(style, hint->status, hint->data.string);
 
if (hint->data.string != NULL)
lwc_string_unref(hint->data.string);
 
return error;
}
 
css_error css__initial_list_style_image(css_select_state *state)
{
return set_list_style_image(state->computed,
CSS_LIST_STYLE_IMAGE_NONE, NULL);
}
 
css_error css__compose_list_style_image(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
lwc_string *url;
uint8_t type = get_list_style_image(child, &url);
 
if (type == CSS_LIST_STYLE_IMAGE_INHERIT) {
type = get_list_style_image(parent, &url);
}
 
return set_list_style_image(result, type, url);
}
 
/programs/network/netsurf/libcss/src/select/properties/list_style_position.c
0,0 → 1,67
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_list_style_position(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_LIST_STYLE_POSITION_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case LIST_STYLE_POSITION_INSIDE:
value = CSS_LIST_STYLE_POSITION_INSIDE;
break;
case LIST_STYLE_POSITION_OUTSIDE:
value = CSS_LIST_STYLE_POSITION_OUTSIDE;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_list_style_position(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_list_style_position_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_list_style_position(style, hint->status);
}
 
css_error css__initial_list_style_position(css_select_state *state)
{
return set_list_style_position(state->computed,
CSS_LIST_STYLE_POSITION_OUTSIDE);
}
 
css_error css__compose_list_style_position(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_list_style_position(child);
 
if (type == CSS_LIST_STYLE_POSITION_INHERIT) {
type = get_list_style_position(parent);
}
 
return set_list_style_position(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/list_style_type.c
0,0 → 1,105
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_list_style_type(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_LIST_STYLE_TYPE_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case LIST_STYLE_TYPE_DISC:
value = CSS_LIST_STYLE_TYPE_DISC;
break;
case LIST_STYLE_TYPE_CIRCLE:
value = CSS_LIST_STYLE_TYPE_CIRCLE;
break;
case LIST_STYLE_TYPE_SQUARE:
value = CSS_LIST_STYLE_TYPE_SQUARE;
break;
case LIST_STYLE_TYPE_DECIMAL:
value = CSS_LIST_STYLE_TYPE_DECIMAL;
break;
case LIST_STYLE_TYPE_DECIMAL_LEADING_ZERO:
value = CSS_LIST_STYLE_TYPE_DECIMAL_LEADING_ZERO;
break;
case LIST_STYLE_TYPE_LOWER_ROMAN:
value = CSS_LIST_STYLE_TYPE_LOWER_ROMAN;
break;
case LIST_STYLE_TYPE_UPPER_ROMAN:
value = CSS_LIST_STYLE_TYPE_UPPER_ROMAN;
break;
case LIST_STYLE_TYPE_LOWER_GREEK:
value = CSS_LIST_STYLE_TYPE_LOWER_GREEK;
break;
case LIST_STYLE_TYPE_LOWER_LATIN:
value = CSS_LIST_STYLE_TYPE_LOWER_LATIN;
break;
case LIST_STYLE_TYPE_UPPER_LATIN:
value = CSS_LIST_STYLE_TYPE_UPPER_LATIN;
break;
case LIST_STYLE_TYPE_ARMENIAN:
value = CSS_LIST_STYLE_TYPE_ARMENIAN;
break;
case LIST_STYLE_TYPE_GEORGIAN:
value = CSS_LIST_STYLE_TYPE_GEORGIAN;
break;
case LIST_STYLE_TYPE_LOWER_ALPHA:
value = CSS_LIST_STYLE_TYPE_LOWER_ALPHA;
break;
case LIST_STYLE_TYPE_UPPER_ALPHA:
value = CSS_LIST_STYLE_TYPE_UPPER_ALPHA;
break;
case LIST_STYLE_TYPE_NONE:
value = CSS_LIST_STYLE_TYPE_NONE;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_list_style_type(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_list_style_type_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_list_style_type(style, hint->status);
}
 
css_error css__initial_list_style_type(css_select_state *state)
{
return set_list_style_type(state->computed, CSS_LIST_STYLE_TYPE_DISC);
}
 
css_error css__compose_list_style_type(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_list_style_type(child);
 
if (type == CSS_LIST_STYLE_TYPE_INHERIT) {
type = get_list_style_type(parent);
}
 
return set_list_style_type(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/margin_bottom.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_margin_bottom(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length_auto(opv, style, state, set_margin_bottom);
}
 
css_error css__set_margin_bottom_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_margin_bottom(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_margin_bottom(css_select_state *state)
{
return set_margin_bottom(state->computed, CSS_MARGIN_SET, 0, CSS_UNIT_PX);
}
 
css_error css__compose_margin_bottom(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_margin_bottom(child, &length, &unit);
 
if (type == CSS_MARGIN_INHERIT) {
type = get_margin_bottom(parent, &length, &unit);
}
 
return set_margin_bottom(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/margin_left.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_margin_left(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length_auto(opv, style, state, set_margin_left);
}
 
css_error css__set_margin_left_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_margin_left(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_margin_left(css_select_state *state)
{
return set_margin_left(state->computed, CSS_MARGIN_SET, 0, CSS_UNIT_PX);
}
 
css_error css__compose_margin_left(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_margin_left(child, &length, &unit);
 
if (type == CSS_MARGIN_INHERIT) {
type = get_margin_left(parent, &length, &unit);
}
 
return set_margin_left(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/margin_right.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_margin_right(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length_auto(opv, style, state, set_margin_right);
}
 
css_error css__set_margin_right_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_margin_right(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_margin_right(css_select_state *state)
{
return set_margin_right(state->computed, CSS_MARGIN_SET, 0, CSS_UNIT_PX);
}
 
css_error css__compose_margin_right(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_margin_right(child, &length, &unit);
 
if (type == CSS_MARGIN_INHERIT) {
type = get_margin_right(parent, &length, &unit);
}
 
return set_margin_right(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/margin_top.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_margin_top(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length_auto(opv, style, state, set_margin_top);
}
 
css_error css__set_margin_top_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_margin_top(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_margin_top(css_select_state *state)
{
return set_margin_top(state->computed, CSS_MARGIN_SET, 0, CSS_UNIT_PX);
}
 
css_error css__compose_margin_top(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_margin_top(child, &length, &unit);
 
if (type == CSS_MARGIN_INHERIT) {
type = get_margin_top(parent, &length, &unit);
}
 
return set_margin_top(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/max_height.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_max_height(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length_none(opv, style, state, set_max_height);
}
 
css_error css__set_max_height_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_max_height(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_max_height(css_select_state *state)
{
return set_max_height(state->computed, CSS_MAX_HEIGHT_NONE,
0, CSS_UNIT_PX);
}
 
css_error css__compose_max_height(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_max_height(child, &length, &unit);
 
if (type == CSS_MAX_HEIGHT_INHERIT) {
type = get_max_height(parent, &length, &unit);
}
 
return set_max_height(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/max_width.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_max_width(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length_none(opv, style, state, set_max_width);;
}
 
css_error css__set_max_width_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_max_width(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_max_width(css_select_state *state)
{
return set_max_width(state->computed, CSS_MAX_WIDTH_NONE, 0, CSS_UNIT_PX);
}
 
css_error css__compose_max_width(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_max_width(child, &length, &unit);
 
if (type == CSS_MAX_WIDTH_INHERIT) {
type = get_max_width(parent, &length, &unit);
}
 
return set_max_width(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/min_height.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_min_height(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length(opv, style, state, set_min_height);
}
 
css_error css__set_min_height_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_min_height(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_min_height(css_select_state *state)
{
return set_min_height(state->computed, CSS_MIN_HEIGHT_SET,
0, CSS_UNIT_PX);
}
 
css_error css__compose_min_height(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_min_height(child, &length, &unit);
 
if (type == CSS_MIN_HEIGHT_INHERIT) {
type = get_min_height(parent, &length, &unit);
}
 
return set_min_height(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/min_width.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_min_width(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length(opv, style, state, set_min_width);
}
 
css_error css__set_min_width_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_min_width(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_min_width(css_select_state *state)
{
return set_min_width(state->computed, CSS_MIN_WIDTH_SET, 0, CSS_UNIT_PX);
}
 
css_error css__compose_min_width(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_min_width(child, &length, &unit);
 
if (type == CSS_MIN_WIDTH_INHERIT) {
type = get_min_width(parent, &length, &unit);
}
 
return set_min_width(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/opacity.c
0,0 → 1,62
/*
* This file is part of LibCSS
* Licensed under the MIT License,
* http://www.opensource.org/licenses/mit-license.php
* Copyright 2011 John-Mark Bell <jmb@netsurf-browser.org>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
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__set_opacity_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_opacity(style, hint->status, hint->data.fixed);
}
 
css_error css__initial_opacity(css_select_state *state)
{
return set_opacity(state->computed, CSS_OPACITY_SET, INTTOFIX(1));
}
 
css_error css__compose_opacity(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed opacity = 0;
uint8_t type = get_opacity(child, &opacity);
 
if (type == CSS_OPACITY_INHERIT) {
type = get_opacity(parent, &opacity);
}
 
return set_opacity(result, type, opacity);
}
 
/programs/network/netsurf/libcss/src/select/properties/orphans.c
0,0 → 1,47
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_orphans(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_number(opv, style, state, set_orphans);
}
 
css_error css__set_orphans_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_orphans(style, hint->status, hint->data.fixed);
}
 
css_error css__initial_orphans(css_select_state *state)
{
return set_orphans(state->computed, CSS_ORPHANS_SET, INTTOFIX(2));
}
 
css_error css__compose_orphans(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed count = 0;
uint8_t type = get_orphans(child, &count);
if (type == CSS_ORPHANS_INHERIT) {
type = get_orphans(parent, &count);
}
return set_orphans(result, type, count);
}
 
/programs/network/netsurf/libcss/src/select/properties/outline_color.c
0,0 → 1,81
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_outline_color(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_OUTLINE_COLOR_INHERIT;
css_color color = 0;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case OUTLINE_COLOR_TRANSPARENT:
value = CSS_OUTLINE_COLOR_COLOR;
break;
case OUTLINE_COLOR_CURRENT_COLOR:
value = CSS_OUTLINE_COLOR_CURRENT_COLOR;
break;
case OUTLINE_COLOR_SET:
value = CSS_OUTLINE_COLOR_COLOR;
color = *((css_color *) style->bytecode);
advance_bytecode(style, sizeof(color));
break;
case OUTLINE_COLOR_INVERT:
value = CSS_OUTLINE_COLOR_INVERT;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_outline_color(state->computed, value, color);
}
 
return CSS_OK;
}
 
css_error css__set_outline_color_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_outline_color(style, hint->status, hint->data.color);
}
 
css_error css__initial_outline_color(css_select_state *state)
{
return set_outline_color(state->computed, CSS_OUTLINE_COLOR_INVERT, 0);
}
 
css_error css__compose_outline_color(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_color color = 0;
uint8_t type = get_outline_color(child, &color);
 
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_OUTLINE_COLOR_INHERIT ||
(child->uncommon != NULL && result != child)) {
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_OUTLINE_COLOR_INHERIT) {
type = get_outline_color(parent, &color);
}
 
return set_outline_color(result, type, color);
}
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/outline_style.c
0,0 → 1,46
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_outline_style(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_border_style(opv, style, state, set_outline_style);
}
 
css_error css__set_outline_style_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_outline_style(style, hint->status);
}
 
css_error css__initial_outline_style(css_select_state *state)
{
return set_outline_style(state->computed, CSS_OUTLINE_STYLE_NONE);
}
 
css_error css__compose_outline_style(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_outline_style(child);
 
if (type == CSS_OUTLINE_STYLE_INHERIT) {
type = get_outline_style(parent);
}
 
return set_outline_style(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/outline_width.c
0,0 → 1,57
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_outline_width(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_border_width(opv, style, state, set_outline_width);
}
 
css_error css__set_outline_width_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_outline_width(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_outline_width(css_select_state *state)
{
return set_outline_width(state->computed, CSS_OUTLINE_WIDTH_MEDIUM,
0, CSS_UNIT_PX);
}
 
css_error css__compose_outline_width(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_outline_width(child, &length, &unit);
 
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_OUTLINE_WIDTH_INHERIT ||
(child->uncommon != NULL && result != child)) {
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_OUTLINE_WIDTH_INHERIT) {
type = get_outline_width(parent, &length, &unit);
}
 
return set_outline_width(result, type, length, unit);
}
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/overflow.c
0,0 → 1,72
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_overflow(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(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_overflow_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_overflow(style, hint->status);
}
 
css_error css__initial_overflow(css_select_state *state)
{
return set_overflow(state->computed, CSS_OVERFLOW_VISIBLE);
}
 
css_error css__compose_overflow(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_overflow(child);
 
if (type == CSS_OVERFLOW_INHERIT) {
type = get_overflow(parent);
}
 
return set_overflow(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/padding_bottom.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_padding_bottom(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length(opv, style, state, set_padding_bottom);
}
 
css_error css__set_padding_bottom_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_padding_bottom(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_padding_bottom(css_select_state *state)
{
return set_padding_bottom(state->computed, CSS_PADDING_SET,
0, CSS_UNIT_PX);
}
 
css_error css__compose_padding_bottom(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_padding_bottom(child, &length, &unit);
 
if (type == CSS_PADDING_INHERIT) {
type = get_padding_bottom(parent, &length, &unit);
}
 
return set_padding_bottom(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/padding_left.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_padding_left(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length(opv, style, state, set_padding_left);
}
 
css_error css__set_padding_left_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_padding_left(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_padding_left(css_select_state *state)
{
return set_padding_left(state->computed, CSS_PADDING_SET, 0, CSS_UNIT_PX);
}
 
css_error css__compose_padding_left(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_padding_left(child, &length, &unit);
 
if (type == CSS_PADDING_INHERIT) {
type = get_padding_left(parent, &length, &unit);
}
 
return set_padding_left(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/padding_right.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_padding_right(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length(opv, style, state, set_padding_right);
}
 
css_error css__set_padding_right_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_padding_right(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_padding_right(css_select_state *state)
{
return set_padding_right(state->computed, CSS_PADDING_SET,
0, CSS_UNIT_PX);
}
 
css_error css__compose_padding_right(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_padding_right(child, &length, &unit);
 
if (type == CSS_PADDING_INHERIT) {
type = get_padding_right(parent, &length, &unit);
}
 
return set_padding_right(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/padding_top.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_padding_top(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length(opv, style, state, set_padding_top);
}
 
css_error css__set_padding_top_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_padding_top(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_padding_top(css_select_state *state)
{
return set_padding_top(state->computed, CSS_PADDING_SET, 0, CSS_UNIT_PX);
}
 
css_error css__compose_padding_top(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_padding_top(child, &length, &unit);
 
if (type == CSS_PADDING_INHERIT) {
type = get_padding_top(parent, &length, &unit);
}
 
return set_padding_top(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/page_break_after.c
0,0 → 1,48
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_page_break_after(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_page_break_after_before_inside(opv, style, state,
set_page_break_after);
}
 
css_error css__set_page_break_after_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_page_break_after(style, hint->status);
}
 
css_error css__initial_page_break_after(css_select_state *state)
{
return set_page_break_after(state->computed,
CSS_PAGE_BREAK_AFTER_AUTO);
}
 
css_error css__compose_page_break_after(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_page_break_after(child);
 
if (type == CSS_PAGE_BREAK_AFTER_INHERIT) {
type = get_page_break_after(parent);
}
 
return set_page_break_after(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/page_break_before.c
0,0 → 1,47
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_page_break_before(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_page_break_after_before_inside(opv, style, state,
set_page_break_before);
}
 
css_error css__set_page_break_before_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_page_break_before(style, hint->status);
}
 
css_error css__initial_page_break_before(css_select_state *state)
{
return set_page_break_before(state->computed,
CSS_PAGE_BREAK_BEFORE_AUTO);
}
 
css_error css__compose_page_break_before(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_page_break_before(child);
if (type == CSS_PAGE_BREAK_BEFORE_INHERIT) {
type = get_page_break_before(parent);
}
return set_page_break_before(result, type);
}
/programs/network/netsurf/libcss/src/select/properties/page_break_inside.c
0,0 → 1,48
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_page_break_inside(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_page_break_after_before_inside(opv, style, state,
set_page_break_inside);
}
 
css_error css__set_page_break_inside_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_page_break_inside(style, hint->status);
}
 
css_error css__initial_page_break_inside(css_select_state *state)
{
return set_page_break_inside(state->computed,
CSS_PAGE_BREAK_INSIDE_AUTO);
}
 
css_error css__compose_page_break_inside(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_page_break_inside(child);
if (type == CSS_PAGE_BREAK_INSIDE_INHERIT) {
type = get_page_break_inside(parent);
}
return set_page_break_inside(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/pause_after.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_pause_after(uint32_t opv, css_style *style,
css_select_state *state)
{
/** \todo pause-after */
return css__cascade_length(opv, style, state, NULL);
}
 
css_error css__set_pause_after_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_pause_after(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_pause_after(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/pause_before.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_pause_before(uint32_t opv, css_style *style,
css_select_state *state)
{
/** \todo pause-before */
return css__cascade_length(opv, style, state, NULL);
}
 
css_error css__set_pause_before_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_pause_before(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_pause_before(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/pitch.c
0,0 → 1,77
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
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__set_pitch_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_pitch(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_pitch(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/pitch_range.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_pitch_range(uint32_t opv, css_style *style,
css_select_state *state)
{
/** \todo pitch-range */
return css__cascade_number(opv, style, state, NULL);
}
 
css_error css__set_pitch_range_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_pitch_range(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_pitch_range(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/play_during.c
0,0 → 1,71
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_play_during(uint32_t opv, css_style *style,
css_select_state *state)
{
lwc_string *uri = NULL;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case PLAY_DURING_URI:
css__stylesheet_string_get(style->sheet, *((css_code_t *) style->bytecode), &uri);
advance_bytecode(style, sizeof(css_code_t));
break;
case PLAY_DURING_AUTO:
case PLAY_DURING_NONE:
/** \todo convert to public values */
break;
}
 
/** \todo mix & repeat */
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
/** \todo play-during */
}
 
return CSS_OK;
}
 
css_error css__set_play_during_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_play_during(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_play_during(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/position.c
0,0 → 1,72
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_position(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_POSITION_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case POSITION_STATIC:
value = CSS_POSITION_STATIC;
break;
case POSITION_RELATIVE:
value = CSS_POSITION_RELATIVE;
break;
case POSITION_ABSOLUTE:
value = CSS_POSITION_ABSOLUTE;
break;
case POSITION_FIXED:
value = CSS_POSITION_FIXED;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_position(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_position_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_position(style, hint->status);
}
 
css_error css__initial_position(css_select_state *state)
{
return set_position(state->computed, CSS_POSITION_STATIC);
}
 
css_error css__compose_position(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_position(child);
 
if (type == CSS_POSITION_INHERIT) {
type = get_position(parent);
}
 
return set_position(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/properties.h
0,0 → 1,138
/*
* 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_properties_h_
#define css_select_properties_h_
 
#include <libcss/errors.h>
#include <libcss/computed.h>
 
#include "stylesheet.h"
#include "select/select.h"
 
#define PROPERTY_FUNCS(pname) \
css_error css__cascade_##pname (uint32_t opv, css_style *style, css_select_state *state); \
css_error css__set_##pname##_from_hint(const css_hint *hint, css_computed_style *style); \
css_error css__initial_##pname (css_select_state *state); \
css_error css__compose_##pname (const css_computed_style *parent, const css_computed_style *child, css_computed_style *result); \
uint32_t destroy_##pname (void *bytecode)
 
PROPERTY_FUNCS(azimuth);
PROPERTY_FUNCS(background_attachment);
PROPERTY_FUNCS(background_color);
PROPERTY_FUNCS(background_image);
PROPERTY_FUNCS(background_position);
PROPERTY_FUNCS(background_repeat);
PROPERTY_FUNCS(border_collapse);
PROPERTY_FUNCS(border_spacing);
PROPERTY_FUNCS(border_top_color);
PROPERTY_FUNCS(border_right_color);
PROPERTY_FUNCS(border_bottom_color);
PROPERTY_FUNCS(border_left_color);
PROPERTY_FUNCS(border_top_style);
PROPERTY_FUNCS(border_right_style);
PROPERTY_FUNCS(border_bottom_style);
PROPERTY_FUNCS(border_left_style);
PROPERTY_FUNCS(border_top_width);
PROPERTY_FUNCS(border_right_width);
PROPERTY_FUNCS(border_bottom_width);
PROPERTY_FUNCS(border_left_width);
PROPERTY_FUNCS(bottom);
PROPERTY_FUNCS(break_after);
PROPERTY_FUNCS(break_before);
PROPERTY_FUNCS(break_inside);
PROPERTY_FUNCS(caption_side);
PROPERTY_FUNCS(clear);
PROPERTY_FUNCS(clip);
PROPERTY_FUNCS(color);
PROPERTY_FUNCS(column_count);
PROPERTY_FUNCS(column_fill);
PROPERTY_FUNCS(column_gap);
PROPERTY_FUNCS(column_rule_color);
PROPERTY_FUNCS(column_rule_style);
PROPERTY_FUNCS(column_rule_width);
PROPERTY_FUNCS(column_span);
PROPERTY_FUNCS(column_width);
PROPERTY_FUNCS(content);
PROPERTY_FUNCS(counter_increment);
PROPERTY_FUNCS(counter_reset);
PROPERTY_FUNCS(cue_after);
PROPERTY_FUNCS(cue_before);
PROPERTY_FUNCS(cursor);
PROPERTY_FUNCS(direction);
PROPERTY_FUNCS(display);
PROPERTY_FUNCS(elevation);
PROPERTY_FUNCS(empty_cells);
PROPERTY_FUNCS(float);
PROPERTY_FUNCS(font_family);
PROPERTY_FUNCS(font_size);
PROPERTY_FUNCS(font_style);
PROPERTY_FUNCS(font_variant);
PROPERTY_FUNCS(font_weight);
PROPERTY_FUNCS(height);
PROPERTY_FUNCS(left);
PROPERTY_FUNCS(letter_spacing);
PROPERTY_FUNCS(line_height);
PROPERTY_FUNCS(list_style_image);
PROPERTY_FUNCS(list_style_position);
PROPERTY_FUNCS(list_style_type);
PROPERTY_FUNCS(margin_top);
PROPERTY_FUNCS(margin_right);
PROPERTY_FUNCS(margin_bottom);
PROPERTY_FUNCS(margin_left);
PROPERTY_FUNCS(max_height);
PROPERTY_FUNCS(max_width);
PROPERTY_FUNCS(min_height);
PROPERTY_FUNCS(min_width);
PROPERTY_FUNCS(opacity);
PROPERTY_FUNCS(orphans);
PROPERTY_FUNCS(outline_color);
PROPERTY_FUNCS(outline_style);
PROPERTY_FUNCS(outline_width);
PROPERTY_FUNCS(overflow);
PROPERTY_FUNCS(padding_top);
PROPERTY_FUNCS(padding_right);
PROPERTY_FUNCS(padding_bottom);
PROPERTY_FUNCS(padding_left);
PROPERTY_FUNCS(page_break_after);
PROPERTY_FUNCS(page_break_before);
PROPERTY_FUNCS(page_break_inside);
PROPERTY_FUNCS(pause_after);
PROPERTY_FUNCS(pause_before);
PROPERTY_FUNCS(pitch_range);
PROPERTY_FUNCS(pitch);
PROPERTY_FUNCS(play_during);
PROPERTY_FUNCS(position);
PROPERTY_FUNCS(quotes);
PROPERTY_FUNCS(richness);
PROPERTY_FUNCS(right);
PROPERTY_FUNCS(speak_header);
PROPERTY_FUNCS(speak_numeral);
PROPERTY_FUNCS(speak_punctuation);
PROPERTY_FUNCS(speak);
PROPERTY_FUNCS(speech_rate);
PROPERTY_FUNCS(stress);
PROPERTY_FUNCS(table_layout);
PROPERTY_FUNCS(text_align);
PROPERTY_FUNCS(text_decoration);
PROPERTY_FUNCS(text_indent);
PROPERTY_FUNCS(text_transform);
PROPERTY_FUNCS(top);
PROPERTY_FUNCS(unicode_bidi);
PROPERTY_FUNCS(vertical_align);
PROPERTY_FUNCS(visibility);
PROPERTY_FUNCS(voice_family);
PROPERTY_FUNCS(volume);
PROPERTY_FUNCS(white_space);
PROPERTY_FUNCS(widows);
PROPERTY_FUNCS(width);
PROPERTY_FUNCS(word_spacing);
PROPERTY_FUNCS(z_index);
 
#undef PROPERTY_FUNCS
 
#endif
/programs/network/netsurf/libcss/src/select/properties/quotes.c
0,0 → 1,167
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_quotes(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_QUOTES_INHERIT;
lwc_string **quotes = NULL;
uint32_t n_quotes = 0;
 
if (isInherit(opv) == false) {
uint32_t v = getValue(opv);
 
value = CSS_QUOTES_STRING;
 
while (v != QUOTES_NONE) {
lwc_string *open, *close;
lwc_string **temp;
 
css__stylesheet_string_get(style->sheet, *((css_code_t *) style->bytecode), &open);
advance_bytecode(style, sizeof(css_code_t));
 
css__stylesheet_string_get(style->sheet, *((css_code_t *) style->bytecode), &close);
advance_bytecode(style, sizeof(css_code_t));
 
temp = state->computed->alloc(quotes,
(n_quotes + 2) * sizeof(lwc_string *),
state->computed->pw);
if (temp == NULL) {
if (quotes != NULL) {
state->computed->alloc(quotes, 0,
state->computed->pw);
}
return CSS_NOMEM;
}
 
quotes = temp;
 
quotes[n_quotes++] = open;
quotes[n_quotes++] = close;
 
v = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(v));
}
}
 
/* Terminate array, if required */
if (n_quotes > 0) {
lwc_string **temp;
 
temp = state->computed->alloc(quotes,
(n_quotes + 1) * sizeof(lwc_string *),
state->computed->pw);
if (temp == NULL) {
state->computed->alloc(quotes, 0, state->computed->pw);
return CSS_NOMEM;
}
 
quotes = temp;
 
quotes[n_quotes] = NULL;
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
css_error error;
 
error = set_quotes(state->computed, value, quotes);
if (error != CSS_OK && quotes != NULL)
state->computed->alloc(quotes, 0, state->computed->pw);
 
return error;
} else {
if (quotes != NULL)
state->computed->alloc(quotes, 0, state->computed->pw);
}
 
return CSS_OK;
}
 
css_error css__set_quotes_from_hint(const css_hint *hint,
css_computed_style *style)
{
lwc_string **item;
css_error error;
error = set_quotes(style, hint->status, hint->data.strings);
 
for (item = hint->data.strings;
item != NULL && (*item) != NULL; item++) {
lwc_string_unref(*item);
}
 
if (error != CSS_OK && hint->data.strings != NULL)
style->alloc(hint->data.strings, 0, style->pw);
 
return error;
}
 
css_error css__initial_quotes(css_select_state *state)
{
css_hint hint;
css_error error;
 
error = state->handler->ua_default_for_property(state->pw,
CSS_PROP_QUOTES, &hint);
if (error != CSS_OK)
return error;
 
return css__set_quotes_from_hint(&hint, state->computed);
}
 
css_error css__compose_quotes(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_error error;
lwc_string **quotes = NULL;
uint8_t type = get_quotes(child, &quotes);
 
if (type == CSS_QUOTES_INHERIT || result != child) {
size_t n_quotes = 0;
lwc_string **copy = NULL;
 
if (type == CSS_QUOTES_INHERIT) {
type = get_quotes(parent, &quotes);
}
 
if (quotes != NULL) {
lwc_string **i;
 
for (i = quotes; (*i) != NULL; i++)
n_quotes++;
 
copy = result->alloc(NULL, (n_quotes + 1) *
sizeof(lwc_string *),
result->pw);
if (copy == NULL)
return CSS_NOMEM;
 
memcpy(copy, quotes, (n_quotes + 1) *
sizeof(lwc_string *));
}
 
error = set_quotes(result, type, copy);
if (error != CSS_OK && copy != NULL)
result->alloc(copy, 0, result->pw);
 
return error;
}
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/richness.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_richness(uint32_t opv, css_style *style,
css_select_state *state)
{
/** \todo richness */
return css__cascade_number(opv, style, state, NULL);
}
 
css_error css__set_richness_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_richness(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_richness(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/right.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_right(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length_auto(opv, style, state, set_right);
}
 
css_error css__set_right_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_right(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_right(css_select_state *state)
{
return set_right(state->computed, CSS_RIGHT_AUTO, 0, CSS_UNIT_PX);
}
 
css_error css__compose_right(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_right(child, &length, &unit);
 
if (type == CSS_RIGHT_INHERIT) {
type = get_right(parent, &length, &unit);
}
 
return set_right(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/speak.c
0,0 → 1,66
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_speak(uint32_t opv, css_style *style,
css_select_state *state)
{
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case SPEAK_NORMAL:
case SPEAK_NONE:
case SPEAK_SPELL_OUT:
/** \todo convert to public values */
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
/** \todo speak */
}
 
return CSS_OK;
}
 
css_error css__set_speak_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_speak(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_speak(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/speak_header.c
0,0 → 1,65
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_speak_header(uint32_t opv, css_style *style,
css_select_state *state)
{
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case SPEAK_HEADER_ONCE:
case SPEAK_HEADER_ALWAYS:
/** \todo convert to public values */
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
/** \todo speak-header */
}
 
return CSS_OK;
}
 
css_error css__set_speak_header_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_speak_header(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_speak_header(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/speak_numeral.c
0,0 → 1,65
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_speak_numeral(uint32_t opv, css_style *style,
css_select_state *state)
{
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case SPEAK_NUMERAL_DIGITS:
case SPEAK_NUMERAL_CONTINUOUS:
/** \todo convert to public values */
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
/** \todo speak-numeral */
}
 
return CSS_OK;
}
 
css_error css__set_speak_numeral_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_speak_numeral(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_speak_numeral(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/speak_punctuation.c
0,0 → 1,65
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_speak_punctuation(
uint32_t opv, css_style *style, css_select_state *state)
{
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case SPEAK_PUNCTUATION_CODE:
case SPEAK_PUNCTUATION_NONE:
/** \todo convert to public values */
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
/** \todo speak-punctuation */
}
 
return CSS_OK;
}
 
css_error css__set_speak_punctuation_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_speak_punctuation(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_speak_punctuation(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/speech_rate.c
0,0 → 1,74
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_speech_rate(uint32_t opv, css_style *style,
css_select_state *state)
{
css_fixed rate = 0;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case SPEECH_RATE_SET:
rate = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(rate));
break;
case SPEECH_RATE_X_SLOW:
case SPEECH_RATE_SLOW:
case SPEECH_RATE_MEDIUM:
case SPEECH_RATE_FAST:
case SPEECH_RATE_X_FAST:
case SPEECH_RATE_FASTER:
case SPEECH_RATE_SLOWER:
/** \todo convert to public values */
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
/** \todo speech-rate */
}
 
return CSS_OK;
}
 
css_error css__set_speech_rate_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_speech_rate(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_speech_rate(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/stress.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_stress(uint32_t opv, css_style *style,
css_select_state *state)
{
/** \todo stress */
return css__cascade_number(opv, style, state, NULL);
}
 
css_error css__set_stress_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_stress(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_stress(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/table_layout.c
0,0 → 1,66
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
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__set_table_layout_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_table_layout(style, hint->status);
}
 
css_error css__initial_table_layout(css_select_state *state)
{
return set_table_layout(state->computed, CSS_TABLE_LAYOUT_AUTO);
}
 
css_error css__compose_table_layout(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_table_layout(child);
 
if (type == CSS_TABLE_LAYOUT_INHERIT) {
type = get_table_layout(parent);
}
 
return set_table_layout(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/text_align.c
0,0 → 1,92
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
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__set_text_align_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_text_align(style, hint->status);
}
 
css_error css__initial_text_align(css_select_state *state)
{
return set_text_align(state->computed, CSS_TEXT_ALIGN_DEFAULT);
}
 
css_error css__compose_text_align(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_text_align(child);
 
if (type == CSS_TEXT_ALIGN_INHERIT) {
type = get_text_align(parent);
} else if (type == CSS_TEXT_ALIGN_INHERIT_IF_NON_MAGIC) {
/* This is purely for the benefit of HTML tables */
type = get_text_align(parent);
 
/* If the parent's text-align is a magical one,
* then reset to the default value. Otherwise,
* inherit as normal. */
if (type == CSS_TEXT_ALIGN_LIBCSS_LEFT ||
type == CSS_TEXT_ALIGN_LIBCSS_CENTER ||
type == CSS_TEXT_ALIGN_LIBCSS_RIGHT)
type = CSS_TEXT_ALIGN_DEFAULT;
}
 
return set_text_align(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/text_decoration.c
0,0 → 1,74
/*
* 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>
*/
 
#include <assert.h>
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_text_decoration(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_TEXT_DECORATION_INHERIT;
UNUSED(style);
 
if (isInherit(opv) == false) {
if (getValue(opv) == TEXT_DECORATION_NONE) {
value = CSS_TEXT_DECORATION_NONE;
} else {
assert(value == 0);
 
if (getValue(opv) & TEXT_DECORATION_UNDERLINE)
value |= CSS_TEXT_DECORATION_UNDERLINE;
if (getValue(opv) & TEXT_DECORATION_OVERLINE)
value |= CSS_TEXT_DECORATION_OVERLINE;
if (getValue(opv) & TEXT_DECORATION_LINE_THROUGH)
value |= CSS_TEXT_DECORATION_LINE_THROUGH;
if (getValue(opv) & TEXT_DECORATION_BLINK)
value |= CSS_TEXT_DECORATION_BLINK;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_text_decoration(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_text_decoration_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_text_decoration(style, hint->status);
}
 
css_error css__initial_text_decoration(css_select_state *state)
{
return set_text_decoration(state->computed, CSS_TEXT_DECORATION_NONE);
}
 
css_error css__compose_text_decoration(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_text_decoration(child);
 
if (type == CSS_TEXT_DECORATION_INHERIT) {
type = get_text_decoration(parent);
}
 
return set_text_decoration(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/text_indent.c
0,0 → 1,50
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_text_indent(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length(opv, style, state, set_text_indent);
}
 
css_error css__set_text_indent_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_text_indent(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_text_indent(css_select_state *state)
{
return set_text_indent(state->computed, CSS_TEXT_INDENT_SET,
0, CSS_UNIT_PX);
}
 
css_error css__compose_text_indent(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_text_indent(child, &length, &unit);
 
if (type == CSS_TEXT_INDENT_INHERIT) {
type = get_text_indent(parent, &length, &unit);
}
 
return set_text_indent(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/text_transform.c
0,0 → 1,72
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
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__set_text_transform_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_text_transform(style, hint->status);
}
 
css_error css__initial_text_transform(css_select_state *state)
{
return set_text_transform(state->computed, CSS_TEXT_TRANSFORM_NONE);
}
 
css_error css__compose_text_transform(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_text_transform(child);
 
if (type == CSS_TEXT_TRANSFORM_INHERIT) {
type = get_text_transform(parent);
}
 
return set_text_transform(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/top.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_top(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length_auto(opv, style, state, set_top);
}
 
css_error css__set_top_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_top(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_top(css_select_state *state)
{
return set_top(state->computed, CSS_TOP_AUTO, 0, CSS_UNIT_PX);
}
 
css_error css__compose_top(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_top(child, &length, &unit);
 
if (type == CSS_TOP_INHERIT) {
type = get_top(parent, &length, &unit);
}
 
return set_top(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/unicode_bidi.c
0,0 → 1,69
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_unicode_bidi(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_UNICODE_BIDI_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case UNICODE_BIDI_NORMAL:
value = CSS_UNICODE_BIDI_NORMAL;
break;
case UNICODE_BIDI_EMBED:
value = CSS_UNICODE_BIDI_EMBED;
break;
case UNICODE_BIDI_BIDI_OVERRIDE:
value = CSS_UNICODE_BIDI_BIDI_OVERRIDE;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_unicode_bidi(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_unicode_bidi_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_unicode_bidi(style, hint->status);
}
 
css_error css__initial_unicode_bidi(css_select_state *state)
{
return set_unicode_bidi(state->computed, CSS_UNICODE_BIDI_NORMAL);
}
 
css_error css__compose_unicode_bidi(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_unicode_bidi(child);
 
if (type == CSS_UNICODE_BIDI_INHERIT) {
type = get_unicode_bidi(parent);
}
 
return set_unicode_bidi(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/vertical_align.c
0,0 → 1,98
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_vertical_align(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_VERTICAL_ALIGN_INHERIT;
css_fixed length = 0;
uint32_t unit = UNIT_PX;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case VERTICAL_ALIGN_SET:
value = CSS_VERTICAL_ALIGN_SET;
 
length = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(length));
unit = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(unit));
break;
case VERTICAL_ALIGN_BASELINE:
value = CSS_VERTICAL_ALIGN_BASELINE;
break;
case VERTICAL_ALIGN_SUB:
value = CSS_VERTICAL_ALIGN_SUB;
break;
case VERTICAL_ALIGN_SUPER:
value = CSS_VERTICAL_ALIGN_SUPER;
break;
case VERTICAL_ALIGN_TOP:
value = CSS_VERTICAL_ALIGN_TOP;
break;
case VERTICAL_ALIGN_TEXT_TOP:
value = CSS_VERTICAL_ALIGN_TEXT_TOP;
break;
case VERTICAL_ALIGN_MIDDLE:
value = CSS_VERTICAL_ALIGN_MIDDLE;
break;
case VERTICAL_ALIGN_BOTTOM:
value = CSS_VERTICAL_ALIGN_BOTTOM;
break;
case VERTICAL_ALIGN_TEXT_BOTTOM:
value = CSS_VERTICAL_ALIGN_TEXT_BOTTOM;
break;
}
}
 
unit = css__to_css_unit(unit);
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_vertical_align(state->computed, value, length, unit);
}
 
return CSS_OK;
}
 
css_error css__set_vertical_align_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_vertical_align(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_vertical_align(css_select_state *state)
{
return set_vertical_align(state->computed, CSS_VERTICAL_ALIGN_BASELINE,
0, CSS_UNIT_PX);
}
 
css_error css__compose_vertical_align(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_vertical_align(child, &length, &unit);
 
if (type == CSS_VERTICAL_ALIGN_INHERIT) {
type = get_vertical_align(parent, &length, &unit);
}
 
return set_vertical_align(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/visibility.c
0,0 → 1,69
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
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__set_visibility_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_visibility(style, hint->status);
}
 
css_error css__initial_visibility(css_select_state *state)
{
return set_visibility(state->computed, CSS_VISIBILITY_VISIBLE);
}
 
css_error css__compose_visibility(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_visibility(child);
 
if (type == CSS_VISIBILITY_INHERIT) {
type = get_visibility(parent);
}
 
return set_visibility(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/voice_family.c
0,0 → 1,135
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_voice_family(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = 0;
lwc_string **voices = NULL;
uint32_t n_voices = 0;
 
if (isInherit(opv) == false) {
uint32_t v = getValue(opv);
 
while (v != VOICE_FAMILY_END) {
lwc_string *voice = NULL;
lwc_string **temp;
 
switch (v) {
case VOICE_FAMILY_STRING:
case VOICE_FAMILY_IDENT_LIST:
css__stylesheet_string_get(style->sheet, *((css_code_t *) style->bytecode), &voice);
advance_bytecode(style, sizeof(css_code_t));
break;
case VOICE_FAMILY_MALE:
if (value == 0)
value = 1;
break;
case VOICE_FAMILY_FEMALE:
if (value == 0)
value = 1;
break;
case VOICE_FAMILY_CHILD:
if (value == 0)
value = 1;
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 == 0 && voice != NULL) {
temp = state->computed->alloc(voices,
(n_voices + 1) * sizeof(lwc_string *),
state->computed->pw);
if (temp == NULL) {
if (voices != NULL) {
state->computed->alloc(voices, 0,
state->computed->pw);
}
return CSS_NOMEM;
}
 
voices = temp;
 
voices[n_voices] = voice;
 
n_voices++;
}
 
v = *((uint32_t *) style->bytecode);
advance_bytecode(style, sizeof(v));
}
}
 
/* Terminate array with blank entry, if needed */
if (n_voices > 0) {
lwc_string **temp;
 
temp = state->computed->alloc(voices,
(n_voices + 1) * sizeof(lwc_string *),
state->computed->pw);
if (temp == NULL) {
state->computed->alloc(voices, 0, state->computed->pw);
return CSS_NOMEM;
}
 
voices = temp;
 
voices[n_voices] = NULL;
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
/** \todo voice-family */
if (n_voices > 0)
state->computed->alloc(voices, 0, state->computed->pw);
} else {
if (n_voices > 0)
state->computed->alloc(voices, 0, state->computed->pw);
}
 
return CSS_OK;
}
 
css_error css__set_voice_family_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_voice_family(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_voice_family(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/volume.c
0,0 → 1,82
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
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__set_volume_from_hint(const css_hint *hint,
css_computed_style *style)
{
UNUSED(hint);
UNUSED(style);
 
return CSS_OK;
}
 
css_error css__initial_volume(css_select_state *state)
{
UNUSED(state);
 
return CSS_OK;
}
 
css_error css__compose_volume(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
UNUSED(parent);
UNUSED(child);
UNUSED(result);
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/white_space.c
0,0 → 1,75
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_white_space(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_WHITE_SPACE_INHERIT;
 
UNUSED(style);
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case WHITE_SPACE_NORMAL:
value = CSS_WHITE_SPACE_NORMAL;
break;
case WHITE_SPACE_PRE:
value = CSS_WHITE_SPACE_PRE;
break;
case WHITE_SPACE_NOWRAP:
value = CSS_WHITE_SPACE_NOWRAP;
break;
case WHITE_SPACE_PRE_WRAP:
value = CSS_WHITE_SPACE_PRE_WRAP;
break;
case WHITE_SPACE_PRE_LINE:
value = CSS_WHITE_SPACE_PRE_LINE;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_white_space(state->computed, value);
}
 
return CSS_OK;
}
 
css_error css__set_white_space_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_white_space(style, hint->status);
}
 
css_error css__initial_white_space(css_select_state *state)
{
return set_white_space(state->computed, CSS_WHITE_SPACE_NORMAL);
}
 
css_error css__compose_white_space(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
uint8_t type = get_white_space(child);
 
if (type == CSS_WHITE_SPACE_INHERIT) {
type = get_white_space(parent);
}
 
return set_white_space(result, type);
}
 
/programs/network/netsurf/libcss/src/select/properties/width.c
0,0 → 1,49
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_width(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length_auto(opv, style, state, set_width);
}
 
css_error css__set_width_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_width(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_width(css_select_state *state)
{
return set_width(state->computed, CSS_WIDTH_AUTO, 0, CSS_UNIT_PX);
}
 
css_error css__compose_width(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_width(child, &length, &unit);
 
if (type == CSS_WIDTH_INHERIT) {
type = get_width(parent, &length, &unit);
}
 
return set_width(result, type, length, unit);
}
 
/programs/network/netsurf/libcss/src/select/properties/windows.c
0,0 → 1,47
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_widows(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_number(opv, style, state, set_widows);
}
 
css_error css__set_widows_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_widows(style, hint->status, hint->data.fixed);
}
 
css_error css__initial_widows(css_select_state *state)
{
return set_widows(state->computed, CSS_WIDOWS_SET, INTTOFIX(2));
}
 
css_error css__compose_widows(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed count = 0;
uint8_t type = get_widows(child, &count);
if (type == CSS_WIDOWS_INHERIT) {
type = get_widows(parent, &count);
}
return set_widows(result, type, count);
}
 
/programs/network/netsurf/libcss/src/select/properties/word_spacing.c
0,0 → 1,57
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_word_spacing(uint32_t opv, css_style *style,
css_select_state *state)
{
return css__cascade_length_normal(opv, style, state, set_word_spacing);
}
 
css_error css__set_word_spacing_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_word_spacing(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
 
css_error css__initial_word_spacing(css_select_state *state)
{
return set_word_spacing(state->computed, CSS_WORD_SPACING_NORMAL,
0, CSS_UNIT_PX);
}
 
css_error css__compose_word_spacing(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_word_spacing(child, &length, &unit);
 
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_WORD_SPACING_INHERIT ||
(child->uncommon != NULL && result != child)) {
if ((child->uncommon == NULL && parent->uncommon != NULL) ||
type == CSS_WORD_SPACING_INHERIT) {
type = get_word_spacing(parent, &length, &unit);
}
 
return set_word_spacing(result, type, length, unit);
}
 
return CSS_OK;
}
 
/programs/network/netsurf/libcss/src/select/properties/z_index.c
0,0 → 1,69
/*
* 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>
*/
 
#include "bytecode/bytecode.h"
#include "bytecode/opcodes.h"
#include "select/propset.h"
#include "select/propget.h"
#include "utils/utils.h"
 
#include "select/properties/properties.h"
#include "select/properties/helpers.h"
 
css_error css__cascade_z_index(uint32_t opv, css_style *style,
css_select_state *state)
{
uint16_t value = CSS_Z_INDEX_INHERIT;
css_fixed index = 0;
 
if (isInherit(opv) == false) {
switch (getValue(opv)) {
case Z_INDEX_SET:
value = CSS_Z_INDEX_SET;
 
index = *((css_fixed *) style->bytecode);
advance_bytecode(style, sizeof(index));
break;
case Z_INDEX_AUTO:
value = CSS_Z_INDEX_AUTO;
break;
}
}
 
if (css__outranks_existing(getOpcode(opv), isImportant(opv), state,
isInherit(opv))) {
return set_z_index(state->computed, value, index);
}
 
return CSS_OK;
}
 
css_error css__set_z_index_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_z_index(style, hint->status, hint->data.integer);
}
 
css_error css__initial_z_index(css_select_state *state)
{
return set_z_index(state->computed, CSS_Z_INDEX_AUTO, 0);
}
 
css_error css__compose_z_index(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
int32_t index = 0;
uint8_t type = get_z_index(child, &index);
 
if (type == CSS_Z_INDEX_INHERIT) {
type = get_z_index(parent, &index);
}
 
return set_z_index(result, type, index);
}