dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / layout / grid_formatting_context_2.lucb
#==============================================================================================
#
# grid_formatting_context_2 - Layout::GridFormattingContext: grid item placement and the
# grid's tracks and gutters
#
# DESCRIPTION:
# Port of LibWeb/Layout/GridFormattingContext.cpp (lines 271-659): resolving an item's
# grid-placement properties into lines and spans (named lines and areas included),
# placing items with a definite row and/or column or none
# (https://drafts.csswg.org/css-grid/#auto-placement-algo, step by step), finding an
# unoccupied area of the occupation grid, recording a placement, creating the explicit and
# implicit tracks from grid-template-* and grid-auto-*, and the gutters
# (https://www.w3.org/TR/css-grid-2/#gutters) as fixed-size tracks between them.
#
# C++ mixes int and size_t here; the size_t arithmetic wraps and its result is converted
# back to int, which `+%`/`-%` on usize and an `(i32)` cast reproduce.
#
# 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: Grid placement ==========================================================================
## `int + size_t` (or `int - size_t`) converted back to int: the size_t arithmetic wraps.
func layout_grid_formatting_context_int_plus_size(value: i32, size: usize) -> i32:
return (i32)((usize)(i64)value +% size)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:271 Web::Layout::GridFormattingContext::resolve_grid_position.
func layout_grid_formatting_context_resolve_grid_position(this: LayoutGridFormattingContext*, child_box: LayoutBox*, dimension: LayoutGridDimension) -> LayoutGridFormattingContextPlacementPosition:
let computed_values = layout_box_computed(child_box)
let placement_start = css_computed_values_grid_row_start(computed_values) if dimension == LayoutGridDimension.row else css_computed_values_grid_column_start(computed_values)
let placement_end = css_computed_values_grid_row_end(computed_values) if dimension == LayoutGridDimension.row else css_computed_values_grid_column_end(computed_values)
var placement_start_line_number: i32? = none
if css_grid_track_placement_has_line_number(&placement_start):
placement_start_line_number = css_int_from_style_value(css_grid_track_placement_line_number(&placement_start))
var placement_end_line_number: i32? = none
if css_grid_track_placement_has_line_number(&placement_end):
placement_end_line_number = css_int_from_style_value(css_grid_track_placement_line_number(&placement_end))
var result = LayoutGridFormattingContextPlacementPosition(start = 0, end = 0, span = 1)
if let start_line_number = placement_start_line_number:
if start_line_number > 0:
result.start = start_line_number - 1
else:
let explicit_line_count = this.m_explicit_rows_line_count if dimension == LayoutGridDimension.row else this.m_explicit_columns_line_count
# `explicit_line_count + placement_start_line_number.value()`: size_t arithmetic.
result.start = (i32)(explicit_line_count +% (usize)(i64)start_line_number)
if let end_line_number = placement_end_line_number:
result.end = end_line_number - 1
if result.end < 0:
# `row_count() + result.end + 2`: size_t arithmetic.
if dimension == LayoutGridDimension.row:
result.end = (i32)(layout_occupation_grid_row_count(&this.m_occupation_grid) +% (usize)(i64)result.end +% 2)
else:
result.end = (i32)(layout_occupation_grid_column_count(&this.m_occupation_grid) +% (usize)(i64)result.end +% 2)
# FIXME: If a name is given as a <custom-ident>, only lines with that name are counted. If not enough lines with
# that name exist, all implicit grid lines on the side of the explicit grid corresponding to the search
# direction are assumed to have that name for the purpose of counting this span.
if css_grid_track_placement_is_span(&placement_end):
result.span = (usize)(i64)css_int_from_style_value(css_grid_track_placement_span(&placement_end))
if css_grid_track_placement_is_span(&placement_start):
result.span = (usize)(i64)css_int_from_style_value(css_grid_track_placement_span(&placement_start))
result.start = layout_grid_formatting_context_int_plus_size(result.end, 0 -% result.span)
# FIXME: Remove me once have implemented spans overflowing into negative indexes, e.g., grid-row: span 2 / 1
if result.start < 0:
result.start = 0
let explicit_line_count = this.m_explicit_rows_line_count if dimension == LayoutGridDimension.row else this.m_explicit_columns_line_count
if css_grid_track_placement_has_identifier(&placement_end):
let area_end_line_name = layout_grid_formatting_context_suffixed_name(css_grid_track_placement_identifier(&placement_end), "-end")
let line_number = placement_end_line_number else 1
if let area_end_line_index = layout_grid_formatting_context_get_nth_line_index_by_line_name(this, dimension, area_end_line_name, line_number):
result.end = area_end_line_index
elif let line_name_index = layout_grid_formatting_context_get_nth_line_index_by_line_name(this, dimension, css_grid_track_placement_identifier(&placement_end), line_number):
result.end = line_name_index
else:
result.end = (i32)explicit_line_count
if not css_grid_track_placement_has_line_number(&placement_start):
result.start = result.end - 1
if css_grid_track_placement_has_identifier(&placement_start):
let area_start_line_name = layout_grid_formatting_context_suffixed_name(css_grid_track_placement_identifier(&placement_start), "-start")
let line_number = placement_start_line_number else 1
if let area_start_line_index = layout_grid_formatting_context_get_nth_line_index_by_line_name(this, dimension, area_start_line_name, line_number):
result.start = area_start_line_index
elif let line_name_index = layout_grid_formatting_context_get_nth_line_index_by_line_name(this, dimension, css_grid_track_placement_identifier(&placement_start), line_number):
result.start = line_name_index
else:
result.start = (i32)explicit_line_count
if not css_grid_track_placement_is_positioned(&placement_start) and css_grid_track_placement_is_positioned(&placement_end) and not css_grid_track_placement_is_span(&placement_end):
if result.span == 0:
result.span = 1
result.start = layout_grid_formatting_context_int_plus_size(result.end, 0 -% result.span)
if css_grid_track_placement_is_positioned(&placement_start) and css_grid_track_placement_is_positioned(&placement_end):
if result.start > result.end:
let start = result.start
result.start = result.end
result.end = start
if result.start != result.end:
result.span = (usize)(i64)(result.end - result.start)
else:
result.span = 1
result.end = layout_grid_formatting_context_int_plus_size(result.start, result.span)
# If the placement contains two spans, remove the one contributed by the end grid-placement
# property.
if css_grid_track_placement_is_span(&placement_start) and css_grid_track_placement_is_span(&placement_end):
result.span = (usize)(i64)css_int_from_style_value(css_grid_track_placement_span(&placement_start))
return result
## `MUST(String::formatted("{}{}", name, suffix))`.
func layout_grid_formatting_context_suffixed_name(name: ak.String, suffix: str) -> ak.String:
var builder = ak.string_builder_new()
ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&name))
ak.string_builder_append(&builder, suffix)
return ak.string_builder_to_string(&builder) else trap("MUST: String::formatted")
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:364 Web::Layout::GridFormattingContext::resolve_grid_span.
func layout_grid_formatting_context_resolve_grid_span(this: LayoutGridFormattingContext*, child_box: LayoutBox*, dimension: LayoutGridDimension) -> usize:
_ = this
let computed_values = layout_box_computed(child_box)
let placement_start = css_computed_values_grid_row_start(computed_values) if dimension == LayoutGridDimension.row else css_computed_values_grid_column_start(computed_values)
let placement_end = css_computed_values_grid_row_end(computed_values) if dimension == LayoutGridDimension.row else css_computed_values_grid_column_end(computed_values)
if css_grid_track_placement_is_span(&placement_start):
return (usize)(i64)css_int_from_style_value(css_grid_track_placement_span(&placement_start))
if css_grid_track_placement_is_span(&placement_end):
return (usize)(i64)css_int_from_style_value(css_grid_track_placement_span(&placement_end))
return 1
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:377 Web::Layout::GridFormattingContext::place_item_with_row_and_column_position.
func layout_grid_formatting_context_place_item_with_row_and_column_position(this: LayoutGridFormattingContext*, child_box: LayoutBox*):
let row_placement_position = layout_grid_formatting_context_resolve_grid_position(this, child_box, LayoutGridDimension.row)
let column_placement_position = layout_grid_formatting_context_resolve_grid_position(this, child_box, LayoutGridDimension.column)
let row_start = row_placement_position.start
let row_span = row_placement_position.span
let column_start = column_placement_position.start
let column_span = column_placement_position.span
layout_grid_formatting_context_record_grid_placement(this, LayoutGridItem(
box = child_box,
used_values = layout_state_get_mutable(this.formatting_context.m_state, child_box.layout_node_with_style()),
row = row_start,
row_span = row_span,
column = column_start,
column_span = column_span))
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:396 Web::Layout::GridFormattingContext::place_item_with_row_position.
func layout_grid_formatting_context_place_item_with_row_position(this: LayoutGridFormattingContext*, child_box: LayoutBox*):
let placement_position = layout_grid_formatting_context_resolve_grid_position(this, child_box, LayoutGridDimension.row)
let row_start = placement_position.start
let row_span: usize = placement_position.span
var column_start: i32 = 0
let column_span = layout_grid_formatting_context_resolve_grid_span(this, child_box, LayoutGridDimension.column)
var found_available_column = false
var column_index = column_start
while column_index <= layout_occupation_grid_max_column_index(&this.m_occupation_grid):
if not layout_occupation_grid_is_area_occupied(&this.m_occupation_grid, column_index, row_start, (i32)column_span, (i32)row_span):
found_available_column = true
column_start = column_index
break
column_index += 1
if not found_available_column:
column_start = layout_occupation_grid_max_column_index(&this.m_occupation_grid) + 1
layout_grid_formatting_context_record_grid_placement(this, LayoutGridItem(
box = child_box,
used_values = layout_state_get_mutable(this.formatting_context.m_state, child_box.layout_node_with_style()),
row = row_start,
row_span = row_span,
column = column_start,
column_span = column_span))
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:426 Web::Layout::GridFormattingContext::place_item_with_column_position.
func layout_grid_formatting_context_place_item_with_column_position(this: LayoutGridFormattingContext*, child_box: LayoutBox*, auto_placement_cursor_row: i32*):
let placement_position = layout_grid_formatting_context_resolve_grid_position(this, child_box, LayoutGridDimension.column)
let column_start = placement_position.start
let column_span: usize = placement_position.span
let row_span = layout_grid_formatting_context_resolve_grid_span(this, child_box, LayoutGridDimension.row)
# Increment the cursor's row position until a value is found where the grid item does not
# overlap any occupied grid cells (creating new rows in the implicit grid as necessary).
while true:
if not layout_occupation_grid_is_area_occupied(&this.m_occupation_grid, column_start, *auto_placement_cursor_row, (i32)column_span, (i32)row_span):
break
*auto_placement_cursor_row += 1
layout_grid_formatting_context_record_grid_placement(this, LayoutGridItem(
box = child_box,
used_values = layout_state_get_mutable(this.formatting_context.m_state, child_box.layout_node_with_style()),
row = *auto_placement_cursor_row,
row_span = row_span,
column = column_start,
column_span = column_span))
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:451 Web::Layout::OccupationGrid::find_unoccupied_place.
pub func layout_occupation_grid_find_unoccupied_place(this: const LayoutOccupationGrid*, dimension: LayoutGridDimension, column_index: i32*, row_index: i32*, column_span: i32, row_span: i32) -> LayoutFoundUnoccupiedPlace:
if dimension == LayoutGridDimension.column:
# Row-flow: columns are the inner (minor) axis, rows are the outer (major) axis.
while *row_index <= layout_occupation_grid_max_row_index(this):
while *column_index <= layout_occupation_grid_max_column_index(this):
let minor_axis_fits = *column_index + column_span - 1 <= layout_occupation_grid_max_column_index(this)
if minor_axis_fits and not layout_occupation_grid_is_area_occupied(this, *column_index, *row_index, column_span, row_span):
return LayoutFoundUnoccupiedPlace.yes
*column_index += 1
*row_index += 1
*column_index = layout_occupation_grid_min_column_index(this)
else:
# Column-flow: rows are the inner (minor) axis, columns are the outer (major) axis.
while *column_index <= layout_occupation_grid_max_column_index(this):
while *row_index <= layout_occupation_grid_max_row_index(this):
let minor_axis_fits = *row_index + row_span - 1 <= layout_occupation_grid_max_row_index(this)
if minor_axis_fits and not layout_occupation_grid_is_area_occupied(this, *column_index, *row_index, column_span, row_span):
return LayoutFoundUnoccupiedPlace.yes
*row_index += 1
*column_index += 1
*row_index = layout_occupation_grid_min_row_index(this)
return LayoutFoundUnoccupiedPlace.no
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:482 Web::Layout::GridFormattingContext::place_item_with_no_declared_position.
func layout_grid_formatting_context_place_item_with_no_declared_position(this: LayoutGridFormattingContext*, child_box: LayoutBox*, auto_placement_cursor_column: i32*, auto_placement_cursor_row: i32*):
var column_start: i32 = 0
let column_span = layout_grid_formatting_context_resolve_grid_span(this, child_box, LayoutGridDimension.column)
var row_start: i32 = 0
let row_span = layout_grid_formatting_context_resolve_grid_span(this, child_box, LayoutGridDimension.row)
let auto_flow = css_computed_values_grid_auto_flow(layout_box_computed(layout_grid_formatting_context_grid_container(this)))
let dimension = LayoutGridDimension.column if auto_flow.row else LayoutGridDimension.row
# 4.1.2.1. Increment the column position of the auto-placement cursor until either this item's grid
# area does not overlap any occupied grid cells, or the cursor's column position, plus the item's
# column span, overflow the number of columns in the implicit grid, as determined earlier in this
# algorithm.
let found_unoccupied_area = layout_occupation_grid_find_unoccupied_place(&this.m_occupation_grid, dimension, auto_placement_cursor_column, auto_placement_cursor_row, (i32)column_span, (i32)row_span)
# 4.1.2.2. If a non-overlapping position was found in the previous step, set the item's row-start
# and column-start lines to the cursor's position. Otherwise, increment the auto-placement cursor's
# row position (creating new rows in the implicit grid as necessary), set its column position to the
# start-most column line in the implicit grid, and return to the previous step.
column_start = *auto_placement_cursor_column
row_start = *auto_placement_cursor_row
# `cursor += span - 1`: int += size_t.
*auto_placement_cursor_column = layout_grid_formatting_context_int_plus_size(*auto_placement_cursor_column, column_span -% 1)
*auto_placement_cursor_row = layout_grid_formatting_context_int_plus_size(*auto_placement_cursor_row, row_span -% 1)
if found_unoccupied_area == LayoutFoundUnoccupiedPlace.yes:
if dimension == LayoutGridDimension.column:
*auto_placement_cursor_column += 1
*auto_placement_cursor_row = layout_occupation_grid_min_row_index(&this.m_occupation_grid)
else:
*auto_placement_cursor_row += 1
*auto_placement_cursor_column = layout_occupation_grid_min_column_index(&this.m_occupation_grid)
layout_grid_formatting_context_record_grid_placement(this, LayoutGridItem(
box = child_box,
used_values = layout_state_get_mutable(this.formatting_context.m_state, child_box.layout_node_with_style()),
row = row_start,
row_span = row_span,
column = column_start,
column_span = column_span))
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:527 Web::Layout::GridFormattingContext::record_grid_placement.
func layout_grid_formatting_context_record_grid_placement(this: LayoutGridFormattingContext*, grid_item: LayoutGridItem):
let column = grid_item.column else trap("VERIFY: the grid item's column has a value")
let column_span = grid_item.column_span else trap("VERIFY: the grid item's column span has a value")
let row = grid_item.row else trap("VERIFY: the grid item's row has a value")
let row_span = grid_item.row_span else trap("VERIFY: the grid item's row span has a value")
layout_occupation_grid_set_occupied(&this.m_occupation_grid, column, layout_grid_formatting_context_int_plus_size(column, column_span), row, layout_grid_formatting_context_int_plus_size(row, row_span))
ak.vector_append_t(&this.m_grid_items, grid_item)
# mark: Tracks ==================================================================================
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:533 Web::Layout::GridFormattingContext::initialize_grid_tracks_from_definition.
func layout_grid_formatting_context_initialize_grid_tracks_from_definition(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension):
let grid_computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
let template = css_computed_values_grid_template_columns(grid_computed_values) if dimension == LayoutGridDimension.column else css_computed_values_grid_template_rows(grid_computed_values)
let tracks_definition = css_grid_track_size_list_track_list(&template)
let tracks = layout_grid_formatting_context_tracks(this, dimension)
let definitions = ak.vector_span_const(&tracks_definition)
for track_definition in &definitions:
var repeat_count: i32 = 1
var is_auto_fit = false
if css_explicit_grid_track_is_repeat(track_definition):
let repeat = css_explicit_grid_track_repeat(track_definition)
is_auto_fit = css_grid_repeat_is_auto_fit(&repeat)
if css_grid_repeat_is_auto_fill(&repeat) or is_auto_fit:
repeat_count = layout_grid_formatting_context_count_of_repeated_auto_fill_or_fit_tracks(this, dimension, track_definition)
else:
repeat_count = (i32)css_grid_repeat_repeat_count(&repeat)
for _repetition in 0..<repeat_count:
if css_explicit_grid_track_is_default(track_definition) or css_explicit_grid_track_is_minmax(track_definition):
ak.vector_append_t(tracks, layout_grid_formatting_context_grid_track_create_from_definition(track_definition, is_auto_fit))
elif css_explicit_grid_track_is_repeat(track_definition):
let repeat = css_explicit_grid_track_repeat(track_definition)
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 explicit_grid_tracks = ak.vector_span_const(&repeat_track_list)
for explicit_grid_track in &explicit_grid_tracks:
ak.vector_append_t(tracks, layout_grid_formatting_context_grid_track_create_from_definition(explicit_grid_track, is_auto_fit))
else:
trap("VERIFY_NOT_REACHED")
## The implicit tracks of one dimension (the two halves of initialize_grid_tracks_for_columns_and_rows, the same steps for
## columns and rows): tracks prepended for items at negative indexes, the explicit tracks, then tracks appended up to the
## occupation grid's size, each implicit one from grid-auto-columns / grid-auto-rows in turn.
func layout_grid_formatting_context_initialize_grid_tracks_for_dimension(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension):
let grid_computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
let tracks = layout_grid_formatting_context_tracks(this, dimension)
let lines = &this.m_column_lines if dimension == LayoutGridDimension.column else &this.m_row_lines
let grid_auto = css_computed_values_grid_auto_columns(grid_computed_values) if dimension == LayoutGridDimension.column else css_computed_values_grid_auto_rows(grid_computed_values)
let grid_auto_tracks = css_grid_track_size_list_track_list(&grid_auto)
var implicit_index: usize = 0
# NOTE: If there are implicit tracks created by items with negative indexes they should prepend explicitly defined tracks
let min_index = layout_occupation_grid_min_column_index(&this.m_occupation_grid) if dimension == LayoutGridDimension.column else layout_occupation_grid_min_row_index(&this.m_occupation_grid)
let negative_index_implied_tracks_count = ak.abs_i32(min_index)
for _line in 0..<negative_index_implied_tracks_count:
ak.vector_insert(lines, 0, ak.Vector[CssGridLineName]())
for _index in 0..<negative_index_implied_tracks_count:
if ak.vector_size(&grid_auto_tracks) > 0:
let definition = *ak.vector_at_const(&grid_auto_tracks, implicit_index % ak.vector_size(&grid_auto_tracks))
ak.vector_append_t(tracks, layout_grid_formatting_context_grid_track_create_from_definition(&definition))
else:
ak.vector_append_t(tracks, layout_grid_formatting_context_grid_track_create_auto())
implicit_index += 1
layout_grid_formatting_context_initialize_grid_tracks_from_definition(this, dimension)
let count = layout_occupation_grid_column_count(&this.m_occupation_grid) if dimension == LayoutGridDimension.column else layout_occupation_grid_row_count(&this.m_occupation_grid)
var index = ak.vector_size(tracks)
while index < count:
if ak.vector_size(&grid_auto_tracks) > 0:
let definition = *ak.vector_at_const(&grid_auto_tracks, implicit_index % ak.vector_size(&grid_auto_tracks))
ak.vector_append_t(tracks, layout_grid_formatting_context_grid_track_create_from_definition(&definition))
else:
ak.vector_append_t(tracks, layout_grid_formatting_context_grid_track_create_auto())
implicit_index += 1
index += 1
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:562 Web::Layout::GridFormattingContext::initialize_grid_tracks_for_columns_and_rows.
func layout_grid_formatting_context_initialize_grid_tracks_for_columns_and_rows(this: LayoutGridFormattingContext*):
layout_grid_formatting_context_initialize_grid_tracks_for_dimension(this, LayoutGridDimension.column)
layout_grid_formatting_context_initialize_grid_tracks_for_dimension(this, LayoutGridDimension.row)
ak.vector_resize(&this.m_column_lines, ak.vector_size(&this.m_grid_columns) + 1)
ak.vector_resize(&this.m_row_lines, ak.vector_size(&this.m_grid_rows) + 1)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:622 Web::Layout::GridFormattingContext::initialize_gap_tracks.
func layout_grid_formatting_context_initialize_gap_tracks_layout_grid_dimension(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension, available_size: LayoutAvailableSize):
# https://www.w3.org/TR/css-grid-2/#gutters
# 11.1. Gutters: the row-gap, column-gap, and gap properties
# For the purpose of track sizing, each gutter is treated as an extra, empty, fixed-size track of the specified
# size, which is spanned by any grid items that span across its corresponding grid line.
let grid_tracks = layout_grid_formatting_context_tracks(this, dimension)
let gap_tracks = &this.m_column_gap_tracks if dimension == LayoutGridDimension.column else &this.m_row_gap_tracks
let tracks_and_gaps = layout_grid_formatting_context_tracks_and_gaps(this, dimension)
ak.vector_clear(gap_tracks)
ak.vector_clear(tracks_and_gaps)
if ak.vector_is_empty(grid_tracks):
return
let computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
let computed_gap = css_computed_values_column_gap(computed_values) if dimension == LayoutGridDimension.column else css_computed_values_row_gap(computed_values)
var gap_size = layout_zero_px()
match computed_gap:
.css_normal_gap(_): _ = gap_size
_: gap_size = layout_formatting_context_gap_to_px(this.layout_formatting_context(), computed_gap, layout_available_size_to_px_or_zero(&available_size))
# The gap tracks are referenced from tracks_and_gaps, so their storage must not move while it is filled.
ak.vector_ensure_capacity(gap_tracks, ak.vector_size(grid_tracks) - 1)
for track_index in 0..<ak.vector_size(grid_tracks):
ak.vector_append_t(tracks_and_gaps, ak.vector_at(grid_tracks, track_index))
if track_index != ak.vector_size(grid_tracks) - 1:
ak.vector_unchecked_append_u(gap_tracks, layout_grid_formatting_context_grid_track_create_gap(gap_size))
ak.vector_append_t(tracks_and_gaps, ak.vector_last(gap_tracks))
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:655 Web::Layout::GridFormattingContext::initialize_gap_tracks.
func layout_grid_formatting_context_initialize_gap_tracks_layout_available_space(this: LayoutGridFormattingContext*, available_space: LayoutAvailableSpace):
layout_grid_formatting_context_initialize_gap_tracks_layout_grid_dimension(this, LayoutGridDimension.column, available_space.width)
layout_grid_formatting_context_initialize_gap_tracks_layout_grid_dimension(this, LayoutGridDimension.row, available_space.height)