dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / css / style_values / shorthand_style_value_3.lucb
#==============================================================================================
#
# shorthand_style_value_3 - ShorthandStyleValue: the special cases of serialize (grid, mask, text)
#
# DESCRIPTION:
# Port of the cases of ShorthandStyleValue::serialize's switch (ShorthandStyleValue.cpp
# lines 553-980) that shorthand_style_value_1 calls, one function per shorthand, in the
# switch's order. Each was a `case` body in C++: `return` there ends serialize, here it ends
# the case's function, which serialize returns from at once. The lambdas of a case are
# functions named after them.
#
# Copyright (c) 2023, Ali Mohammad Pur <mpfard@serenityos.org>
# Copyright (c) 2018-2020, Andreas Kling <andreas@ladybird.org>
# Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
# Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
# Copyright (c) 2022-2023, MacDue <macdue@dueutil.tech>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: Grid ====================================================================================
## The `is_auto` lambda of the `grid-area` case.
func css_shorthand_is_auto_track_placement(track_placement: CssStyleValue*) -> bool:
if css_style_value_is_grid_track_placement(track_placement):
let placement = css_grid_track_placement_style_value_grid_track_placement(css_style_value_as_grid_track_placement(track_placement))
return css_grid_track_placement_is_auto(&placement)
return false
## The `serialize_grid_area` lambda of the `grid-area` case.
func css_shorthand_serialize_grid_area(builder: ak.StringBuilder*, mode: css_syntax.SerializationMode, row_start: CssStyleValue*, column_start: CssStyleValue*, row_end: CssStyleValue*, column_end: CssStyleValue*):
if css_style_values_equal(row_start, column_start) and css_style_values_equal(row_start, row_end) and css_style_values_equal(row_start, column_end):
css_style_value_serialize(row_start, builder, mode)
return
if css_style_values_equal(row_start, row_end) and css_style_values_equal(column_start, column_end):
css_style_value_serialize(row_start, builder, mode)
ak.string_builder_append(builder, " / ")
css_style_value_serialize(column_start, builder, mode)
return
if css_style_values_equal(column_start, column_end):
if css_shorthand_is_auto_track_placement(row_end):
if css_shorthand_is_auto_track_placement(column_start):
css_style_value_serialize(row_start, builder, mode)
return
css_style_value_serialize(row_start, builder, mode)
ak.string_builder_append(builder, " / ")
css_style_value_serialize(column_start, builder, mode)
return
css_style_value_serialize(row_start, builder, mode)
ak.string_builder_append(builder, " / ")
css_style_value_serialize(column_start, builder, mode)
ak.string_builder_append(builder, " / ")
css_style_value_serialize(row_end, builder, mode)
return
css_style_value_serialize(row_start, builder, mode)
ak.string_builder_append(builder, " / ")
css_style_value_serialize(column_start, builder, mode)
ak.string_builder_append(builder, " / ")
css_style_value_serialize(row_end, builder, mode)
ak.string_builder_append(builder, " / ")
css_style_value_serialize(column_end, builder, mode)
## ShorthandStyleValue::serialize, `case PropertyID::GridArea` (ShorthandStyleValue.cpp:553).
func css_shorthand_style_value_serialize_grid_area(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
# https://drafts.csswg.org/css-grid/#propdef-grid-area
# The grid-area property is a shorthand for grid-row-start, grid-column-start, grid-row-end and grid-column-end.
var row_start = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_row_start)
var column_start = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_column_start)
var row_end = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_row_end)
var column_end = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_column_end)
# If four <grid-line> values are specified, grid-row-start is set to the first value, grid-column-start is set
# to the second value, grid-row-end is set to the third value, and grid-column-end is set to the fourth value.
if not css_shorthand_is_auto_track_placement(row_start) and not css_shorthand_is_auto_track_placement(column_start) and not css_shorthand_is_auto_track_placement(row_end) and not css_shorthand_is_auto_track_placement(column_end):
css_shorthand_serialize_grid_area(builder, mode, row_start, column_start, row_end, column_end)
return
# When grid-column-end is omitted, if grid-column-start is a <custom-ident>, grid-column-end is set to that
# <custom-ident>; otherwise, it is set to auto.
if css_shorthand_is_auto_track_placement(column_end) and css_style_value_is_custom_ident(column_start):
column_end = column_start
# When grid-column-start is omitted, if grid-row-start is a <custom-ident>, all four longhands are set to
# that value. Otherwise, it is set to auto.
if css_shorthand_is_auto_track_placement(column_start) and css_style_value_is_custom_ident(row_start):
column_start = row_start
row_end = row_start
column_end = row_start
# When grid-row-end is omitted, if grid-row-start is a <custom-ident>, grid-row-end is set to that
# <custom-ident>; otherwise, it is set to auto.
if css_shorthand_is_auto_track_placement(row_end) and css_style_value_is_custom_ident(row_start):
row_end = row_start
css_shorthand_serialize_grid_area(builder, mode, row_start, column_start, row_end, column_end)
## The `is_initial` lambda of the `grid` case.
func css_shorthand_is_initial(value: CssStyleValue*, property: css_data.PropertyId) -> bool:
return css_style_value_eq(value, css_property_initial_value(property))
## ShorthandStyleValue::serialize, `case PropertyID::Grid` (ShorthandStyleValue.cpp:629). Answers whether the case
## falls through to `grid-template` (C++'s `[[fallthrough]]`).
func css_shorthand_style_value_serialize_grid(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode) -> bool:
# https://drafts.csswg.org/css-grid/#propdef-grid
# <'grid-template'> |
# <'grid-template-rows'> / [ auto-flow && dense? ] <'grid-auto-columns'>? |
# [ auto-flow && dense? ] <'grid-auto-rows'>? / <'grid-template-columns'>
let auto_flow_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_auto_flow)
let auto_rows_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_auto_rows)
let auto_columns_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_auto_columns)
let auto_flow_is_initial = css_shorthand_is_initial(auto_flow_value, css_data.PropertyId.grid_auto_flow)
let auto_rows_is_initial = css_shorthand_is_initial(auto_rows_value, css_data.PropertyId.grid_auto_rows)
let auto_columns_is_initial = css_shorthand_is_initial(auto_columns_value, css_data.PropertyId.grid_auto_columns)
if not auto_flow_is_initial or not auto_rows_is_initial or not auto_columns_is_initial:
let areas_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_template_areas)
let rows_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_template_rows)
let columns_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_template_columns)
let areas_is_initial = css_shorthand_is_initial(areas_value, css_data.PropertyId.grid_template_areas)
let rows_is_initial = css_shorthand_is_initial(rows_value, css_data.PropertyId.grid_template_rows)
let columns_is_initial = css_shorthand_is_initial(columns_value, css_data.PropertyId.grid_template_columns)
let auto_flow = css_style_value_as_grid_auto_flow(auto_flow_value)
# [ auto-flow && dense? ] <'grid-auto-rows'>? / <'grid-template-columns'>
if css_grid_auto_flow_style_value_is_row(auto_flow) and auto_columns_is_initial and areas_is_initial and rows_is_initial:
ak.string_builder_append(builder, "auto-flow")
if css_grid_auto_flow_style_value_is_dense(auto_flow):
ak.string_builder_append(builder, " dense")
if not auto_rows_is_initial:
ak.string_builder_append_u8(builder, ' ')
css_style_value_serialize(auto_rows_value, builder, mode)
ak.string_builder_append(builder, " / ")
css_style_value_serialize(columns_value, builder, mode)
return false
# <'grid-template-rows'> / [ auto-flow && dense? ] <'grid-auto-columns'>?
if css_grid_auto_flow_style_value_is_column(auto_flow) and auto_rows_is_initial and areas_is_initial and columns_is_initial:
css_style_value_serialize(rows_value, builder, mode)
ak.string_builder_append(builder, " / auto-flow")
if css_grid_auto_flow_style_value_is_dense(auto_flow):
ak.string_builder_append(builder, " dense")
if not auto_columns_is_initial:
ak.string_builder_append_u8(builder, ' ')
css_style_value_serialize(auto_columns_value, builder, mode)
return false
return false
# <'grid-template'>
return true
## The `construct_rows_string` lambda of the `grid-template` case.
func css_shorthand_construct_rows_string(areas: CssGridTemplateAreaStyleValue*, rows: CssGridTrackSizeListStyleValue*, mode: css_syntax.SerializationMode) -> ak.String:
var inner_builder = ak.string_builder_new()
var area_index: usize = 0
let row_list = css_grid_track_size_list_style_value_grid_track_size_list(rows)
let list = css_grid_track_size_list_list(&row_list)
for i in 0..<ak.vector_size(&list):
match *ak.vector_at_const(&list, i):
.css_grid_line_names(line_names):
if i != 0:
ak.string_builder_append_u8(&inner_builder, ' ')
css_grid_line_names_serialize(&line_names, &inner_builder)
.css_explicit_grid_track(track_size):
if area_index < css_grid_template_area_style_value_row_count(areas):
if not ak.string_builder_is_empty(&inner_builder):
ak.string_builder_append_u8(&inner_builder, ' ')
ak.string_builder_append(&inner_builder, "\"")
for y in 0..<css_grid_template_area_style_value_column_count(areas):
if y != 0:
ak.string_builder_append_u8(&inner_builder, ' ')
let cell_name = css_grid_template_area_style_value_cell_name_at(areas, area_index, y)
ak.string_builder_append_string_view(&inner_builder, ak.string_bytes_as_string_view(&cell_name))
ak.string_builder_append(&inner_builder, "\"")
let track_size_serialization = css_explicit_grid_track_to_string(&track_size, mode)
if not ak.string_eq_string_view(&track_size_serialization, ak.sv("auto")):
if not ak.string_builder_is_empty(&inner_builder):
ak.string_builder_append_u8(&inner_builder, ' ')
ak.string_builder_append_string_view(&inner_builder, ak.string_bytes_as_string_view(&track_size_serialization))
area_index += 1
return ak.string_builder_to_string(&inner_builder) else trap("MUST: StringBuilder::to_string")
## ShorthandStyleValue::serialize, `case PropertyID::GridTemplate` (ShorthandStyleValue.cpp:690).
func css_shorthand_style_value_serialize_grid_template(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
let areas_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_template_areas)
let rows_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_template_rows)
let columns_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_template_columns)
if not css_style_value_is_grid_template_area(areas_value) or not css_style_value_is_grid_track_size_list(rows_value) or not css_style_value_is_grid_track_size_list(columns_value):
css_shorthand_style_value_default_serialize(this, builder, mode)
return
let areas = css_style_value_as_grid_template_area(areas_value)
let rows = css_style_value_as_grid_track_size_list(rows_value)
let columns = css_style_value_as_grid_track_size_list(columns_value)
let row_list = css_grid_track_size_list_style_value_grid_track_size_list(rows)
let column_list = css_grid_track_size_list_style_value_grid_track_size_list(columns)
let row_tracks = css_grid_track_size_list_track_list(&row_list)
let column_tracks = css_grid_track_size_list_track_list(&column_list)
if css_grid_template_area_style_value_row_count(areas) == 0 and ak.vector_size(&row_tracks) == 0 and ak.vector_size(&column_tracks) == 0:
ak.string_builder_append(builder, "none")
return
if css_grid_template_area_style_value_row_count(areas) == 0:
css_grid_track_size_list_serialize(&row_list, builder, mode)
ak.string_builder_append(builder, " / ")
css_grid_track_size_list_serialize(&column_list, builder, mode)
return
let rows_serialization = css_shorthand_construct_rows_string(areas, rows, mode)
if ak.string_is_empty(&rows_serialization):
return
if css_grid_track_size_list_is_empty(&column_list):
ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&rows_serialization))
return
ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&rows_serialization))
ak.string_builder_append(builder, " / ")
css_grid_track_size_list_serialize(&column_list, builder, mode)
## ShorthandStyleValue::serialize, `case PropertyID::GridColumn` and `case PropertyID::GridRow`
## (ShorthandStyleValue.cpp:758, 770), the same body over a start and an end longhand.
func css_shorthand_style_value_serialize_grid_line_pair(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode, start_id: css_data.PropertyId, end_id: css_data.PropertyId):
let start = css_shorthand_style_value_required_longhand(this, start_id)
let end = css_shorthand_style_value_required_longhand(this, end_id)
let end_placement = css_grid_track_placement_style_value_grid_track_placement(css_style_value_as_grid_track_placement(end))
if css_grid_track_placement_is_auto(&end_placement) or css_style_values_equal(start, end):
css_style_value_serialize(start, builder, mode)
return
css_style_value_serialize(start, builder, mode)
ak.string_builder_append(builder, " / ")
css_style_value_serialize(end, builder, mode)
# mark: Mask ====================================================================================
## The value of a property among a mask layer's, the `property_value_string` lambda of the `mask` case.
func css_shorthand_mask_property_value_string(property_ids: const css_data.PropertyId[], property_values: const (CssStyleValue*?)[], property: css_data.PropertyId, mode: css_syntax.SerializationMode) -> ak.String:
for i in 0..<property_ids.length:
if property_ids[i] == property:
return css_style_value_to_string(property_values[i] else trap("VERIFY: a mask layer value"), mode)
trap("VERIFY_NOT_REACHED")
## The `is_initial_value` lambda of the `mask` case.
func css_shorthand_mask_is_initial_value(property_ids: const css_data.PropertyId[], property_values: const (CssStyleValue*?)[], property: css_data.PropertyId, mode: css_syntax.SerializationMode) -> bool:
let value_string = css_shorthand_mask_property_value_string(property_ids, property_values, property, mode)
let initial_string = css_style_value_to_string(css_property_initial_value(property), mode)
return css_strings_equal(value_string, initial_string)
## The `can_skip_serializing_initial_value` lambda of the `mask` case.
func css_shorthand_mask_can_skip_serializing_initial_value(property_ids: const css_data.PropertyId[], property_values: const (CssStyleValue*?)[], property: css_data.PropertyId, mode: css_syntax.SerializationMode) -> bool:
match property:
.mask_position:
return css_shorthand_mask_is_initial_value(property_ids, property_values, css_data.PropertyId.mask_size, mode)
.mask_origin:
let clip_string = css_shorthand_mask_property_value_string(property_ids, property_values, css_data.PropertyId.mask_clip, mode)
return css_shorthand_mask_is_initial_value(property_ids, property_values, css_data.PropertyId.mask_clip, mode) or ak.string_eq_string_view(&clip_string, css_data.string_from_keyword(css_data.Keyword.no_clip))
_:
return true
## The `serialize_layer` lambda of the `mask` case.
func css_shorthand_serialize_mask_layer(builder: ak.StringBuilder*, mode: css_syntax.SerializationMode, image_value: CssStyleValue*?, position_value: CssStyleValue*?, size_value: CssStyleValue*?, repeat_value: CssStyleValue*?, origin_value: CssStyleValue*?, clip_value: CssStyleValue*?, composite_value: CssStyleValue*?, mode_value: CssStyleValue*?):
let canonical_property_order: css_data.PropertyId[7] = [
css_data.PropertyId.mask_image,
css_data.PropertyId.mask_position,
# Intentionally skipping MaskSize here, it is handled together with MaskPosition.
css_data.PropertyId.mask_repeat,
css_data.PropertyId.mask_origin,
css_data.PropertyId.mask_clip,
css_data.PropertyId.mask_composite,
css_data.PropertyId.mask_mode,
]
let property_ids: css_data.PropertyId[8] = [css_data.PropertyId.mask_image, css_data.PropertyId.mask_position, css_data.PropertyId.mask_size, css_data.PropertyId.mask_repeat, css_data.PropertyId.mask_origin, css_data.PropertyId.mask_clip, css_data.PropertyId.mask_composite, css_data.PropertyId.mask_mode]
let property_values: (CssStyleValue*?)[8] = [image_value, position_value, size_value, repeat_value, origin_value, clip_value, composite_value, mode_value]
var layer_is_empty = true
for property in canonical_property_order:
let value = css_shorthand_mask_property_value_string(property_ids, property_values, property, mode)
if css_shorthand_mask_is_initial_value(property_ids, property_values, property, mode) and css_shorthand_mask_can_skip_serializing_initial_value(property_ids, property_values, property, mode):
continue
if property == css_data.PropertyId.mask_clip and css_strings_equal(value, css_shorthand_mask_property_value_string(property_ids, property_values, css_data.PropertyId.mask_origin, mode)):
continue
if not layer_is_empty:
ak.string_builder_append_u8(builder, ' ')
ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&value))
if property == css_data.PropertyId.mask_position and not css_shorthand_mask_is_initial_value(property_ids, property_values, css_data.PropertyId.mask_size, mode):
ak.string_builder_append(builder, " / ")
let size_string = css_shorthand_mask_property_value_string(property_ids, property_values, css_data.PropertyId.mask_size, mode)
ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&size_string))
layer_is_empty = false
if layer_is_empty:
ak.string_builder_append(builder, "none")
## ShorthandStyleValue::serialize, `case PropertyID::Mask` (ShorthandStyleValue.cpp:782).
func css_shorthand_style_value_serialize_mask(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
let mask_image = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_image)
let mask_position = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_position)
let mask_size = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_size)
let mask_repeat = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_repeat)
let mask_origin = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_origin)
let mask_clip = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_clip)
let mask_composite = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_composite)
let mask_mode = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_mode)
let layer_count = ak.max[usize](css_shorthand_layer_count(mask_image), ak.max[usize](css_shorthand_layer_count(mask_position), ak.max[usize](css_shorthand_layer_count(mask_size), ak.max[usize](css_shorthand_layer_count(mask_repeat), ak.max[usize](css_shorthand_layer_count(mask_origin), ak.max[usize](css_shorthand_layer_count(mask_clip), ak.max[usize](css_shorthand_layer_count(mask_composite), css_shorthand_layer_count(mask_mode))))))))
if layer_count == 1:
css_shorthand_serialize_mask_layer(builder, mode, mask_image, mask_position, mask_size, mask_repeat, mask_origin, mask_clip, mask_composite, mask_mode)
else:
for i in 0..<layer_count:
if i != 0:
ak.string_builder_append(builder, ", ")
css_shorthand_serialize_mask_layer(builder, mode, css_shorthand_layer_value(mask_image, i), css_shorthand_layer_value(mask_position, i), css_shorthand_layer_value(mask_size, i), css_shorthand_layer_value(mask_repeat, i), css_shorthand_layer_value(mask_origin, i), css_shorthand_layer_value(mask_clip, i), css_shorthand_layer_value(mask_composite, i), css_shorthand_layer_value(mask_mode, i))
# mark: Text ====================================================================================
## The `append_if_non_default` lambda of the `text-decoration` case.
func css_shorthand_append_if_non_default(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode, property_id: css_data.PropertyId):
let value = css_shorthand_style_value_required_longhand(this, property_id)
if not css_style_value_equals(value, css_property_initial_value(property_id)):
if not ak.string_builder_is_empty(builder):
ak.string_builder_append_u8(builder, ' ')
css_style_value_serialize(value, builder, mode)
## ShorthandStyleValue::serialize, `case PropertyID::TextDecoration` (ShorthandStyleValue.cpp:900).
func css_shorthand_style_value_serialize_text_decoration(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
# The rule here seems to be, only print what's different from the default value,
# but if they're all default, print the line.
css_shorthand_append_if_non_default(this, builder, mode, css_data.PropertyId.text_decoration_line)
css_shorthand_append_if_non_default(this, builder, mode, css_data.PropertyId.text_decoration_thickness)
css_shorthand_append_if_non_default(this, builder, mode, css_data.PropertyId.text_decoration_style)
css_shorthand_append_if_non_default(this, builder, mode, css_data.PropertyId.text_decoration_color)
if ak.string_builder_is_empty(builder):
css_style_value_serialize(css_shorthand_style_value_required_longhand(this, css_data.PropertyId.text_decoration_line), builder, mode)
## ShorthandStyleValue::serialize, `case PropertyID::WhiteSpace` (ShorthandStyleValue.cpp:933).
func css_shorthand_style_value_serialize_white_space(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
let white_space_collapse_property = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.white_space_collapse)
let text_wrap_mode_property = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.text_wrap_mode)
let white_space_trim_property = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.white_space_trim)
if css_style_value_is_keyword(white_space_trim_property) and css_keyword_style_value_keyword(css_style_value_as_keyword(white_space_trim_property)) == css_data.Keyword.none_:
let white_space_collapse_keyword = css_keyword_style_value_keyword(css_style_value_as_keyword(white_space_collapse_property))
let text_wrap_mode_keyword = css_keyword_style_value_keyword(css_style_value_as_keyword(text_wrap_mode_property))
if white_space_collapse_keyword == css_data.Keyword.collapse and text_wrap_mode_keyword == css_data.Keyword.wrap:
ak.string_builder_append(builder, "normal")
return
if white_space_collapse_keyword == css_data.Keyword.preserve and text_wrap_mode_keyword == css_data.Keyword.nowrap:
ak.string_builder_append(builder, "pre")
return
if white_space_collapse_keyword == css_data.Keyword.preserve and text_wrap_mode_keyword == css_data.Keyword.wrap:
ak.string_builder_append(builder, "pre-wrap")
return
if white_space_collapse_keyword == css_data.Keyword.preserve_breaks and text_wrap_mode_keyword == css_data.Keyword.wrap:
ak.string_builder_append(builder, "pre-line")
return
css_shorthand_style_value_default_serialize(this, builder, mode)