dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / layout / grid_formatting_context_1.lucb
#==============================================================================================
#
# grid_formatting_context_1 - Layout::GridFormattingContext: grid items, alignment keywords,
# grid tracks, construction and repeat() counts
#
# DESCRIPTION:
# Port of LibWeb/Layout/GridFormattingContext.cpp (lines 1-269) and the inline members of
# GridFormattingContext.h: a grid item's spans, positions, sizes and margins in either
# dimension, the occupation grid's inline members, the context's inline members (the
# grid container, gaps, flexible tracks, and the traversal of the tracks and gaps an item
# spans as an iterator), the four to_alignment conversions, the GridTrack factories, the
# constructor, the size of a definite track and the number of auto-fill / auto-fit
# repetitions (https://www.w3.org/TR/css-grid-2/#auto-repeat).
#
# Copyright (c) 2023-2025, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
# Copyright (c) 2022-2023, Martin Falisse <mfalisse@outlook.com>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: GridItem (GridFormattingContext.h) ======================================================
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:36 Web::Layout::GridItem::span.
pub func layout_grid_item_span(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> usize:
if dimension == LayoutGridDimension.column:
return this.column_span else trap("VERIFY: the grid item's column span has a value")
return this.row_span else trap("VERIFY: the grid item's row span has a value")
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:41 Web::Layout::GridItem::raw_position.
pub func layout_grid_item_raw_position(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> i32:
if dimension == LayoutGridDimension.column:
return this.column else trap("VERIFY: the grid item's column has a value")
return this.row else trap("VERIFY: the grid item's row has a value")
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:46 Web::Layout::GridItem::add_margin_box_sizes.
pub func layout_grid_item_add_margin_box_sizes(this: const LayoutGridItem*, content_size: gfx.CssPixels, dimension: LayoutGridDimension) -> gfx.CssPixels:
if dimension == LayoutGridDimension.column:
return layout_state_used_values_margin_box_left(this.used_values).add(content_size).add(layout_state_used_values_margin_box_right(this.used_values))
return layout_state_used_values_margin_box_top(this.used_values).add(content_size).add(layout_state_used_values_margin_box_bottom(this.used_values))
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:53 Web::Layout::GridItem::gap_adjusted_position.
pub func layout_grid_item_gap_adjusted_position(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> i32:
if dimension == LayoutGridDimension.column:
return layout_grid_item_gap_adjusted_column(this)
return layout_grid_item_gap_adjusted_row(this)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:61 Web::Layout::GridItem::computed_values.
pub func layout_grid_item_computed_values(this: const LayoutGridItem*) -> const CssComputedValues*:
return layout_box_computed(this.box)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:66 Web::Layout::GridItem::minimum_size.
pub func layout_grid_item_minimum_size(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> CssSize:
if dimension == LayoutGridDimension.column:
return css_computed_values_min_width(layout_grid_item_computed_values(this))
return css_computed_values_min_height(layout_grid_item_computed_values(this))
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:71 Web::Layout::GridItem::maximum_size.
pub func layout_grid_item_maximum_size(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> CssSize:
if dimension == LayoutGridDimension.column:
return css_computed_values_max_width(layout_grid_item_computed_values(this))
return css_computed_values_max_height(layout_grid_item_computed_values(this))
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:76 Web::Layout::GridItem::preferred_size.
pub func layout_grid_item_preferred_size(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> CssSize:
if dimension == LayoutGridDimension.column:
return css_computed_values_width(layout_grid_item_computed_values(this))
return css_computed_values_height(layout_grid_item_computed_values(this))
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:81 Web::Layout::GridItem::margin_start.
pub func layout_grid_item_margin_start(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> CssLengthPercentageOrAuto:
let margin = css_computed_values_margin(layout_grid_item_computed_values(this))
if dimension == LayoutGridDimension.column:
return css_length_box_left_const(&margin)
return css_length_box_top_const(&margin)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:86 Web::Layout::GridItem::margin_end.
pub func layout_grid_item_margin_end(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> CssLengthPercentageOrAuto:
let margin = css_computed_values_margin(layout_grid_item_computed_values(this))
if dimension == LayoutGridDimension.column:
return css_length_box_right_const(&margin)
return css_length_box_bottom_const(&margin)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:91 Web::Layout::GridItem::used_margin_box_start.
pub func layout_grid_item_used_margin_box_start(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
if dimension == LayoutGridDimension.column:
return layout_state_used_values_margin_box_left(this.used_values)
return layout_state_used_values_margin_box_top(this.used_values)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:96 Web::Layout::GridItem::used_margin_box_end.
pub func layout_grid_item_used_margin_box_end(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
if dimension == LayoutGridDimension.column:
return layout_state_used_values_margin_box_right(this.used_values)
return layout_state_used_values_margin_box_bottom(this.used_values)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:101 Web::Layout::GridItem::used_margin_start.
pub func layout_grid_item_used_margin_start(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
if dimension == LayoutGridDimension.column:
return this.used_values.margin_left
return this.used_values.margin_top
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:106 Web::Layout::GridItem::used_margin_end.
pub func layout_grid_item_used_margin_end(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
if dimension == LayoutGridDimension.column:
return this.used_values.margin_right
return this.used_values.margin_bottom
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:111 Web::Layout::GridItem::available_space.
pub func layout_grid_item_available_space(this: const LayoutGridItem*) -> LayoutAvailableSpace:
let available_width = layout_available_size_make_definite(layout_state_used_values_content_width(this.used_values)) if layout_state_used_values_has_definite_width(this.used_values) else layout_available_size_make_indefinite()
let available_height = layout_available_size_make_definite(layout_state_used_values_content_height(this.used_values)) if layout_state_used_values_has_definite_height(this.used_values) else layout_available_size_make_indefinite()
return LayoutAvailableSpace(width = available_width, height = available_height)
# mark: OccupationGrid (GridFormattingContext.h) ================================================
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:126 Web::Layout::OccupationGrid::OccupationGrid.
pub func layout_occupation_grid_construct_usize(this: LayoutOccupationGrid*, columns_count: usize, rows_count: usize):
layout_occupation_grid_construct(this)
# `max(0, columns_count - 1)` is AK::max<int>: the size_t difference is converted to int.
this.m_max_column_index = ak.max[i32](0, (i32)(columns_count -% 1))
this.m_max_row_index = ak.max[i32](0, (i32)(rows_count -% 1))
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:131 Web::Layout::OccupationGrid::OccupationGrid.
pub func layout_occupation_grid_construct(this: LayoutOccupationGrid*):
this.m_occupation_grid = ak.HashTable[LayoutGridPosition, LayoutGridPositionTraits]()
this.m_min_column_index = 0
this.m_max_column_index = 0
this.m_min_row_index = 0
this.m_max_row_index = 0
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:135 Web::Layout::OccupationGrid::column_count.
pub func layout_occupation_grid_column_count(this: const LayoutOccupationGrid*) -> usize:
return (usize)(i64)(ak.abs_i32(this.m_min_column_index) + this.m_max_column_index + 1)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:140 Web::Layout::OccupationGrid::row_count.
pub func layout_occupation_grid_row_count(this: const LayoutOccupationGrid*) -> usize:
return (usize)(i64)(ak.abs_i32(this.m_min_row_index) + this.m_max_row_index + 1)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:145 Web::Layout::OccupationGrid::set_max_column_index.
pub func layout_occupation_grid_set_max_column_index(this: LayoutOccupationGrid*, max_column_index: usize):
this.m_max_column_index = (i32)max_column_index
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:147 Web::Layout::OccupationGrid::min_column_index.
pub func layout_occupation_grid_min_column_index(this: const LayoutOccupationGrid*) -> i32:
return this.m_min_column_index
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:148 Web::Layout::OccupationGrid::max_column_index.
pub func layout_occupation_grid_max_column_index(this: const LayoutOccupationGrid*) -> i32:
return this.m_max_column_index
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:149 Web::Layout::OccupationGrid::min_row_index.
pub func layout_occupation_grid_min_row_index(this: const LayoutOccupationGrid*) -> i32:
return this.m_min_row_index
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:150 Web::Layout::OccupationGrid::max_row_index.
pub func layout_occupation_grid_max_row_index(this: const LayoutOccupationGrid*) -> i32:
return this.m_max_row_index
# mark: GridFormattingContext's inline members (GridFormattingContext.h) ========================
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:171 Web::Layout::GridFormattingContext::inhibits_floating (override).
pub func layout_grid_formatting_context_inhibits_floating_impl(base: LayoutFormattingContext*) -> bool:
_ = base
return true
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:178 Web::Layout::GridFormattingContext::grid_container.
pub func layout_grid_formatting_context_grid_container(this: LayoutGridFormattingContext*) -> LayoutBox*:
return layout_formatting_context_context_box(this.layout_formatting_context())
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:220 Web::Layout::GridFormattingContext::has_gaps.
func layout_grid_formatting_context_has_gaps(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension) -> bool:
let computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
let gap = css_computed_values_column_gap(computed_values) if dimension == LayoutGridDimension.column else css_computed_values_row_gap(computed_values)
match gap:
.css_normal_gap(_): return false
_: return true
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:230 Web::Layout::GridFormattingContext::for_each_spanned_track_by_item:
## `for track in layout_grid_formatting_context_for_each_spanned_track_by_item(this, item, dimension)` visits each
## track the item spans, each followed by the gap after it unless it is the last spanned track (DESIGN.md §2.9).
func layout_grid_formatting_context_for_each_spanned_track_by_item(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> LayoutGridFormattingContextSpannedTracks:
let tracks = &this.m_grid_columns if dimension == LayoutGridDimension.column else &this.m_grid_rows
let gaps = &this.m_column_gap_tracks if dimension == LayoutGridDimension.column else &this.m_row_gap_tracks
let has_gaps = layout_grid_formatting_context_has_gaps(this, dimension)
let item_span = layout_grid_item_span(item, dimension)
let item_index = layout_grid_item_raw_position(item, dimension)
return LayoutGridFormattingContextSpannedTracks(tracks = tracks, gaps = gaps, has_gaps = has_gaps, item_span = item_span, item_index = item_index)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:254 Web::Layout::GridFormattingContext::for_each_spanned_track_by_item
## (the const overload, the same traversal).
func layout_grid_formatting_context_for_each_spanned_track_by_item_const(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> LayoutGridFormattingContextSpannedTracks:
return layout_grid_formatting_context_for_each_spanned_track_by_item(this, item, dimension)
## The tracks and gaps a grid item spans, as an iterable (for_each_spanned_track_by_item's loop).
pub struct LayoutGridFormattingContextSpannedTracks: luce.Iterable[LayoutGridFormattingContextGridTrack*, LayoutGridFormattingContextSpannedTrackIterator]:
pub var tracks: ak.Vector[LayoutGridFormattingContextGridTrack]*
pub var gaps: ak.Vector[LayoutGridFormattingContextGridTrack]*
pub var has_gaps: bool
pub var item_span: usize
pub var item_index: i32
func iterator() -> LayoutGridFormattingContextSpannedTrackIterator:
return LayoutGridFormattingContextSpannedTrackIterator(spanned = self, span = 0, pending_gap_index = none)
## The iterator of LayoutGridFormattingContextSpannedTracks: `callback(track)` for each spanned track, then
## `callback(gap)` for the gap that follows it.
pub struct LayoutGridFormattingContextSpannedTrackIterator: luce.Iterator[LayoutGridFormattingContextGridTrack*]:
pub var spanned: LayoutGridFormattingContextSpannedTracks
pub var span: usize
pub var pending_gap_index: usize?
func next() -> LayoutGridFormattingContextGridTrack*?:
if let gap_index = self.pending_gap_index:
self.pending_gap_index = none
return ak.vector_at(self.spanned.gaps, gap_index)
if self.span >= self.spanned.item_span:
return none
# `item_index + span` is size_t arithmetic: a negative index wraps past the tracks and ends the walk.
let track_index = (usize)(i64)self.spanned.item_index +% self.span
if track_index >= ak.vector_size(self.spanned.tracks):
return none
let track = ak.vector_at(self.spanned.tracks, track_index)
let is_last_spanned_track = self.span == self.spanned.item_span - 1
if self.spanned.has_gaps and not is_last_spanned_track:
self.pending_gap_index = track_index
self.span += 1
return track
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:289 Web::Layout::GridFormattingContext::has_flexible_tracks.
func layout_grid_formatting_context_has_flexible_tracks(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension) -> bool:
return this.m_has_flexible_column_tracks if dimension == LayoutGridDimension.column else this.m_has_flexible_row_tracks
## `m_available_space.value()` (and `m_available_space->`): VERIFYs that run() has set it.
func layout_grid_formatting_context_available_space(this: LayoutGridFormattingContext*) -> LayoutAvailableSpace:
return this.m_available_space else trap("VERIFY: m_available_space has a value")
## `dimension == GridDimension::Column ? m_available_space->width : m_available_space->height`.
func layout_grid_formatting_context_available_size(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension) -> LayoutAvailableSize:
let available_space = layout_grid_formatting_context_available_space(this)
return available_space.width if dimension == LayoutGridDimension.column else available_space.height
## `dimension == GridDimension::Column ? m_grid_columns : m_grid_rows`.
func layout_grid_formatting_context_tracks(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension) -> ak.Vector[LayoutGridFormattingContextGridTrack]*:
return &this.m_grid_columns if dimension == LayoutGridDimension.column else &this.m_grid_rows
## `dimension == GridDimension::Column ? m_grid_columns_and_gaps : m_grid_rows_and_gaps`.
func layout_grid_formatting_context_tracks_and_gaps(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension) -> ak.Vector[LayoutGridFormattingContextGridTrack*]*:
return &this.m_grid_columns_and_gaps if dimension == LayoutGridDimension.column else &this.m_grid_rows_and_gaps
## `value / count` read as CSSPixels for a size_t count: `CSSPixels / size_t` is a CSSPixelFraction over
## CSSPixels(Unsigned), which saturates, converted by its operator CSSPixels.
func layout_grid_formatting_context_div_count(value: gfx.CssPixels, count: usize) -> gfx.CssPixels:
let fraction = value.div(gfx.css_pixels_from_unsigned((u64)count))
return gfx.css_pixel_fraction_to_css_pixels(&fraction)
# mark: to_alignment ============================================================================
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:17 Web::Layout::to_alignment.
func layout_to_alignment_justify_content(value: css_data.JustifyContent) -> LayoutAlignment:
match value:
.left: return LayoutAlignment.start
.right: return LayoutAlignment.end
.flex_start, .start: return LayoutAlignment.start
.flex_end, .end: return LayoutAlignment.end
.center: return LayoutAlignment.center
.space_between: return LayoutAlignment.space_between
.space_around: return LayoutAlignment.space_around
.space_evenly: return LayoutAlignment.space_evenly
.stretch: return LayoutAlignment.stretch
.normal: return LayoutAlignment.normal
_: trap("VERIFY_NOT_REACHED")
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:47 Web::Layout::to_alignment.
func layout_to_alignment_justify_items(value: css_data.JustifyItems) -> LayoutAlignment:
match value:
.baseline: return LayoutAlignment.baseline
.center: return LayoutAlignment.center
.end: return LayoutAlignment.end
.flex_end: return LayoutAlignment.end
.flex_start: return LayoutAlignment.start
.legacy: return LayoutAlignment.normal
.normal: return LayoutAlignment.normal
.safe: return LayoutAlignment.safe
.self_end: return LayoutAlignment.self_end
.self_start: return LayoutAlignment.self_start
.start: return LayoutAlignment.start
.stretch: return LayoutAlignment.stretch
.unsafe: return LayoutAlignment.unsafe
.left: return LayoutAlignment.start
.right: return LayoutAlignment.end
_: trap("VERIFY_NOT_REACHED")
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:85 Web::Layout::to_alignment.
func layout_to_alignment_align_content(value: css_data.AlignContent) -> LayoutAlignment:
match value:
.start: return LayoutAlignment.start
.end: return LayoutAlignment.end
.center: return LayoutAlignment.center
.space_between: return LayoutAlignment.space_between
.space_around: return LayoutAlignment.space_around
.space_evenly: return LayoutAlignment.space_evenly
.stretch: return LayoutAlignment.stretch
.normal: return LayoutAlignment.normal
.flex_start: return LayoutAlignment.start
.flex_end: return LayoutAlignment.end
_: trap("VERIFY_NOT_REACHED")
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:113 Web::Layout::to_alignment.
func layout_to_alignment_align_items(value: css_data.AlignItems) -> LayoutAlignment:
match value:
.baseline: return LayoutAlignment.baseline
.center: return LayoutAlignment.center
.end: return LayoutAlignment.end
.flex_end: return LayoutAlignment.end
.flex_start: return LayoutAlignment.start
.normal: return LayoutAlignment.normal
.safe: return LayoutAlignment.safe
.self_end: return LayoutAlignment.self_end
.self_start: return LayoutAlignment.self_start
.start: return LayoutAlignment.start
.stretch: return LayoutAlignment.stretch
.unsafe: return LayoutAlignment.unsafe
_: trap("VERIFY_NOT_REACHED")
# mark: GridTrack ===============================================================================
## A GridTrack with its C++ default member initializers and the given sizing functions.
func layout_grid_formatting_context_grid_track_new(min_track_sizing_function: CssGridSize, max_track_sizing_function: CssGridSize) -> LayoutGridFormattingContextGridTrack:
return LayoutGridFormattingContextGridTrack(min_track_sizing_function = min_track_sizing_function, max_track_sizing_function = max_track_sizing_function, growth_limit = layout_zero_px())
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:145 Web::Layout::GridFormattingContext::GridTrack::create_from_definition.
func layout_grid_formatting_context_grid_track_create_from_definition(definition: const CssExplicitGridTrack*, is_auto_fit: bool = false) -> LayoutGridFormattingContextGridTrack:
# NOTE: repeat() is expected to be expanded beforehand.
assert(not css_explicit_grid_track_is_repeat(definition))
if css_explicit_grid_track_is_minmax(definition):
let minmax = css_explicit_grid_track_minmax(definition)
var track = layout_grid_formatting_context_grid_track_new(css_grid_min_max_min_grid_size(&minmax), css_grid_min_max_max_grid_size(&minmax))
track.is_auto_fit = is_auto_fit
return track
# https://drafts.csswg.org/css-grid-2/#algo-terms
# min track sizing function:
# If the track was sized with a minmax() function, this is the first argument to that function.
# If the track was sized with a <flex> value or fit-content() function, auto. Otherwise, the track’s sizing function.
var min_track_sizing_function = css_explicit_grid_track_grid_size(definition)
if css_grid_size_is_flexible_length(&min_track_sizing_function) or css_grid_size_is_fit_content(&min_track_sizing_function):
min_track_sizing_function = css_grid_size_make_auto()
let max_track_sizing_function = css_explicit_grid_track_grid_size(definition)
var track = layout_grid_formatting_context_grid_track_new(min_track_sizing_function, max_track_sizing_function)
track.is_auto_fit = is_auto_fit
return track
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:175 Web::Layout::GridFormattingContext::GridTrack::create_auto.
func layout_grid_formatting_context_grid_track_create_auto() -> LayoutGridFormattingContextGridTrack:
return layout_grid_formatting_context_grid_track_new(css_grid_size_make_auto(), css_grid_size_make_auto())
## `CSS::GridSize(CSS::LengthStyleValue::create(CSS::Length::make_px(size)))`.
func layout_grid_formatting_context_px_grid_size(size: gfx.CssPixels) -> CssGridSize:
return css_grid_size_new(css_length_style_value_create(css_length_make_px_css_pixels(size)).css_style_value())
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:183 Web::Layout::GridFormattingContext::GridTrack::create_gap.
func layout_grid_formatting_context_grid_track_create_gap(size: gfx.CssPixels) -> LayoutGridFormattingContextGridTrack:
var track = layout_grid_formatting_context_grid_track_new(layout_grid_formatting_context_px_grid_size(size), layout_grid_formatting_context_px_grid_size(size))
track.base_size = size
track.is_gap = true
return track
# mark: Construction ============================================================================
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:193 Web::Layout::GridFormattingContext::GridFormattingContext.
pub func layout_grid_formatting_context_construct(this: LayoutGridFormattingContext*, state: LayoutState*, layout_mode: LayoutMode, grid_container: LayoutBox*, parent: LayoutFormattingContext*?):
layout_formatting_context_construct(this.layout_formatting_context(), LayoutFormattingContextType.grid, layout_mode, state, grid_container, parent)
layout_formatting_context_set_class(this.layout_formatting_context(), &layout_grid_formatting_context_class)
this.m_grid_container_used_values = layout_state_get_mutable(state, grid_container.layout_node_with_style())
# The other members start as their default member initializers: zero, empty, none.
layout_occupation_grid_construct(&this.m_occupation_grid)
this.m_available_space = none
# GridFormattingContext::~GridFormattingContext() is the default destructor (GridFormattingContext.cpp:199):
# layout_formatting_context_destruct has nothing to run for this context.
# mark: Definite track sizes and repeat() counts ================================================
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:201 Web::Layout::GridFormattingContext::resolve_definite_track_size.
func layout_grid_formatting_context_resolve_definite_track_size(this: LayoutGridFormattingContext*, grid_size: const CssGridSize*, available_space: LayoutAvailableSpace) -> gfx.CssPixels:
assert(css_grid_size_is_definite(grid_size))
let css_size = css_grid_size_css_size(grid_size)
return css_size_to_px(&css_size, layout_grid_formatting_context_grid_container(this).layout_node(), layout_available_size_to_px_or_zero(&available_space.width))
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:207 Web::Layout::GridFormattingContext::count_of_repeated_auto_fill_or_fit_tracks.
func layout_grid_formatting_context_count_of_repeated_auto_fill_or_fit_tracks(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension, repeated_track: const CssExplicitGridTrack*) -> i32:
# https://www.w3.org/TR/css-grid-2/#auto-repeat
# 7.2.3.2. Repeat-to-fill: auto-fill and auto-fit repetitions
# On a subgridded axis, the auto-fill keyword is only valid once per <line-name-list>, and repeats
# enough times for the name list to match the subgrid’s specified grid span (falling back to 0 if
# the span is already fulfilled).
# Otherwise on a standalone axis, when auto-fill is given as the repetition number
# If the grid container has a definite size or max size in the relevant axis, then the number of
# repetitions is the largest possible positive integer that does not cause the grid to overflow the
# content box of its grid container
let grid_computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
let available_space = layout_grid_formatting_context_available_space(this)
var size_of_repeated_tracks = layout_zero_px()
# (treating each track as its max track sizing function if that is definite or its minimum track sizing
# function otherwise, flooring the max track sizing function by the min track sizing function if both
# are definite, and taking gap into account)
let repeat = css_explicit_grid_track_repeat(repeated_track)
let repeat_grid_track_size_list = css_grid_repeat_grid_track_size_list(&repeat)
let repeat_track_list = css_grid_track_size_list_track_list(&repeat_grid_track_size_list)
let repeat_tracks = ak.vector_span_const(&repeat_track_list)
for explicit_grid_track in &repeat_tracks:
let track_sizing_function = explicit_grid_track
var track_size = layout_zero_px()
if css_explicit_grid_track_is_minmax(track_sizing_function):
let minmax = css_explicit_grid_track_minmax(track_sizing_function)
let min_size = css_grid_min_max_min_grid_size(&minmax)
let max_size = css_grid_min_max_max_grid_size(&minmax)
if css_grid_size_is_definite(&max_size):
track_size = layout_grid_formatting_context_resolve_definite_track_size(this, &max_size, available_space)
if css_grid_size_is_definite(&min_size):
track_size = ak.min(track_size, layout_grid_formatting_context_resolve_definite_track_size(this, &min_size, available_space))
elif css_grid_size_is_definite(&min_size):
track_size = layout_grid_formatting_context_resolve_definite_track_size(this, &min_size, available_space)
else:
trap("VERIFY_NOT_REACHED")
else:
let grid_size = css_explicit_grid_track_grid_size(track_sizing_function)
track_size = layout_grid_formatting_context_resolve_definite_track_size(this, &grid_size, available_space)
size_of_repeated_tracks = size_of_repeated_tracks.add(track_size)
if gfx.eq_css_pixels_int(size_of_repeated_tracks, 0):
return 0
let available_size = layout_grid_formatting_context_available_size(this, dimension)
let gap = css_computed_values_column_gap(grid_computed_values) if dimension == LayoutGridDimension.column else css_computed_values_row_gap(grid_computed_values)
let gap_px = layout_formatting_context_gap_to_px(this.layout_formatting_context(), gap, layout_available_size_to_px_or_zero(&available_size))
# `repeat_track_list.size() * gap_px`: CSSPixels(size_t) * CSSPixels.
let size_of_repeated_tracks_with_gap = size_of_repeated_tracks.add(gfx.css_pixels_from_unsigned((u64)ak.vector_size(&repeat_track_list)).mul(gap_px))
# Otherwise, if the grid container has a definite min size in the relevant axis, the number of repetitions is the
# smallest possible positive integer that fulfills that minimum requirement
if layout_available_size_is_definite(&available_size):
# NOTE: Gap size is added to free space to compensate for the fact that the last track does not have a gap
let free_space = layout_available_size_to_px_or_zero(&available_size)
let repetitions = free_space.add(gap_px).div(size_of_repeated_tracks_with_gap)
let number_of_repetitions = gfx.css_pixel_fraction_to_int(&repetitions)
# If any number of repetitions would overflow, then 1 repetition.
return ak.max[i32](1, number_of_repetitions)
# Otherwise, the specified track list repeats only once.
return 1
# For the purpose of finding the number of auto-repeated tracks in a standalone axis, the UA must
# floor the track size to a UA-specified value to avoid division by zero. It is suggested that this
# floor be 1px.