dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / css / computed_properties_3.lucb
#==============================================================================================
#
# computed_properties_3 - ComputedProperties: equality, text, content, cursor, shadows
#
# DESCRIPTION:
# Port of LibWeb/CSS/ComputedProperties.cpp (lines 891-1398): operator==, the text
# readers (anchor, alignment, justification, overflow, rendering, underline, tab-size,
# word-break, spacing, white-space, decoration, transform, indent), the line and outline
# styles, float, caret-color, clear, column-span, `content` (with quotes and counters),
# content-visibility, cursor, visibility, display, list-style, overflow and the box and
# text shadows.
#
# Copyright (c) 2018-2025, Andreas Kling <andreas@ladybird.org>
# Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: Equality and text =======================================================================
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:897 Web::CSS::ComputedProperties::operator==.
pub func css_computed_properties_eq(this: CssComputedProperties*, other: CssComputedProperties*) -> bool:
for i in 0..<css_data.number_of_longhand_properties:
let my_style = this.m_property_values[i]
let other_style = other.m_property_values[i]
if let my_value = my_style:
let other_value = other_style else return false
if css_style_value_type(my_value) != css_style_value_type(other_value):
return false
if not css_style_value_equals(my_value, other_value):
return false
elif other_style != none:
return false
return true
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:920 Web::CSS::ComputedProperties::text_anchor.
pub func css_computed_properties_text_anchor(this: CssComputedProperties*) -> css_data.TextAnchor:
let value = css_computed_properties_property(this, css_data.PropertyId.text_anchor)
return css_data.keyword_to_text_anchor(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:926 Web::CSS::ComputedProperties::dominant_baseline.
pub func css_computed_properties_dominant_baseline(this: CssComputedProperties*) -> css_data.BaselineMetric?:
let value = css_computed_properties_property(this, css_data.PropertyId.dominant_baseline)
return css_data.keyword_to_baseline_metric(css_style_value_to_keyword(value))
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:932 Web::CSS::ComputedProperties::text_align.
pub func css_computed_properties_text_align(this: CssComputedProperties*) -> css_data.TextAlign:
let value = css_computed_properties_property(this, css_data.PropertyId.text_align)
return css_data.keyword_to_text_align(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:938 Web::CSS::ComputedProperties::text_justify.
pub func css_computed_properties_text_justify(this: CssComputedProperties*) -> css_data.TextJustify:
let value = css_computed_properties_property(this, css_data.PropertyId.text_justify)
return css_data.keyword_to_text_justify(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:944 Web::CSS::ComputedProperties::text_overflow.
pub func css_computed_properties_text_overflow(this: CssComputedProperties*) -> css_data.TextOverflow:
let value = css_computed_properties_property(this, css_data.PropertyId.text_overflow)
return css_data.keyword_to_text_overflow(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:950 Web::CSS::ComputedProperties::text_rendering.
pub func css_computed_properties_text_rendering(this: CssComputedProperties*) -> css_data.TextRendering:
let value = css_computed_properties_property(this, css_data.PropertyId.text_rendering)
return css_data.keyword_to_text_rendering(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:956 Web::CSS::ComputedProperties::text_underline_offset.
pub func css_computed_properties_text_underline_offset(this: CssComputedProperties*) -> gfx.CssPixels:
let computed_text_underline_offset = css_computed_properties_property(this, css_data.PropertyId.text_underline_offset)
# auto
if css_style_value_to_keyword(computed_text_underline_offset) == css_data.Keyword.auto:
return css_initial_values_text_underline_offset()
# <length>
# <percentage>
let length = css_length_from_style_value(computed_text_underline_offset, css_length_make_px_css_pixels(css_computed_properties_font_size(this)))
return css_length_absolute_length_to_px(&length)
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:969 Web::CSS::ComputedProperties::text_underline_position.
pub func css_computed_properties_text_underline_position(this: CssComputedProperties*) -> CssTextUnderlinePosition:
let computed_text_underline_position = css_style_value_as_text_underline_position(css_computed_properties_property(this, css_data.PropertyId.text_underline_position))
return CssTextUnderlinePosition(
horizontal = css_text_underline_position_style_value_horizontal(computed_text_underline_position),
vertical = css_text_underline_position_style_value_vertical(computed_text_underline_position))
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:979 Web::CSS::ComputedProperties::pointer_events.
pub func css_computed_properties_pointer_events(this: CssComputedProperties*) -> css_data.PointerEvents:
let value = css_computed_properties_property(this, css_data.PropertyId.pointer_events)
return css_data.keyword_to_pointer_events(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:985 Web::CSS::ComputedProperties::tab_size.
pub func css_computed_properties_tab_size(this: CssComputedProperties*) -> CssLengthOrF64:
let value = css_computed_properties_property(this, css_data.PropertyId.tab_size)
if css_style_value_is_calculated(value):
let math_value = css_style_value_as_calculated(value)
if css_calculated_style_value_resolves_to_length(math_value):
return CssLengthOrF64.css_length(css_calculated_style_value_resolve_length(math_value, CssCalculationResolutionContext()) else trap("VERIFY: Optional::value() of resolve_length()"))
if css_calculated_style_value_resolves_to_number(math_value):
return CssLengthOrF64.f64_(css_calculated_style_value_resolve_number(math_value, CssCalculationResolutionContext()) else trap("VERIFY: Optional::value() of resolve_number()"))
if css_style_value_is_length(value):
return CssLengthOrF64.css_length(css_length_style_value_length(css_style_value_as_length(value)))
return CssLengthOrF64.f64_(css_number_style_value_number(css_style_value_as_number(value)))
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1004 Web::CSS::ComputedProperties::word_break.
pub func css_computed_properties_word_break(this: CssComputedProperties*) -> css_data.WordBreak:
let value = css_computed_properties_property(this, css_data.PropertyId.word_break)
return css_data.keyword_to_word_break(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1010 Web::CSS::ComputedProperties::word_spacing.
pub func css_computed_properties_word_spacing(this: CssComputedProperties*) -> gfx.CssPixels:
let value = css_computed_properties_property(this, css_data.PropertyId.word_spacing)
if css_style_value_is_keyword(value) and css_style_value_to_keyword(value) == css_data.Keyword.normal:
return gfx.css_pixels_from_int(0)
let length = css_length_from_style_value(value, css_length_make_px_css_pixels(css_computed_properties_font_size(this)))
return css_length_absolute_length_to_px(&length)
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1019 Web::CSS::ComputedProperties::white_space_collapse.
pub func css_computed_properties_white_space_collapse(this: CssComputedProperties*) -> css_data.WhiteSpaceCollapse:
let value = css_computed_properties_property(this, css_data.PropertyId.white_space_collapse)
return css_data.keyword_to_white_space_collapse(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1025 Web::CSS::ComputedProperties::white_space_trim.
pub func css_computed_properties_white_space_trim(this: CssComputedProperties*) -> CssWhiteSpaceTrimData:
let value = css_computed_properties_property(this, css_data.PropertyId.white_space_trim)
if css_style_value_is_keyword(value) and css_style_value_to_keyword(value) == css_data.Keyword.none_:
return CssWhiteSpaceTrimData()
if css_style_value_is_value_list(value):
var white_space_trim_data = CssWhiteSpaceTrimData()
let values = css_style_value_list_values(css_style_value_as_value_list(value))
for item in ak.vector_span_const(&values):
match css_keyword_style_value_keyword(css_style_value_as_keyword(item)):
.discard_before:
white_space_trim_data.discard_before = true
.discard_after:
white_space_trim_data.discard_after = true
.discard_inner:
white_space_trim_data.discard_inner = true
_:
trap("VERIFY_NOT_REACHED")
return white_space_trim_data
trap("VERIFY_NOT_REACHED")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1057 Web::CSS::ComputedProperties::letter_spacing.
pub func css_computed_properties_letter_spacing(this: CssComputedProperties*) -> gfx.CssPixels:
let value = css_computed_properties_property(this, css_data.PropertyId.letter_spacing)
if css_style_value_is_keyword(value) and css_style_value_to_keyword(value) == css_data.Keyword.normal:
return gfx.css_pixels_from_int(0)
let length = css_length_from_style_value(value, css_length_make_px_css_pixels(css_computed_properties_font_size(this)))
return css_length_absolute_length_to_px(&length)
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1066 Web::CSS::ComputedProperties::line_style.
pub func css_computed_properties_line_style(this: CssComputedProperties*, property_id: css_data.PropertyId) -> css_data.LineStyle:
let value = css_computed_properties_property(this, property_id)
return css_data.keyword_to_line_style(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1072 Web::CSS::ComputedProperties::outline_style.
pub func css_computed_properties_outline_style(this: CssComputedProperties*) -> css_data.OutlineStyle:
let value = css_computed_properties_property(this, css_data.PropertyId.outline_style)
return css_data.keyword_to_outline_style(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1078 Web::CSS::ComputedProperties::float_.
pub func css_computed_properties_float(this: CssComputedProperties*) -> css_data.Float:
let value = css_computed_properties_property(this, css_data.PropertyId.float)
return css_data.keyword_to_float(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1084 Web::CSS::ComputedProperties::caret_color.
pub func css_computed_properties_caret_color(this: CssComputedProperties*, node: LayoutNodeWithStyle*) -> gfx.Color:
let value = css_computed_properties_property(this, css_data.PropertyId.caret_color)
if css_style_value_is_keyword(value) and css_style_value_to_keyword(value) == css_data.Keyword.auto:
let computed_values = layout_node_with_style_computed_values(node)
return css_computed_values_color(&computed_values.computed_values)
if css_style_value_has_color(value):
return css_style_value_to_color(value, css_color_resolution_context_for_layout_node_with_style(node)) else trap("VERIFY: Optional::value() of to_color()")
return css_initial_values_caret_color()
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1096 Web::CSS::ComputedProperties::clear.
pub func css_computed_properties_clear(this: CssComputedProperties*) -> css_data.Clear:
let value = css_computed_properties_property(this, css_data.PropertyId.clear)
return css_data.keyword_to_clear(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1102 Web::CSS::ComputedProperties::column_span.
pub func css_computed_properties_column_span(this: CssComputedProperties*) -> css_data.ColumnSpan:
let value = css_computed_properties_property(this, css_data.PropertyId.column_span)
return css_data.keyword_to_column_span(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
# mark: content =================================================================================
## The `get_quote_string` lambda of ComputedProperties::content: the open or close quote at `depth`.
func css_computed_properties_get_quote_string(quotes_data: const CssQuotesData*, open: bool, depth: u32) -> ak.FlyString:
match quotes_data.type_:
.none_:
return ak.FlyString()
.auto:
# FIXME: "A typographically appropriate used value for quotes is automatically chosen by the UA
# based on the content language of the element and/or its parent."
if open:
return ak.fly_string_from_str("“") if depth == 0 else ak.fly_string_from_str("‘")
return ak.fly_string_from_str("”") if depth == 0 else ak.fly_string_from_str("’")
.specified:
# If the depth is greater than the number of pairs, the last pair is repeated.
let level = ak.vector_at_const("es_data.strings, ak.min((usize)depth, ak.vector_size("es_data.strings) - 1))
return (*level)[0] if open else (*level)[1]
_:
trap("VERIFY_NOT_REACHED")
## C++ `dbgln("`{}` is not supported in `<property>` (yet?)", item->to_string(SerializationMode::Normal))`.
func css_computed_properties_dbgln_unsupported(item: CssStyleValue*, property: str):
let text = css_style_value_to_string(item, css_syntax.SerializationMode.normal)
ak.dbgln(f"`{ak.string_view_text(ak.string_bytes_as_string_view(&text))}` is not supported in `{property}` (yet?)")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1108 Web::CSS::ComputedProperties::content.
pub func css_computed_properties_content(this: CssComputedProperties*, element_reference: DomAbstractElement*, initial_quote_nesting_level: u32) -> CssComputedPropertiesContentDataAndQuoteNestingLevel:
let value = css_computed_properties_property(this, css_data.PropertyId.content)
let quotes_data = css_computed_properties_quotes(this)
var quote_nesting_level = initial_quote_nesting_level
if css_style_value_is_content(value):
let content_style_value = css_style_value_as_content(value)
var content_data = CssContentData()
let items = css_style_value_list_values(css_content_style_value_content(content_style_value))
for item in ak.vector_span_const(&items):
if css_style_value_is_string(item):
let string_value = css_string_style_value_string_value(css_style_value_as_string(item))
ak.vector_append_t(&content_data.data, StringOrCssImageStyleValue.string(ak.fly_string_to_string_const(&string_value)))
elif css_style_value_is_keyword(item):
match css_style_value_to_keyword(item):
.open_quote:
let quote = css_computed_properties_get_quote_string("es_data, true, quote_nesting_level)
quote_nesting_level += 1
ak.vector_append_t(&content_data.data, StringOrCssImageStyleValue.string(ak.fly_string_to_string_const("e)))
.close_quote:
# A 'close-quote' or 'no-close-quote' that would make the depth negative is in error and is ignored
# (at rendering time): the depth stays at 0 and no quote mark is rendered (although the rest of the
# 'content' property's value is still inserted).
# - https://www.w3.org/TR/CSS21/generate.html#quotes-insert
# (This is missing from the CONTENT-3 spec.)
if quote_nesting_level > 0:
quote_nesting_level -= 1
let quote = css_computed_properties_get_quote_string("es_data, false, quote_nesting_level)
ak.vector_append_t(&content_data.data, StringOrCssImageStyleValue.string(ak.fly_string_to_string_const("e)))
.no_open_quote:
quote_nesting_level += 1
.no_close_quote:
# NOTE: See CloseQuote
if quote_nesting_level > 0:
quote_nesting_level -= 1
_:
css_computed_properties_dbgln_unsupported(item, "content")
elif css_style_value_is_counter(item):
let counter = css_style_value_as_counter(item)
let counter_style = css_style_value_as_counter_style(css_counter_style_value_counter_style(counter))
ak.vector_append_t(&content_data.counter_style_dependencies, css_counter_style_style_value_resolve_counter_style(counter_style, dom_abstract_element_style_scope(element_reference)))
ak.vector_append_t(&content_data.data, StringOrCssImageStyleValue.string(css_counter_style_value_resolve(counter, element_reference)))
elif css_style_value_is_image(item):
ak.vector_append_t(&content_data.data, StringOrCssImageStyleValue.css_image_style_value(css_style_value_as_image(item)))
else:
# TODO: Implement images, and other things.
css_computed_properties_dbgln_unsupported(item, "content")
content_data.type_ = CssContentDataType.list
if let alt_text = css_content_style_value_alt_text(content_style_value):
var alt_text_builder = ak.string_builder_new()
let alt_items = css_style_value_list_values(alt_text)
for item in ak.vector_span_const(&alt_items):
if css_style_value_is_string(item):
let string_value = css_string_style_value_string_value(css_style_value_as_string(item))
ak.string_builder_append_string_view(&alt_text_builder, ak.fly_string_bytes_as_string_view(&string_value))
elif css_style_value_is_counter(item):
let counter = css_style_value_as_counter(item)
let counter_style = css_style_value_as_counter_style(css_counter_style_value_counter_style(counter))
ak.vector_append_t(&content_data.counter_style_dependencies, css_counter_style_style_value_resolve_counter_style(counter_style, dom_abstract_element_style_scope(element_reference)))
let resolved = css_counter_style_value_resolve(counter, element_reference)
ak.string_builder_append_string_view(&alt_text_builder, ak.string_bytes_as_string_view(&resolved))
else:
css_computed_properties_dbgln_unsupported(item, "content` alt-text")
content_data.alt_text = ak.string_builder_to_string(&alt_text_builder) else trap("MUST: StringBuilder::to_string()")
return CssComputedPropertiesContentDataAndQuoteNestingLevel(content_data = content_data, final_quote_nesting_level = quote_nesting_level)
match css_style_value_to_keyword(value):
.none_:
return CssComputedPropertiesContentDataAndQuoteNestingLevel(content_data = CssContentData(type_ = CssContentDataType.none_), final_quote_nesting_level = quote_nesting_level)
.normal:
return CssComputedPropertiesContentDataAndQuoteNestingLevel(content_data = CssContentData(type_ = CssContentDataType.normal), final_quote_nesting_level = quote_nesting_level)
_:
_ = value
return CssComputedPropertiesContentDataAndQuoteNestingLevel(content_data = CssContentData(), final_quote_nesting_level = quote_nesting_level)
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1209 Web::CSS::ComputedProperties::content_visibility.
pub func css_computed_properties_content_visibility(this: CssComputedProperties*) -> css_data.ContentVisibility:
let value = css_computed_properties_property(this, css_data.PropertyId.content_visibility)
return css_data.keyword_to_content_visibility(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
# mark: Cursor, visibility, display, decorations, lists =========================================
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1215 Web::CSS::ComputedProperties::cursor.
pub func css_computed_properties_cursor(this: CssComputedProperties*) -> ak.Vector[CssCursorData]:
# Return the first available cursor.
let value = css_computed_properties_property(this, css_data.PropertyId.cursor)
var cursors: ak.Vector[CssCursorData]
if css_style_value_is_value_list(value):
let items = css_style_value_list_values(css_style_value_as_value_list(value))
for item in ak.vector_span_const(&items):
if css_style_value_is_cursor(item):
ak.vector_append_t(&cursors, CssCursorData.css_cursor_style_value(css_style_value_as_cursor(item)))
continue
if let keyword = css_data.keyword_to_cursor_predefined(css_style_value_to_keyword(item)):
ak.vector_append_t(&cursors, CssCursorData.cursor_predefined(keyword))
elif css_style_value_is_keyword(value):
if let keyword = css_data.keyword_to_cursor_predefined(css_style_value_to_keyword(value)):
ak.vector_append_t(&cursors, CssCursorData.cursor_predefined(keyword))
if ak.vector_is_empty(&cursors):
ak.vector_append_t(&cursors, CssCursorData.cursor_predefined(css_data.CursorPredefined.auto))
return cursors
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1241 Web::CSS::ComputedProperties::visibility.
pub func css_computed_properties_visibility(this: CssComputedProperties*) -> css_data.Visibility:
let value = css_computed_properties_property(this, css_data.PropertyId.visibility)
if not css_style_value_is_keyword(value):
return css_data.Visibility.collapse # `return {};`: the enum's zero value
return css_data.keyword_to_visibility(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1249 Web::CSS::ComputedProperties::display.
pub func css_computed_properties_display(this: CssComputedProperties*) -> CssDisplay:
return css_display_style_value_display(css_style_value_as_display(css_computed_properties_property(this, css_data.PropertyId.display)))
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1254 Web::CSS::ComputedProperties::text_decoration_line.
pub func css_computed_properties_text_decoration_line(this: CssComputedProperties*) -> ak.Vector[css_data.TextDecorationLine]:
let value = css_computed_properties_property(this, css_data.PropertyId.text_decoration_line)
if css_style_value_to_keyword(value) == css_data.Keyword.none_:
return ak.Vector[css_data.TextDecorationLine]()
if css_style_value_is_value_list(value):
var lines: ak.Vector[css_data.TextDecorationLine]
let values = css_style_value_list_values(css_style_value_as_value_list(value))
for item in ak.vector_span_const(&values):
ak.vector_append_t(&lines, css_data.keyword_to_text_decoration_line(css_style_value_to_keyword(item)) else trap("VERIFY: Optional::value()"))
return lines
trap("VERIFY_NOT_REACHED")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1273 Web::CSS::ComputedProperties::text_decoration_skip_ink.
pub func css_computed_properties_text_decoration_skip_ink(this: CssComputedProperties*) -> css_data.TextDecorationSkipInk:
let value = css_computed_properties_property(this, css_data.PropertyId.text_decoration_skip_ink)
return css_data.keyword_to_text_decoration_skip_ink(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1279 Web::CSS::ComputedProperties::text_decoration_style.
pub func css_computed_properties_text_decoration_style(this: CssComputedProperties*) -> css_data.TextDecorationStyle:
let value = css_computed_properties_property(this, css_data.PropertyId.text_decoration_style)
return css_data.keyword_to_text_decoration_style(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1285 Web::CSS::ComputedProperties::text_decoration_thickness.
pub func css_computed_properties_text_decoration_thickness(this: CssComputedProperties*) -> CssTextDecorationThickness:
let value = css_computed_properties_property(this, css_data.PropertyId.text_decoration_thickness)
if css_style_value_is_keyword(value):
match css_style_value_to_keyword(value):
.auto:
return CssTextDecorationThickness(value = CssTextDecorationThicknessAutoOrCssTextDecorationThicknessFromFontOrCssLengthPercentage.css_text_decoration_thickness_auto(CssTextDecorationThicknessAuto()))
.from_font:
return CssTextDecorationThickness(value = CssTextDecorationThicknessAutoOrCssTextDecorationThicknessFromFontOrCssLengthPercentage.css_text_decoration_thickness_from_font(CssTextDecorationThicknessFromFont()))
_:
trap("VERIFY_NOT_REACHED")
return CssTextDecorationThickness(value = CssTextDecorationThicknessAutoOrCssTextDecorationThicknessFromFontOrCssLengthPercentage.css_length_percentage(css_length_percentage_from_style_value(value)))
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1302 Web::CSS::ComputedProperties::text_transform.
pub func css_computed_properties_text_transform(this: CssComputedProperties*) -> css_data.TextTransform:
let value = css_computed_properties_property(this, css_data.PropertyId.text_transform)
return css_data.keyword_to_text_transform(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1308 Web::CSS::ComputedProperties::list_style_type.
pub func css_computed_properties_list_style_type(this: CssComputedProperties*, style_scope: const CssStyleScope*) -> CssListStyleType:
let value = css_computed_properties_property(this, css_data.PropertyId.list_style_type)
if css_style_value_to_keyword(value) == css_data.Keyword.none_:
return CssListStyleType.empty
if css_style_value_is_string(value):
let string_value = css_string_style_value_string_value(css_style_value_as_string(value))
return CssListStyleType.string(ak.fly_string_to_string_const(&string_value))
return CssListStyleType.css_counter_style(css_counter_style_style_value_resolve_counter_style(css_style_value_as_counter_style(value), style_scope))
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1321 Web::CSS::ComputedProperties::list_style_position.
pub func css_computed_properties_list_style_position(this: CssComputedProperties*) -> css_data.ListStylePosition:
let value = css_computed_properties_property(this, css_data.PropertyId.list_style_position)
return css_data.keyword_to_list_style_position(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
# mark: Overflow, shadows, text-indent ==========================================================
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1327 Web::CSS::ComputedProperties::overflow_x.
pub func css_computed_properties_overflow_x(this: CssComputedProperties*) -> css_data.Overflow:
return css_computed_properties_overflow(this, css_data.PropertyId.overflow_x)
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1332 Web::CSS::ComputedProperties::overflow_y.
pub func css_computed_properties_overflow_y(this: CssComputedProperties*) -> css_data.Overflow:
return css_computed_properties_overflow(this, css_data.PropertyId.overflow_y)
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1337 Web::CSS::ComputedProperties::overflow.
pub func css_computed_properties_overflow(this: CssComputedProperties*, property_id: css_data.PropertyId) -> css_data.Overflow:
let value = css_computed_properties_property(this, property_id)
return css_data.keyword_to_overflow(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")
## The `make_shadow_data` lambda of ComputedProperties::shadow.
func css_computed_properties_make_shadow_data(layout_node: LayoutNode*, value: CssShadowStyleValue*) -> CssShadowData?:
let offset_x = css_length_from_style_value(css_shadow_style_value_offset_x(value), none)
let offset_y = css_length_from_style_value(css_shadow_style_value_offset_y(value), none)
let blur_radius = css_length_from_style_value(css_shadow_style_value_blur_radius(value), none)
let spread_distance = css_length_from_style_value(css_shadow_style_value_spread_distance(value), none)
return CssShadowData(
offset_x = offset_x,
offset_y = offset_y,
blur_radius = blur_radius,
spread_distance = spread_distance,
color = css_style_value_to_color(css_shadow_style_value_color(value), css_color_resolution_context_for_layout_node_with_style(as_layout_node_with_style(layout_node))) else trap("VERIFY: Optional::value() of to_color()"),
placement = css_shadow_style_value_placement(value))
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1343 Web::CSS::ComputedProperties::shadow.
pub func css_computed_properties_shadow(this: CssComputedProperties*, property_id: css_data.PropertyId, layout_node: LayoutNode*) -> ak.Vector[CssShadowData]:
let value = css_computed_properties_property(this, property_id)
if css_style_value_to_keyword(value) == css_data.Keyword.none_:
return ak.Vector[CssShadowData]()
let value_list = css_style_value_as_value_list(value)
var shadow_data: ak.Vector[CssShadowData]
ak.vector_ensure_capacity(&shadow_data, css_style_value_list_size(value_list))
let layers = css_style_value_list_values(value_list)
for layer_value in ak.vector_span_const(&layers):
let maybe_shadow_data = css_computed_properties_make_shadow_data(layout_node, css_style_value_as_shadow(layer_value)) else return ak.Vector[CssShadowData]()
ak.vector_append_t(&shadow_data, maybe_shadow_data)
return shadow_data
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1379 Web::CSS::ComputedProperties::box_shadow.
pub func css_computed_properties_box_shadow(this: CssComputedProperties*, layout_node: LayoutNode*) -> ak.Vector[CssShadowData]:
return css_computed_properties_shadow(this, css_data.PropertyId.box_shadow, layout_node)
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1384 Web::CSS::ComputedProperties::text_shadow.
pub func css_computed_properties_text_shadow(this: CssComputedProperties*, layout_node: LayoutNode*) -> ak.Vector[CssShadowData]:
return css_computed_properties_shadow(this, css_data.PropertyId.text_shadow, layout_node)
## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1389 Web::CSS::ComputedProperties::text_indent.
pub func css_computed_properties_text_indent(this: CssComputedProperties*) -> CssTextIndentData:
let value = css_style_value_as_text_indent(css_computed_properties_property(this, css_data.PropertyId.text_indent))
return CssTextIndentData(
length_percentage = css_length_percentage_from_style_value(css_text_indent_style_value_length_percentage(value)),
each_line = css_text_indent_style_value_each_line(value),
hanging = css_text_indent_style_value_hanging(value))