dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / layout / grid_formatting_context_5.lucb
#==============================================================================================
#
# grid_formatting_context_5 - Layout::GridFormattingContext: item alignment and sizes,
# gutters, box metrics, collapsed auto-fit tracks and grid areas
#
# DESCRIPTION:
# Port of LibWeb/Layout/GridFormattingContext.cpp (lines 1613-2056): the alignment of an
# item in either axis (justify-self / align-self, with `auto` taken from the container's
# justify-items / align-items), the used size and margins of every item in its grid area
# (auto margins, alignment, stretching, min and max sizes, replaced elements and aspect
# ratios), the gutters' sizes under justify-content / align-content, the items' padding,
# margins and borders, collapsing empty auto-fit tracks, and the rectangle of an item's
# grid area (or of the augmented grid's padding edges for an absolutely positioned item).
#
# 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: Item alignment ==========================================================================
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:1613 Web::Layout::GridFormattingContext::alignment_for_item.
func layout_grid_formatting_context_alignment_for_item(this: LayoutGridFormattingContext*, box: LayoutBox*, dimension: LayoutGridDimension) -> LayoutAlignment:
let grid_computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
if dimension == LayoutGridDimension.column:
match css_computed_values_justify_self(layout_box_computed(box)):
.auto: return layout_to_alignment_justify_items(css_computed_values_justify_items(grid_computed_values))
.end: return LayoutAlignment.end
.normal: return LayoutAlignment.normal
.self_start: return LayoutAlignment.self_start
.self_end: return LayoutAlignment.self_end
.flex_start: return LayoutAlignment.start
.flex_end: return LayoutAlignment.end
.center: return LayoutAlignment.center
.baseline: return LayoutAlignment.baseline
.start: return LayoutAlignment.start
.stretch: return LayoutAlignment.stretch
.safe: return LayoutAlignment.safe
.unsafe: return LayoutAlignment.unsafe
.left: return LayoutAlignment.start
.right: return LayoutAlignment.end
_: trap("VERIFY_NOT_REACHED")
match css_computed_values_align_self(layout_box_computed(box)):
.auto: return layout_to_alignment_align_items(css_computed_values_align_items(grid_computed_values))
.end: return LayoutAlignment.end
.normal: return LayoutAlignment.normal
.self_start: return LayoutAlignment.self_start
.self_end: return LayoutAlignment.self_end
.flex_start: return LayoutAlignment.start
.flex_end: return LayoutAlignment.end
.center: return LayoutAlignment.center
.baseline: return LayoutAlignment.baseline
.start: return LayoutAlignment.start
.stretch: return LayoutAlignment.stretch
.safe: return LayoutAlignment.safe
.unsafe: return LayoutAlignment.unsafe
_: trap("VERIFY_NOT_REACHED")
# mark: Item sizes ==============================================================================
## resolve_grid_item_sizes' local `struct ItemAlignment`.
struct LayoutGridFormattingContextItemAlignment:
var margin_start: gfx.CssPixels
var margin_end: gfx.CssPixels
var size: gfx.CssPixels
## The `try_compute_size` lambda of resolve_grid_item_sizes (it captures the item, its containing block size, its
## alignment and the dimension).
func layout_grid_formatting_context_try_compute_size(item: const LayoutGridItem*, containing_block_size: gfx.CssPixels, alignment: LayoutAlignment, dimension: LayoutGridDimension, a_size: gfx.CssPixels, css_size: const CssSize*) -> LayoutGridFormattingContextItemAlignment:
var result = LayoutGridFormattingContextItemAlignment(margin_start = layout_grid_item_used_margin_start(item, dimension), margin_end = layout_grid_item_used_margin_end(item, dimension), size = a_size)
# Auto margins absorb positive free space prior to alignment via the box alignment properties.
let free_space_left_for_margins = containing_block_size.sub(result.size).sub(layout_grid_item_used_margin_box_start(item, dimension)).sub(layout_grid_item_used_margin_box_end(item, dimension))
let margin_start = layout_grid_item_margin_start(item, dimension)
let margin_end = layout_grid_item_margin_end(item, dimension)
if css_length_percentage_or_auto_is_auto(&margin_start) and css_length_percentage_or_auto_is_auto(&margin_end):
result.margin_start = layout_div_int(free_space_left_for_margins, 2)
result.margin_end = layout_div_int(free_space_left_for_margins, 2)
elif css_length_percentage_or_auto_is_auto(&margin_start):
result.margin_start = free_space_left_for_margins
elif css_length_percentage_or_auto_is_auto(&margin_end):
result.margin_end = free_space_left_for_margins
elif css_size_is_auto(css_size) and not layout_node_is_replaced_box(item.box.layout_node()):
result.size = result.size.add(free_space_left_for_margins)
let free_space_left_for_alignment = containing_block_size.sub(a_size).sub(layout_grid_item_used_margin_box_start(item, dimension)).sub(layout_grid_item_used_margin_box_end(item, dimension))
match alignment:
.normal, .stretch:
_ = alignment
.center:
result.margin_start = result.margin_start.add(layout_div_int(free_space_left_for_alignment, 2))
result.margin_end = result.margin_end.add(layout_div_int(free_space_left_for_alignment, 2))
result.size = a_size
.baseline, .start:
result.margin_end = result.margin_end.add(free_space_left_for_alignment)
result.size = a_size
.end:
result.margin_start = result.margin_start.add(free_space_left_for_alignment)
result.size = a_size
_:
_ = alignment
return result
## The `calculate_inner_size` lambda of resolve_grid_item_sizes.
func layout_grid_formatting_context_calculate_inner_size(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension, available_space: LayoutAvailableSpace, size: CssSize) -> gfx.CssPixels:
if dimension == LayoutGridDimension.column:
return layout_formatting_context_calculate_inner_width(this.layout_formatting_context(), item.box, available_space.width, size)
return layout_formatting_context_calculate_inner_height(this.layout_formatting_context(), item.box, available_space, size)
## The `tentative_size_for_replaced_element` lambda of resolve_grid_item_sizes.
func layout_grid_formatting_context_tentative_size_for_replaced_element(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension, available_space: LayoutAvailableSpace, size: CssSize) -> gfx.CssPixels:
if dimension == LayoutGridDimension.column:
return layout_formatting_context_tentative_width_for_replaced_element(this.layout_formatting_context(), item.box, size, available_space)
return layout_formatting_context_tentative_height_for_replaced_element(this.layout_formatting_context(), item.box, size, available_space)
## `*box.preferred_aspect_ratio() != 0`.
func layout_grid_formatting_context_preferred_aspect_ratio_is_not_zero(box: LayoutBox*) -> bool:
let preferred_aspect_ratio = layout_box_preferred_aspect_ratio(box) else trap("VERIFY: the box has a preferred aspect ratio")
return gfx.css_pixel_fraction_cmp_int(&preferred_aspect_ratio, 0) != 0
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:1683 Web::Layout::GridFormattingContext::resolve_grid_item_sizes.
func layout_grid_formatting_context_resolve_grid_item_sizes(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension):
let base = this.layout_formatting_context()
let items = ak.vector_span(&this.m_grid_items)
for item in &items:
let containing_block_size = layout_grid_formatting_context_containing_block_size_for_item(this, item, dimension)
let alignment = layout_grid_formatting_context_alignment_for_item(this, item.box, dimension)
let preferred_size = layout_grid_item_preferred_size(item, dimension)
# (struct ItemAlignment is LayoutGridFormattingContextItemAlignment; try_compute_size is
# layout_grid_formatting_context_try_compute_size.)
let available_space = LayoutAvailableSpace(
width = layout_available_size_make_definite(layout_clamp_to_max_dimension_value(layout_grid_formatting_context_containing_block_size_for_item(this, item, LayoutGridDimension.column))),
height = layout_available_size_make_definite(layout_clamp_to_max_dimension_value(layout_grid_formatting_context_containing_block_size_for_item(this, item, LayoutGridDimension.row))))
# (calculate_inner_size and tentative_size_for_replaced_element are layout_grid_formatting_context_calculate_inner_size
# and layout_grid_formatting_context_tentative_size_for_replaced_element.)
var used_alignment: LayoutGridFormattingContextItemAlignment
let hint = layout_box_auto_content_box_size(item.box)
var has_replaced_size_hint_in_this_axis = false
if dimension == LayoutGridDimension.column:
has_replaced_size_hint_in_this_axis = css_size_with_aspect_ratio_has_width(&hint) or (css_size_with_aspect_ratio_has_height(&hint) and layout_box_has_preferred_aspect_ratio(item.box))
else:
has_replaced_size_hint_in_this_axis = css_size_with_aspect_ratio_has_height(&hint) or (css_size_with_aspect_ratio_has_width(&hint) and layout_box_has_preferred_aspect_ratio(item.box))
if layout_node_is_replaced_box(item.box.layout_node()) and has_replaced_size_hint_in_this_axis:
let tentative_size = layout_grid_formatting_context_tentative_size_for_replaced_element(this, item, dimension, available_space, preferred_size)
let item_preferred_size = layout_grid_item_preferred_size(item, dimension)
used_alignment = layout_grid_formatting_context_try_compute_size(item, containing_block_size, alignment, dimension, tentative_size, &item_preferred_size)
else:
# OPTIMIZATION: For auto-sized items with stretch/normal alignment and no auto margins, the item stretches
# to fill the containing block. We can compute this directly without the expensive
# calculate_fit_content_width/height calls that trigger intrinsic sizing.
# NB: Final grid item alignment works with the resolved grid area size. Percentage preferred sizes
# must resolve against that definite area instead of being reclassified as auto from the outer
# grid container's own definiteness.
let margin_start = layout_grid_item_margin_start(item, dimension)
let margin_end = layout_grid_item_margin_end(item, dimension)
let can_stretch_directly = css_size_is_auto(&preferred_size) and (alignment == LayoutAlignment.stretch or alignment == LayoutAlignment.normal) and not css_length_percentage_or_auto_is_auto(&margin_start) and not css_length_percentage_or_auto_is_auto(&margin_end)
if can_stretch_directly:
let stretched_size = containing_block_size.sub(layout_grid_item_used_margin_box_start(item, dimension)).sub(layout_grid_item_used_margin_box_end(item, dimension))
used_alignment = LayoutGridFormattingContextItemAlignment(margin_start = layout_grid_item_used_margin_start(item, dimension), margin_end = layout_grid_item_used_margin_end(item, dimension), size = stretched_size)
elif css_size_is_auto(&preferred_size) or css_size_is_fit_content(&preferred_size):
var fit_content_size: gfx.CssPixels
if dimension == LayoutGridDimension.column:
fit_content_size = layout_formatting_context_calculate_fit_content_width(base, item.box, available_space)
elif css_size_is_auto(&preferred_size) and layout_box_has_preferred_aspect_ratio(item.box) and layout_grid_formatting_context_preferred_aspect_ratio_is_not_zero(item.box) and layout_state_used_values_has_definite_width(item.used_values):
# NB: When the item has a preferred aspect ratio and a definite width, resolve the
# height through the aspect ratio instead of using fit-content sizing, which would
# incorrectly use the available width (grid area width) instead of the item's width.
fit_content_size = layout_state_used_values_content_width(item.used_values).div_fraction(layout_box_preferred_aspect_ratio(item.box) else trap("VERIFY: the item has a preferred aspect ratio"))
else:
fit_content_size = layout_formatting_context_calculate_fit_content_height(base, item.box, available_space)
used_alignment = layout_grid_formatting_context_try_compute_size(item, containing_block_size, alignment, dimension, fit_content_size, &preferred_size)
else:
let size_px = layout_grid_formatting_context_calculate_inner_size(this, item, dimension, available_space, preferred_size)
used_alignment = layout_grid_formatting_context_try_compute_size(item, containing_block_size, alignment, dimension, size_px, &preferred_size)
let should_treat_maximum_size_as_none = layout_formatting_context_should_treat_max_width_as_none(base, item.box, available_space.width) if dimension == LayoutGridDimension.column else layout_formatting_context_should_treat_max_height_as_none(base, item.box, available_space.height)
if not should_treat_maximum_size_as_none:
let maximum_size = layout_grid_item_maximum_size(item, dimension)
let max_size_px = layout_grid_formatting_context_calculate_inner_size(this, item, dimension, available_space, maximum_size)
let max_width_alignment = layout_grid_formatting_context_try_compute_size(item, containing_block_size, alignment, dimension, max_size_px, &maximum_size)
if used_alignment.size.gt(max_width_alignment.size):
used_alignment = max_width_alignment
let minimum_size = layout_grid_item_minimum_size(item, dimension)
if not css_size_is_auto(&minimum_size):
let min_size_alignment = layout_grid_formatting_context_try_compute_size(item, containing_block_size, alignment, dimension, layout_grid_formatting_context_calculate_inner_size(this, item, dimension, available_space, minimum_size), &minimum_size)
if used_alignment.size.lt(min_size_alignment.size):
used_alignment = min_size_alignment
if dimension == LayoutGridDimension.column:
item.used_values.margin_left = used_alignment.margin_start
item.used_values.margin_right = used_alignment.margin_end
layout_state_used_values_set_content_width(item.used_values, used_alignment.size)
else:
item.used_values.margin_top = used_alignment.margin_start
item.used_values.margin_bottom = used_alignment.margin_end
layout_state_used_values_set_content_height(item.used_values, used_alignment.size)
# mark: Gutters and box metrics =================================================================
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:1839 Web::Layout::GridFormattingContext::resolve_track_spacing.
func layout_grid_formatting_context_resolve_track_spacing(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension):
let is_column_dimension = dimension == LayoutGridDimension.column
let available_space = layout_grid_formatting_context_available_space(this)
var total_gap_space = layout_available_size_to_px_or_zero(&available_space.width) if is_column_dimension else layout_available_size_to_px_or_zero(&available_space.height)
let grid_tracks = ak.vector_span(&this.m_grid_columns if is_column_dimension else &this.m_grid_rows)
for track in &grid_tracks:
total_gap_space = total_gap_space.sub(track.base_size)
total_gap_space = ak.max(total_gap_space, layout_zero_px())
let gap_track_count = ak.vector_size(&this.m_column_gap_tracks) if is_column_dimension else ak.vector_size(&this.m_row_gap_tracks)
if gap_track_count == 0:
return
var space_between_tracks = layout_zero_px()
var alignment: LayoutAlignment
let computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
if is_column_dimension:
alignment = layout_to_alignment_justify_content(css_computed_values_justify_content(computed_values))
else:
alignment = layout_to_alignment_align_content(css_computed_values_align_content(computed_values))
match alignment:
.space_between:
space_between_tracks = layout_grid_formatting_context_div_count(total_gap_space, gap_track_count)
.space_around:
space_between_tracks = layout_grid_formatting_context_div_count(total_gap_space, gap_track_count + 1)
.space_evenly:
space_between_tracks = layout_grid_formatting_context_div_count(total_gap_space, gap_track_count + 2)
_:
# Normal, Stretch, Start, End, Center and the rest.
_ = alignment
let computed_gap = css_computed_values_column_gap(computed_values) if is_column_dimension else css_computed_values_row_gap(computed_values)
let available_size = layout_available_size_to_px_or_zero(&available_space.width) if is_column_dimension else layout_available_size_to_px_or_zero(&available_space.height)
space_between_tracks = ak.max(space_between_tracks, layout_formatting_context_gap_to_px(this.layout_formatting_context(), computed_gap, available_size))
let gap_tracks = ak.vector_span(&this.m_column_gap_tracks if is_column_dimension else &this.m_row_gap_tracks)
for gap_track in &gap_tracks:
gap_track.base_size = space_between_tracks
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:1892 Web::Layout::GridFormattingContext::resolve_items_box_metrics.
func layout_grid_formatting_context_resolve_items_box_metrics(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension):
let grid_container = layout_grid_formatting_context_grid_container(this).layout_node()
let items = ak.vector_span(&this.m_grid_items)
for item in &items:
let computed_values = layout_box_computed(item.box)
let padding = css_computed_values_padding(computed_values)
let margin = css_computed_values_margin(computed_values)
let containing_block_width = layout_grid_formatting_context_containing_block_size_for_item(this, item, LayoutGridDimension.column)
if dimension == LayoutGridDimension.column:
let padding_right = css_length_box_right_const(&padding)
let padding_left = css_length_box_left_const(&padding)
item.used_values.padding_right = css_length_percentage_or_auto_to_px_or_zero(&padding_right, grid_container, containing_block_width)
item.used_values.padding_left = css_length_percentage_or_auto_to_px_or_zero(&padding_left, grid_container, containing_block_width)
let margin_right = css_length_box_right_const(&margin)
let margin_left = css_length_box_left_const(&margin)
item.used_values.margin_right = css_length_percentage_or_auto_to_px_or_zero(&margin_right, grid_container, containing_block_width)
item.used_values.margin_left = css_length_percentage_or_auto_to_px_or_zero(&margin_left, grid_container, containing_block_width)
item.used_values.border_right = css_computed_values_border_right(computed_values).width
item.used_values.border_left = css_computed_values_border_left(computed_values).width
else:
let padding_top = css_length_box_top_const(&padding)
let padding_bottom = css_length_box_bottom_const(&padding)
item.used_values.padding_top = css_length_percentage_or_auto_to_px_or_zero(&padding_top, grid_container, containing_block_width)
item.used_values.padding_bottom = css_length_percentage_or_auto_to_px_or_zero(&padding_bottom, grid_container, containing_block_width)
let margin_top = css_length_box_top_const(&margin)
let margin_bottom = css_length_box_bottom_const(&margin)
item.used_values.margin_top = css_length_percentage_or_auto_to_px_or_zero(&margin_top, grid_container, containing_block_width)
item.used_values.margin_bottom = css_length_percentage_or_auto_to_px_or_zero(&margin_bottom, grid_container, containing_block_width)
item.used_values.border_top = css_computed_values_border_top(computed_values).width
item.used_values.border_bottom = css_computed_values_border_bottom(computed_values).width
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:1920 Web::Layout::GridFormattingContext::collapse_auto_fit_tracks_if_needed.
func layout_grid_formatting_context_collapse_auto_fit_tracks_if_needed(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension):
# https://www.w3.org/TR/css-grid-2/#auto-repeat
# The auto-fit keyword behaves the same as auto-fill, except that after grid item placement any
# empty repeated tracks are collapsed. An empty track is one with no in-flow grid items placed into
# or spanning across it. (This can result in all tracks being collapsed, if they’re all empty.)
let tracks = ak.vector_span(layout_grid_formatting_context_tracks(this, dimension))
for track_index in 0..<tracks.length:
if not tracks[track_index].is_auto_fit:
continue
# `is_occupied(int column_index, int row_index)`: the size_t index converted to int.
let column_index: i32 = (i32)track_index if dimension == LayoutGridDimension.column else 0
let row_index: i32 = (i32)track_index if dimension == LayoutGridDimension.row else 0
if layout_occupation_grid_is_occupied(&this.m_occupation_grid, column_index, row_index):
continue
# NOTE: A collapsed track is treated as having a fixed track sizing function of 0px
tracks[track_index].min_track_sizing_function = layout_grid_formatting_context_px_grid_size(layout_zero_px())
tracks[track_index].max_track_sizing_function = layout_grid_formatting_context_px_grid_size(layout_zero_px())
# mark: Grid areas ==============================================================================
## The `place_into_track` lambda of get_grid_area_rect.
func layout_grid_formatting_context_place_into_track(this: LayoutGridFormattingContext*, grid_item: const LayoutGridItem*, area_rect: gfx.CssPixelRect*, dimension: LayoutGridDimension):
let tracks_and_gaps = ak.vector_span(layout_grid_formatting_context_tracks_and_gaps(this, dimension))
let resolved_span = layout_grid_item_span(grid_item, dimension) * 2
let gap_adjusted_position = layout_grid_item_gap_adjusted_position(grid_item, dimension)
let start: i32 = gap_adjusted_position
# `start + resolved_span` (int + size_t) converted to int.
let end: i32 = layout_grid_formatting_context_int_plus_size(start, resolved_span)
assert(start <= end)
let grid_container_size = layout_grid_formatting_context_available_size(this, dimension)
var sum_of_base_sizes_including_gaps = layout_zero_px()
for summed_track in tracks_and_gaps:
sum_of_base_sizes_including_gaps = sum_of_base_sizes_including_gaps.add(summed_track.base_size)
var alignment: LayoutAlignment
let computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
if dimension == LayoutGridDimension.column:
alignment = layout_to_alignment_justify_content(css_computed_values_justify_content(computed_values))
else:
alignment = layout_to_alignment_align_content(css_computed_values_align_content(computed_values))
var start_offset = layout_zero_px()
var end_offset = layout_zero_px()
if alignment == LayoutAlignment.center or alignment == LayoutAlignment.space_around or alignment == LayoutAlignment.space_evenly:
var free_space = layout_available_size_to_px_or_zero(&grid_container_size).sub(sum_of_base_sizes_including_gaps)
free_space = ak.max(free_space, layout_zero_px())
start_offset = layout_div_int(free_space, 2)
end_offset = layout_div_int(free_space, 2)
elif alignment == LayoutAlignment.end:
let free_space = layout_available_size_to_px_or_zero(&grid_container_size).sub(sum_of_base_sizes_including_gaps)
start_offset = free_space
end_offset = free_space
# `min(start, tracks_and_gaps.size())` is AK::min<int>.
let track_count = (i32)tracks_and_gaps.length
for i in 0..<ak.min[i32](start, track_count):
start_offset = start_offset.add(tracks_and_gaps[(usize)i].base_size)
for i in 0..<ak.min[i32](end, track_count):
end_offset = end_offset.add(tracks_and_gaps[(usize)i].base_size)
if dimension == LayoutGridDimension.column:
gfx.css_pixel_rect_set_x(area_rect, start_offset)
gfx.css_pixel_rect_set_width(area_rect, end_offset.sub(start_offset))
else:
gfx.css_pixel_rect_set_y(area_rect, start_offset)
gfx.css_pixel_rect_set_height(area_rect, end_offset.sub(start_offset))
## The `place_into_track_formed_by_last_line_and_grid_container_padding_edge` lambda of get_grid_area_rect.
func layout_grid_formatting_context_place_into_track_formed_by_last_line_and_grid_container_padding_edge(this: LayoutGridFormattingContext*, grid_item: const LayoutGridItem*, area_rect: gfx.CssPixelRect*, dimension: LayoutGridDimension):
assert(layout_node_is_absolutely_positioned(grid_item.box.layout_node()))
var offset = layout_zero_px()
for row_track in ak.vector_span(layout_grid_formatting_context_tracks_and_gaps(this, dimension)):
offset = offset.add(row_track.base_size)
let size = this.m_grid_container_used_values.padding_right if dimension == LayoutGridDimension.column else this.m_grid_container_used_values.padding_bottom
if dimension == LayoutGridDimension.column:
gfx.css_pixel_rect_set_x(area_rect, offset)
gfx.css_pixel_rect_set_width(area_rect, size)
else:
gfx.css_pixel_rect_set_y(area_rect, offset)
gfx.css_pixel_rect_set_height(area_rect, size)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:1939 Web::Layout::GridFormattingContext::get_grid_area_rect.
func layout_grid_formatting_context_get_grid_area_rect(this: LayoutGridFormattingContext*, grid_item: const LayoutGridItem*) -> gfx.CssPixelRect:
var area_rect: gfx.CssPixelRect
# (place_into_track and place_into_track_formed_by_last_line_and_grid_container_padding_edge are
# layout_grid_formatting_context_place_into_track and ..._place_into_track_formed_by_last_line_and_grid_container_padding_edge.)
let available_space = layout_grid_formatting_context_available_space(this)
if let row = grid_item.row:
if row == (i32)ak.vector_size(&this.m_grid_rows):
layout_grid_formatting_context_place_into_track_formed_by_last_line_and_grid_container_padding_edge(this, grid_item, &area_rect, LayoutGridDimension.row)
else:
layout_grid_formatting_context_place_into_track(this, grid_item, &area_rect, LayoutGridDimension.row)
else:
# https://www.w3.org/TR/css-grid-2/#abspos-items
# Instead of auto-placement, an auto value for a grid-placement property contributes a special line to the placement whose position
# is that of the corresponding padding edge of the grid container (the padding edge of the scrollable area, if the grid container
# overflows). These lines become the first and last lines (0th and -0th) of the augmented grid used for positioning absolutely-positioned items.
var height = layout_zero_px()
if layout_available_size_is_definite(&available_space.height):
height = layout_available_size_to_px_or_zero(&available_space.height)
else:
for row_track in ak.vector_span(&this.m_grid_rows_and_gaps):
height = height.add(row_track.base_size)
height = height.add(this.m_grid_container_used_values.padding_top).add(this.m_grid_container_used_values.padding_bottom)
gfx.css_pixel_rect_set_height(&area_rect, height)
gfx.css_pixel_rect_set_y(&area_rect, this.m_grid_container_used_values.padding_top.neg())
if let column = grid_item.column:
if column == (i32)ak.vector_size(&this.m_grid_columns):
layout_grid_formatting_context_place_into_track_formed_by_last_line_and_grid_container_padding_edge(this, grid_item, &area_rect, LayoutGridDimension.column)
else:
layout_grid_formatting_context_place_into_track(this, grid_item, &area_rect, LayoutGridDimension.column)
else:
var width = layout_zero_px()
if layout_available_size_is_definite(&available_space.width):
width = layout_available_size_to_px_or_zero(&available_space.width)
else:
for col_track in ak.vector_span(&this.m_grid_columns_and_gaps):
width = width.add(col_track.base_size)
width = width.add(this.m_grid_container_used_values.padding_left).add(this.m_grid_container_used_values.padding_right)
gfx.css_pixel_rect_set_width(&area_rect, width)
gfx.css_pixel_rect_set_x(&area_rect, this.m_grid_container_used_values.padding_left.neg())
return area_rect