dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / css / grid_track_size.lucb
#==============================================================================================
#
# grid_track_size - the grid track sizing values: GridSize, GridMinMax, GridRepeat,
# ExplicitGridTrack, GridLineNames, GridTrackSizeList
#
# DESCRIPTION:
# Port of LibWeb/CSS/GridTrackSize.cpp (lines 1-321) and the inline members of
# GridTrackSize.h, in the order of GridTrackSize.cpp with each class's header members
# first. The variant visits are matches. The defaulted operator==s that the C++ relies
# on (style values compare by value: ValueComparingRefPtr) are the css_*_eq functions;
# GridTrackSizeList's out-of-line defaulted operator== is css_grid_track_size_list_eq.
#
# Copyright (c) 2022, Martin Falisse <mfalisse@outlook.com>
# Copyright (c) 2025, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
# Copyright (c) 2025, Sam Atkins <sam@ladybird.org>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: GridSize ================================================================================
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:17 Web::CSS::GridSize::GridSize.
pub func css_grid_size_construct(this: CssGridSize*, size: CssStyleValue*):
this.m_value = size
## `GridSize { size }` as a value.
pub func css_grid_size_new(size: CssStyleValue*) -> CssGridSize:
var grid_size: CssGridSize = ---
css_grid_size_construct(&grid_size, size)
return grid_size
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:24 Web::CSS::GridSize::is_auto.
pub func css_grid_size_is_auto(this: const CssGridSize*, available_size: LayoutAvailableSize) -> bool:
if css_style_value_to_keyword(this.m_value) == css_data.Keyword.auto:
return true
if css_style_value_is_percentage(this.m_value) or (css_style_value_is_calculated(this.m_value) and css_calculated_style_value_contains_percentage(css_style_value_as_calculated(this.m_value))):
return not layout_available_size_is_definite(&available_size)
return false
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:35 Web::CSS::is_length_percentage.
func css_is_length_percentage(value: CssStyleValue*) -> bool:
return css_style_value_is_length(value) or css_style_value_is_percentage(value) or (css_style_value_is_calculated(value) and css_calculated_style_value_resolves_to_length(css_style_value_as_calculated(value)))
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:40 Web::CSS::GridSize::is_fixed.
pub func css_grid_size_is_fixed(this: const CssGridSize*, available_size: LayoutAvailableSize) -> bool:
if not css_is_length_percentage(this.m_value):
return false
if css_style_value_is_percentage(this.m_value) or (css_style_value_is_calculated(this.m_value) and css_calculated_style_value_contains_percentage(css_style_value_as_calculated(this.m_value))):
return layout_available_size_is_definite(&available_size)
return true
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:51 Web::CSS::GridSize::is_flexible_length.
pub func css_grid_size_is_flexible_length(this: const CssGridSize*) -> bool:
return css_style_value_is_flex(this.m_value) or (css_style_value_is_calculated(this.m_value) and css_calculated_style_value_resolves_to_flex(css_style_value_as_calculated(this.m_value)))
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:56 Web::CSS::GridSize::is_fit_content.
pub func css_grid_size_is_fit_content(this: const CssGridSize*) -> bool:
if css_style_value_to_keyword(this.m_value) == css_data.Keyword.fit_content:
return true
if css_style_value_is_function(this.m_value):
let name = css_function_style_value_name(css_style_value_as_function(this.m_value))
if ak.fly_string_eq_string_view(&name, ak.sv("fit-content")):
return true
return false
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:67 Web::CSS::GridSize::is_max_content.
pub func css_grid_size_is_max_content(this: const CssGridSize*) -> bool:
return css_style_value_to_keyword(this.m_value) == css_data.Keyword.max_content
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:72 Web::CSS::GridSize::is_min_content.
pub func css_grid_size_is_min_content(this: const CssGridSize*) -> bool:
return css_style_value_to_keyword(this.m_value) == css_data.Keyword.min_content
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:34 Web::CSS::GridSize::css_size.
pub func css_grid_size_css_size(this: const CssGridSize*) -> CssSize:
return css_size_from_style_value(this.m_value)
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:35 Web::CSS::GridSize::flex_factor.
pub func css_grid_size_flex_factor(this: const CssGridSize*) -> f64:
let flex = css_flex_from_style_value(this.m_value)
return css_flex_to_fr(&flex)
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:37 Web::CSS::GridSize::style_value.
pub func css_grid_size_style_value(this: const CssGridSize*) -> CssStyleValue*:
return this.m_value
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:77 Web::CSS::GridSize::is_intrinsic.
# https://www.w3.org/TR/css-grid-2/#layout-algorithm
# An intrinsic sizing function (min-content, max-content, auto, fit-content()).
pub func css_grid_size_is_intrinsic(this: const CssGridSize*, available_size: LayoutAvailableSize) -> bool:
return css_grid_size_is_auto(this, available_size) or css_grid_size_is_max_content(this) or css_grid_size_is_min_content(this) or css_grid_size_is_fit_content(this)
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:82 Web::CSS::GridSize::is_definite.
pub func css_grid_size_is_definite(this: const CssGridSize*) -> bool:
return css_is_length_percentage(this.m_value)
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:87 Web::CSS::GridSize::make_auto.
pub func css_grid_size_make_auto() -> CssGridSize:
return css_grid_size_new(css_keyword_style_value_create(css_data.Keyword.auto).css_style_value())
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:92 Web::CSS::GridSize::serialize.
pub func css_grid_size_serialize(this: const CssGridSize*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
css_style_value_serialize(this.m_value, builder, mode)
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:97 Web::CSS::GridSize::to_string.
pub func css_grid_size_to_string(this: const CssGridSize*, mode: css_syntax.SerializationMode) -> ak.String:
var builder = ak.string_builder_new()
css_grid_size_serialize(this, &builder, mode)
return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:104 Web::CSS::GridSize::absolutized.
pub func css_grid_size_absolutized(this: const CssGridSize*, context: CssComputationContext) -> CssGridSize:
let absolutized_value = css_style_value_absolutized(this.m_value, context)
if absolutized_value == this.m_value:
return *this
return css_grid_size_new(absolutized_value)
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:48 Web::CSS::GridSize::operator== (defaulted: the values
## compare by value).
pub func css_grid_size_eq(this: const CssGridSize*, other: CssGridSize) -> bool:
return css_style_values_equal(this.m_value, other.m_value)
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:50 Web::CSS::GridSize::is_computationally_independent.
pub func css_grid_size_is_computationally_independent(this: const CssGridSize*) -> bool:
return css_style_value_is_computationally_independent(this.m_value)
# mark: GridMinMax ==============================================================================
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:114 Web::CSS::GridMinMax::GridMinMax.
pub func css_grid_min_max_construct(this: CssGridMinMax*, min_grid_size: CssGridSize, max_grid_size: CssGridSize):
this.m_min_grid_size = min_grid_size
this.m_max_grid_size = max_grid_size
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:60 Web::CSS::GridMinMax::min_grid_size.
pub func css_grid_min_max_min_grid_size(this: const CssGridMinMax*) -> CssGridSize:
return this.m_min_grid_size
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:61 Web::CSS::GridMinMax::max_grid_size.
pub func css_grid_min_max_max_grid_size(this: const CssGridMinMax*) -> CssGridSize:
return this.m_max_grid_size
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:120 Web::CSS::GridMinMax::serialize.
pub func css_grid_min_max_serialize(this: const CssGridMinMax*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
ak.string_builder_append(builder, "minmax(")
css_grid_size_serialize(&this.m_min_grid_size, builder, mode)
ak.string_builder_append(builder, ", ")
css_grid_size_serialize(&this.m_max_grid_size, builder, mode)
ak.string_builder_append(builder, ")")
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:129 Web::CSS::GridMinMax::to_string.
pub func css_grid_min_max_to_string(this: const CssGridMinMax*, mode: css_syntax.SerializationMode) -> ak.String:
var builder = ak.string_builder_new()
css_grid_min_max_serialize(this, &builder, mode)
return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:136 Web::CSS::GridMinMax::absolutized.
pub func css_grid_min_max_absolutized(this: const CssGridMinMax*, context: CssComputationContext) -> CssGridMinMax:
var result: CssGridMinMax = ---
css_grid_min_max_construct(&result, css_grid_size_absolutized(&this.m_min_grid_size, context), css_grid_size_absolutized(&this.m_max_grid_size, context))
return result
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:66 Web::CSS::GridMinMax::operator== (defaulted).
pub func css_grid_min_max_eq(this: const CssGridMinMax*, other: CssGridMinMax) -> bool:
return css_grid_size_eq(&this.m_min_grid_size, other.m_min_grid_size) and css_grid_size_eq(&this.m_max_grid_size, other.m_max_grid_size)
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:68 Web::CSS::GridMinMax::is_computationally_independent.
pub func css_grid_min_max_is_computationally_independent(this: const CssGridMinMax*) -> bool:
return css_grid_size_is_computationally_independent(&this.m_min_grid_size) and css_grid_size_is_computationally_independent(&this.m_max_grid_size)
# mark: GridRepeat ==============================================================================
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:144 Web::CSS::GridRepeat::GridRepeat.
pub func css_grid_repeat_construct_css_grid_repeat_type(this: CssGridRepeat*, grid_repeat_type: CssGridRepeatType, grid_track_size_list: CssGridTrackSizeList, repeat_count: CssStyleValue*?):
this.m_type = grid_repeat_type
this.m_grid_track_size_list = grid_track_size_list
this.m_repeat_count = repeat_count
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:151 Web::CSS::GridRepeat::GridRepeat.
pub func css_grid_repeat_construct_css_grid_track_size_list(this: CssGridRepeat*, grid_track_size_list: CssGridTrackSizeList, params: CssGridRepeatParams):
css_grid_repeat_construct_css_grid_repeat_type(this, params.type_, grid_track_size_list, params.count)
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:158 Web::CSS::GridRepeat::is_auto_fill.
pub func css_grid_repeat_is_auto_fill(this: const CssGridRepeat*) -> bool:
return this.m_type == CssGridRepeatType.auto_fill
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:159 Web::CSS::GridRepeat::is_auto_fit.
pub func css_grid_repeat_is_auto_fit(this: const CssGridRepeat*) -> bool:
return this.m_type == CssGridRepeatType.auto_fit
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:160 Web::CSS::GridRepeat::is_fixed.
pub func css_grid_repeat_is_fixed(this: const CssGridRepeat*) -> bool:
return this.m_type == CssGridRepeatType.fixed
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:161 Web::CSS::GridRepeat::repeat_count.
pub func css_grid_repeat_repeat_count(this: const CssGridRepeat*) -> usize:
assert(css_grid_repeat_is_fixed(this))
let repeat_count = this.m_repeat_count else trap("VERIFY: a repeat count")
# int -> size_t, as C++ converts it.
return (usize)(i64)css_int_from_style_value(repeat_count)
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:166 Web::CSS::GridRepeat::grid_track_size_list.
pub func css_grid_repeat_grid_track_size_list(this: const CssGridRepeat*) -> CssGridTrackSizeList:
return this.m_grid_track_size_list
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:167 Web::CSS::GridRepeat::type.
pub func css_grid_repeat_type(this: const CssGridRepeat*) -> CssGridRepeatType:
return this.m_type
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:156 Web::CSS::GridRepeat::serialize.
pub func css_grid_repeat_serialize(this: const CssGridRepeat*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
ak.string_builder_append(builder, "repeat(")
match this.m_type:
.auto_fit:
ak.string_builder_append(builder, "auto-fit")
.auto_fill:
ak.string_builder_append(builder, "auto-fill")
.fixed:
css_style_value_serialize(this.m_repeat_count else trap("VERIFY: a repeat count"), builder, mode)
_: trap("VERIFY_NOT_REACHED")
ak.string_builder_append(builder, ", ")
css_grid_track_size_list_serialize(&this.m_grid_track_size_list, builder, mode)
ak.string_builder_append(builder, ")")
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:177 Web::CSS::GridRepeat::to_string.
pub func css_grid_repeat_to_string(this: const CssGridRepeat*, mode: css_syntax.SerializationMode) -> ak.String:
var builder = ak.string_builder_new()
css_grid_repeat_serialize(this, &builder, mode)
return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:184 Web::CSS::GridRepeat::absolutized.
pub func css_grid_repeat_absolutized(this: const CssGridRepeat*, context: CssComputationContext) -> CssGridRepeat:
var repeat_count: CssStyleValue*? = none
if let count = this.m_repeat_count:
repeat_count = css_style_value_absolutized(count, context)
var result: CssGridRepeat = ---
css_grid_repeat_construct_css_grid_repeat_type(&result, this.m_type, css_grid_track_size_list_absolutized(&this.m_grid_track_size_list, context), repeat_count)
return result
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:172 Web::CSS::GridRepeat::operator== (defaulted).
pub func css_grid_repeat_eq(this: const CssGridRepeat*, other: CssGridRepeat) -> bool:
return this.m_type == other.m_type and css_grid_track_size_list_eq(&this.m_grid_track_size_list, other.m_grid_track_size_list) and css_optional_style_values_equal(this.m_repeat_count, other.m_repeat_count)
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:174 Web::CSS::GridRepeat::is_computationally_independent.
pub func css_grid_repeat_is_computationally_independent(this: const CssGridRepeat*) -> bool:
if not css_grid_track_size_list_is_computationally_independent(&this.m_grid_track_size_list):
return false
if let repeat_count = this.m_repeat_count:
return css_style_value_is_computationally_independent(repeat_count)
return true
# mark: ExplicitGridTrack =======================================================================
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:193 Web::CSS::ExplicitGridTrack::ExplicitGridTrack.
pub func css_explicit_grid_track_construct(this: CssExplicitGridTrack*, value: CssGridRepeatOrCssGridMinMaxOrCssGridSize):
this.m_value = value
## `ExplicitGridTrack { value }` as a value.
pub func css_explicit_grid_track_new(value: CssGridRepeatOrCssGridMinMaxOrCssGridSize) -> CssExplicitGridTrack:
var track: CssExplicitGridTrack = ---
css_explicit_grid_track_construct(&track, value)
return track
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:186 Web::CSS::ExplicitGridTrack::is_repeat.
pub func css_explicit_grid_track_is_repeat(this: const CssExplicitGridTrack*) -> bool:
match this.m_value:
.css_grid_repeat(_): return true
_: return false
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:187 Web::CSS::ExplicitGridTrack::repeat.
pub func css_explicit_grid_track_repeat(this: const CssExplicitGridTrack*) -> CssGridRepeat:
match this.m_value:
.css_grid_repeat(repeat): return repeat
_: trap("VERIFY: a GridRepeat")
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:189 Web::CSS::ExplicitGridTrack::is_minmax.
pub func css_explicit_grid_track_is_minmax(this: const CssExplicitGridTrack*) -> bool:
match this.m_value:
.css_grid_min_max(_): return true
_: return false
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:190 Web::CSS::ExplicitGridTrack::minmax.
pub func css_explicit_grid_track_minmax(this: const CssExplicitGridTrack*) -> CssGridMinMax:
match this.m_value:
.css_grid_min_max(minmax): return minmax
_: trap("VERIFY: a GridMinMax")
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:192 Web::CSS::ExplicitGridTrack::is_default.
pub func css_explicit_grid_track_is_default(this: const CssExplicitGridTrack*) -> bool:
match this.m_value:
.css_grid_size(_): return true
_: return false
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:193 Web::CSS::ExplicitGridTrack::grid_size.
pub func css_explicit_grid_track_grid_size(this: const CssExplicitGridTrack*) -> CssGridSize:
match this.m_value:
.css_grid_size(grid_size): return grid_size
_: trap("VERIFY: a GridSize")
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:198 Web::CSS::ExplicitGridTrack::serialize.
pub func css_explicit_grid_track_serialize(this: const CssExplicitGridTrack*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
match this.m_value:
.css_grid_repeat(track): css_grid_repeat_serialize(&track, builder, mode)
.css_grid_min_max(track): css_grid_min_max_serialize(&track, builder, mode)
.css_grid_size(track): css_grid_size_serialize(&track, builder, mode)
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:205 Web::CSS::ExplicitGridTrack::to_string.
pub func css_explicit_grid_track_to_string(this: const CssExplicitGridTrack*, mode: css_syntax.SerializationMode) -> ak.String:
var builder = ak.string_builder_new()
css_explicit_grid_track_serialize(this, &builder, mode)
return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:212 Web::CSS::ExplicitGridTrack::absolutized.
pub func css_explicit_grid_track_absolutized(this: const CssExplicitGridTrack*, context: CssComputationContext) -> CssExplicitGridTrack:
match this.m_value:
.css_grid_repeat(it): return css_explicit_grid_track_new(.css_grid_repeat(css_grid_repeat_absolutized(&it, context)))
.css_grid_min_max(it): return css_explicit_grid_track_new(.css_grid_min_max(css_grid_min_max_absolutized(&it, context)))
.css_grid_size(it): return css_explicit_grid_track_new(.css_grid_size(css_grid_size_absolutized(&it, context)))
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:198 Web::CSS::ExplicitGridTrack::operator== (defaulted).
pub func css_explicit_grid_track_eq(this: const CssExplicitGridTrack*, other: CssExplicitGridTrack) -> bool:
match this.m_value:
.css_grid_repeat(track):
match other.m_value:
.css_grid_repeat(other_track): return css_grid_repeat_eq(&track, other_track)
_: return false
.css_grid_min_max(track):
match other.m_value:
.css_grid_min_max(other_track): return css_grid_min_max_eq(&track, other_track)
_: return false
.css_grid_size(track):
match other.m_value:
.css_grid_size(other_track): return css_grid_size_eq(&track, other_track)
_: return false
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:200 Web::CSS::ExplicitGridTrack::is_computationally_independent.
pub func css_explicit_grid_track_is_computationally_independent(this: const CssExplicitGridTrack*) -> bool:
match this.m_value:
.css_grid_repeat(value): return css_grid_repeat_is_computationally_independent(&value)
.css_grid_min_max(value): return css_grid_min_max_is_computationally_independent(&value)
.css_grid_size(value): return css_grid_size_is_computationally_independent(&value)
# mark: GridTemplateAreas and GridLineNames =====================================================
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:99 Web::CSS::GridTemplateAreas::is_empty.
pub func css_grid_template_areas_is_empty(this: const CssGridTemplateAreas*) -> bool:
return this.row_count == 0
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:105 Web::CSS::GridLineNames::append.
pub func css_grid_line_names_append(this: CssGridLineNames*, name: ak.FlyString):
ak.vector_append_t(&this.m_names, CssGridLineName(name = name, implicit = false))
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:106 Web::CSS::GridLineNames::is_empty.
pub func css_grid_line_names_is_empty(this: const CssGridLineNames*) -> bool:
return ak.vector_is_empty(&this.m_names)
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:107 Web::CSS::GridLineNames::names.
pub func css_grid_line_names_names(this: const CssGridLineNames*) -> ak.Vector[CssGridLineName]:
return this.m_names
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:219 Web::CSS::GridLineNames::serialize.
pub func css_grid_line_names_serialize(this: const CssGridLineNames*, builder: ak.StringBuilder*):
ak.string_builder_append(builder, "[")
for i in 0..<ak.vector_size(&this.m_names):
if i > 0:
ak.string_builder_append(builder, " ")
let name = ak.vector_at_const(&this.m_names, i).name
ak.string_builder_append_string_view(builder, ak.fly_string_bytes_as_string_view(&name))
ak.string_builder_append(builder, "]")
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:230 Web::CSS::GridLineNames::to_string.
pub func css_grid_line_names_to_string(this: const CssGridLineNames*) -> ak.String:
var builder = ak.string_builder_new()
css_grid_line_names_serialize(this, &builder)
return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:112 Web::CSS::GridLineNames::operator== (defaulted: the names
## and their implicit flags, in order).
pub func css_grid_line_names_eq(this: const CssGridLineNames*, other: CssGridLineNames) -> bool:
let size = ak.vector_size(&this.m_names)
if size != ak.vector_size(&other.m_names):
return false
for i in 0..<size:
let name = ak.vector_at_const(&this.m_names, i)
let other_name = ak.vector_at_const(&other.m_names, i)
if not ak.fly_string_eq_fly_string(&name.name, &other_name.name) or name.implicit != other_name.implicit:
return false
return true
# mark: GridTrackSizeList =======================================================================
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:237 Web::CSS::GridTrackSizeList::make_none.
pub func css_grid_track_size_list_make_none() -> CssGridTrackSizeList:
return CssGridTrackSizeList(m_list = ak.Vector[CssExplicitGridTrackOrCssGridLineNames]())
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:269 Web::CSS::GridTrackSizeList::track_list.
pub func css_grid_track_size_list_track_list(this: const CssGridTrackSizeList*) -> ak.Vector[CssExplicitGridTrack]:
var track_list = ak.Vector[CssExplicitGridTrack]()
for line_definition_or_name in ak.vector_span_const(&this.m_list):
match line_definition_or_name:
.css_explicit_grid_track(track): ak.vector_append_t(&track_list, track)
_: _ = track_list
return track_list
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:123 Web::CSS::GridTrackSizeList::list.
pub func css_grid_track_size_list_list(this: const CssGridTrackSizeList*) -> ak.Vector[CssExplicitGridTrackOrCssGridLineNames]:
return this.m_list
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:242 Web::CSS::GridTrackSizeList::serialize.
pub func css_grid_track_size_list_serialize(this: const CssGridTrackSizeList*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
if ak.vector_is_empty(&this.m_list):
ak.string_builder_append(builder, "none")
return
var first = true
for line_definition_or_name in ak.vector_span_const(&this.m_list):
if not first:
ak.string_builder_append(builder, " ")
first = false
match line_definition_or_name:
.css_explicit_grid_track(track): css_explicit_grid_track_serialize(&track, builder, mode)
.css_grid_line_names(names): css_grid_line_names_serialize(&names, builder)
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:262 Web::CSS::GridTrackSizeList::to_string.
pub func css_grid_track_size_list_to_string(this: const CssGridTrackSizeList*, mode: css_syntax.SerializationMode) -> ak.String:
var builder = ak.string_builder_new()
css_grid_track_size_list_serialize(this, &builder, mode)
return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:279 Web::CSS::GridTrackSizeList::operator== (defaulted).
pub func css_grid_track_size_list_eq(this: const CssGridTrackSizeList*, other: CssGridTrackSizeList) -> bool:
let size = ak.vector_size(&this.m_list)
if size != ak.vector_size(&other.m_list):
return false
for i in 0..<size:
match *ak.vector_at_const(&this.m_list, i):
.css_explicit_grid_track(track):
match *ak.vector_at_const(&other.m_list, i):
.css_explicit_grid_track(other_track):
if not css_explicit_grid_track_eq(&track, other_track):
return false
_: return false
.css_grid_line_names(names):
match *ak.vector_at_const(&other.m_list, i):
.css_grid_line_names(other_names):
if not css_grid_line_names_eq(&names, other_names):
return false
_: return false
return true
## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:129 Web::CSS::GridTrackSizeList::is_empty.
pub func css_grid_track_size_list_is_empty(this: const CssGridTrackSizeList*) -> bool:
return ak.vector_is_empty(&this.m_list)
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:281 Web::CSS::GridTrackSizeList::append.
pub func css_grid_track_size_list_append_css_grid_line_names(this: CssGridTrackSizeList*, line_names: CssGridLineNames):
if not ak.vector_is_empty(&this.m_list):
let last = ak.vector_last(&this.m_list)
match *last:
.css_grid_line_names(last_line_names):
# `auto& last_line_names = m_list.last().get<GridLineNames>()`: appended to in place, so the
# updated names are stored back.
var updated_line_names = last_line_names
for name in ak.vector_span_const(&line_names.m_names):
css_grid_line_names_append(&updated_line_names, name.name)
*last = .css_grid_line_names(updated_line_names)
return
_: _ = last
ak.vector_append_t(&this.m_list, CssExplicitGridTrackOrCssGridLineNames.css_grid_line_names(line_names))
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:292 Web::CSS::GridTrackSizeList::append.
pub func css_grid_track_size_list_append_css_explicit_grid_track(this: CssGridTrackSizeList*, explicit_track: CssExplicitGridTrack):
ak.vector_append_t(&this.m_list, CssExplicitGridTrackOrCssGridLineNames.css_explicit_grid_track(explicit_track))
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:297 Web::CSS::GridTrackSizeList::absolutized.
pub func css_grid_track_size_list_absolutized(this: const CssGridTrackSizeList*, context: CssComputationContext) -> CssGridTrackSizeList:
var result = css_grid_track_size_list_make_none()
for item in ak.vector_span_const(&this.m_list):
match item:
.css_explicit_grid_track(track):
css_grid_track_size_list_append_css_explicit_grid_track(&result, css_explicit_grid_track_absolutized(&track, context))
.css_grid_line_names(names):
# The lambda takes `GridLineNames names` by value: a copy that the result may append to.
css_grid_track_size_list_append_css_grid_line_names(&result, CssGridLineNames(m_names = ak.vector_clone(&names.m_names)))
return result
## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:312 Web::CSS::GridTrackSizeList::is_computationally_independent.
pub func css_grid_track_size_list_is_computationally_independent(this: const CssGridTrackSizeList*) -> bool:
for item in ak.vector_span_const(&this.m_list):
match item:
.css_explicit_grid_track(track):
if not css_explicit_grid_track_is_computationally_independent(&track):
return false
.css_grid_line_names(_):
_ = item
return true