dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / layout / grid_formatting_context_7.lucb
#==============================================================================================
#
# grid_formatting_context_7 - Layout::GridFormattingContext: the items' size contributions
# and automatic minimum sizes
#
# DESCRIPTION:
# Port of LibWeb/Layout/GridFormattingContext.cpp (lines 2464-2850): the grid container's
# maximum size, the items' min- and max-content sizes and contributions, their
# containing block (the sum of the tracks and gaps they span), the limited contributions
# of items under fixed max track sizing functions
# (https://drafts.csswg.org/css-grid-2/#algo-spanning-items), the specified,
# transferred and content size suggestions, the content-based minimum size
# (https://www.w3.org/TR/css-grid-1/#content-based-minimum-size), the automatic minimum
# size, the minimum contribution, and the static position rectangle of an absolutely
# positioned child.
#
# 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: The grid container's maximum size =======================================================
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2464 Web::Layout::GridFormattingContext::should_treat_grid_container_maximum_size_as_none.
func layout_grid_formatting_context_should_treat_grid_container_maximum_size_as_none(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension) -> bool:
let available_space = layout_grid_formatting_context_available_space(this)
if dimension == LayoutGridDimension.column:
return layout_formatting_context_should_treat_max_width_as_none(this.layout_formatting_context(), layout_grid_formatting_context_grid_container(this), available_space.width)
return layout_formatting_context_should_treat_max_height_as_none(this.layout_formatting_context(), layout_grid_formatting_context_grid_container(this), available_space.height)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2471 Web::Layout::GridFormattingContext::calculate_grid_container_maximum_size.
func layout_grid_formatting_context_calculate_grid_container_maximum_size(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension) -> gfx.CssPixels:
let grid_container = layout_grid_formatting_context_grid_container(this)
let computed_values = layout_box_computed(grid_container)
let available_space = layout_grid_formatting_context_available_space(this)
if dimension == LayoutGridDimension.column:
return layout_formatting_context_calculate_inner_width(this.layout_formatting_context(), grid_container, available_space.width, css_computed_values_max_width(computed_values))
return layout_formatting_context_calculate_inner_height(this.layout_formatting_context(), grid_container, available_space, css_computed_values_max_height(computed_values))
# mark: Content sizes and contributions =========================================================
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2479 Web::Layout::GridFormattingContext::calculate_min_content_size.
func layout_grid_formatting_context_calculate_min_content_size(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
if dimension == LayoutGridDimension.column:
return layout_formatting_context_calculate_min_content_width(this.layout_formatting_context(), item.box)
let item_available_space = layout_grid_item_available_space(item)
return layout_formatting_context_calculate_min_content_height(this.layout_formatting_context(), item.box, layout_available_size_to_px_or_zero(&item_available_space.width))
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2487 Web::Layout::GridFormattingContext::calculate_max_content_size
## (nothing calls it, in C++ either; public so the module checks without an unused-function warning).
pub func layout_grid_formatting_context_calculate_max_content_size(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
if dimension == LayoutGridDimension.column:
return layout_formatting_context_calculate_max_content_width(this.layout_formatting_context(), item.box)
let item_available_space = layout_grid_item_available_space(item)
return layout_formatting_context_calculate_max_content_height(this.layout_formatting_context(), item.box, layout_available_size_to_px_or_zero(&item_available_space.width))
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2495 Web::Layout::GridFormattingContext::containing_block_size_for_item.
func layout_grid_formatting_context_containing_block_size_for_item(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
var containing_block_size = layout_zero_px()
for track in layout_grid_formatting_context_for_each_spanned_track_by_item_const(this, item, dimension):
containing_block_size = containing_block_size.add(track.base_size)
return containing_block_size
## `item.maximum_size(dimension)` in pixels when it is a length, else CSSPixels::max() (the contributions' upper bound).
func layout_grid_formatting_context_maximum_size_px(item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
var maximum_size = gfx.css_pixels_max()
let css_maximum_size = layout_grid_item_maximum_size(item, dimension)
if css_size_is_length(&css_maximum_size):
let length = css_size_length(&css_maximum_size)
maximum_size = css_length_to_px_layout_node(&length, item.box.layout_node())
return maximum_size
## The `should_treat_preferred_size_as_auto` lambda of the contributions.
func layout_grid_formatting_context_should_treat_preferred_size_as_auto(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension, available_space_for_item: LayoutAvailableSpace) -> bool:
if dimension == LayoutGridDimension.column:
return layout_formatting_context_should_treat_width_as_auto(this.layout_formatting_context(), item.box, available_space_for_item)
return layout_formatting_context_should_treat_height_as_auto(this.layout_formatting_context(), item.box, available_space_for_item)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2504 Web::Layout::GridFormattingContext::calculate_min_content_contribution.
func layout_grid_formatting_context_calculate_min_content_contribution(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
let base = this.layout_formatting_context()
let available_space_for_item = layout_grid_item_available_space(item)
let should_treat_preferred_size_as_auto = layout_grid_formatting_context_should_treat_preferred_size_as_auto(this, item, dimension, available_space_for_item)
let maximum_size = layout_grid_formatting_context_maximum_size_px(item, dimension)
if should_treat_preferred_size_as_auto:
var min_content_size: gfx.CssPixels
# NOTE: Not defined in spec, but matches other browsers: a scroll container's min-content
# width contribution is 0 because its content can overflow and scroll horizontally.
# This does NOT apply to the row dimension — scroll containers must still contribute
# their content height, otherwise grids with height:min-content collapse rows to 0.
if dimension == LayoutGridDimension.column and layout_node_with_style_is_scroll_container(item.box.layout_node_with_style()):
min_content_size = layout_zero_px()
else:
min_content_size = layout_grid_formatting_context_calculate_min_content_size(this, item, dimension)
let result = layout_grid_item_add_margin_box_sizes(item, min_content_size, dimension)
return ak.min(result, maximum_size)
let preferred_size = layout_grid_item_preferred_size(item, dimension)
let available_space = layout_grid_formatting_context_available_space(this)
if dimension == LayoutGridDimension.column:
let width = layout_formatting_context_calculate_inner_width(base, item.box, available_space.width, preferred_size)
return ak.min(layout_grid_item_add_margin_box_sizes(item, width, dimension), maximum_size)
let height = layout_formatting_context_calculate_inner_height(base, item.box, available_space, preferred_size)
return ak.min(layout_grid_item_add_margin_box_sizes(item, height, dimension), maximum_size)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2543 Web::Layout::GridFormattingContext::calculate_max_content_contribution.
func layout_grid_formatting_context_calculate_max_content_contribution(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
let base = this.layout_formatting_context()
let available_space_for_item = layout_grid_item_available_space(item)
let should_treat_preferred_size_as_auto = layout_grid_formatting_context_should_treat_preferred_size_as_auto(this, item, dimension, available_space_for_item)
let maximum_size = layout_grid_formatting_context_maximum_size_px(item, dimension)
let preferred_size = layout_grid_item_preferred_size(item, dimension)
if should_treat_preferred_size_as_auto or css_size_is_fit_content(&preferred_size):
let fit_content_size = layout_formatting_context_calculate_fit_content_width(base, item.box, available_space_for_item) if dimension == LayoutGridDimension.column else layout_formatting_context_calculate_fit_content_height(base, item.box, available_space_for_item)
let result = layout_grid_item_add_margin_box_sizes(item, fit_content_size, dimension)
return ak.min(result, maximum_size)
# The `resolve_size` lambda.
var resolved_size: gfx.CssPixels
let available_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)))
if dimension == LayoutGridDimension.row:
let available_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)))
let item_available_space = LayoutAvailableSpace(width = available_width, height = available_height)
resolved_size = layout_formatting_context_calculate_inner_height(base, item.box, item_available_space, preferred_size)
else:
resolved_size = layout_formatting_context_calculate_inner_width(base, item.box, available_width, preferred_size)
let result = layout_grid_item_add_margin_box_sizes(item, resolved_size, dimension)
return ak.min(result, maximum_size)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2579 Web::Layout::GridFormattingContext::calculate_fixed_max_track_size_limit.
func layout_grid_formatting_context_calculate_fixed_max_track_size_limit(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels?:
# https://drafts.csswg.org/css-grid-2/#algo-spanning-items
# For an item spanning multiple tracks, the upper limit used to calculate its limited min-/max-content
# contribution is the sum of the fixed max track sizing functions of any tracks it spans, and is applied
# if it only spans such tracks.
#
# https://drafts.csswg.org/css-grid-2#algo-terms
# In all cases, treat auto and fit-content() as max-content, except where specified otherwise for fit-content().
let available_size = layout_grid_formatting_context_available_size(this, dimension)
let grid_container = layout_grid_formatting_context_grid_container(this).layout_node()
var result = layout_zero_px()
var saw_track = false
var has_limit = true
for track in layout_grid_formatting_context_for_each_spanned_track_by_item_const(this, item, dimension):
# (The C++ callback returns early; the walk itself goes on.)
if not has_limit:
continue
saw_track = true
let max_track_sizing_function = track.max_track_sizing_function
if css_grid_size_is_fixed(&max_track_sizing_function, available_size):
let max_track_size = css_grid_size_css_size(&max_track_sizing_function)
result = result.add(css_size_to_px(&max_track_size, grid_container, layout_available_size_to_px_or_zero(&available_size)))
continue
if css_grid_size_is_fit_content(&max_track_sizing_function):
let max_track_size = css_grid_size_css_size(&max_track_sizing_function)
if let fit_content_available_space = css_size_fit_content_available_space(&max_track_size):
if not css_percentage_or_contains_percentage(&fit_content_available_space.percentage_or) or layout_available_size_is_definite(&available_size):
result = result.add(css_size_to_px(&max_track_size, grid_container, layout_available_size_to_px_or_zero(&available_size)))
continue
has_limit = false
if not has_limit:
return none
if not saw_track:
return none
return result
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2626 Web::Layout::GridFormattingContext::calculate_limited_min_content_contribution.
func layout_grid_formatting_context_calculate_limited_min_content_contribution(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
# The limited min-content contribution of an item is its min-content contribution,
# limited by the max track sizing function (which could be the argument to a fit-content() track
# sizing function) if that is fixed and ultimately floored by its minimum contribution.
let min_content_contribution = layout_grid_formatting_context_calculate_min_content_contribution(this, item, dimension)
let minimum_contribution = layout_grid_formatting_context_calculate_minimum_contribution(this, item, dimension)
if min_content_contribution.lt(minimum_contribution):
return minimum_contribution
if let fixed_max_track_size_limit = layout_grid_formatting_context_calculate_fixed_max_track_size_limit(this, item, dimension):
return ak.max(ak.min(min_content_contribution, fixed_max_track_size_limit), minimum_contribution)
if not layout_grid_formatting_context_should_treat_grid_container_maximum_size_as_none(this, dimension):
let max_size = layout_grid_formatting_context_calculate_grid_container_maximum_size(this, dimension)
if min_content_contribution.gt(max_size):
return max_size
return min_content_contribution
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2648 Web::Layout::GridFormattingContext::calculate_limited_max_content_contribution.
func layout_grid_formatting_context_calculate_limited_max_content_contribution(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
# The limited max-content contribution of an item is its max-content contribution,
# limited by the max track sizing function (which could be the argument to a fit-content() track
# sizing function) if that is fixed and ultimately floored by its minimum contribution.
let max_content_contribution = layout_grid_formatting_context_calculate_max_content_contribution(this, item, dimension)
let minimum_contribution = layout_grid_formatting_context_calculate_minimum_contribution(this, item, dimension)
if max_content_contribution.lt(minimum_contribution):
return minimum_contribution
if let fixed_max_track_size_limit = layout_grid_formatting_context_calculate_fixed_max_track_size_limit(this, item, dimension):
return ak.max(ak.min(max_content_contribution, fixed_max_track_size_limit), minimum_contribution)
if not layout_grid_formatting_context_should_treat_grid_container_maximum_size_as_none(this, dimension):
let max_size = layout_grid_formatting_context_calculate_grid_container_maximum_size(this, dimension)
if max_content_contribution.gt(max_size):
return max_size
return max_content_contribution
# mark: Minimum sizes ===========================================================================
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2670 Web::Layout::GridFormattingContext::content_size_suggestion.
func layout_grid_formatting_context_content_size_suggestion(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
# The content size suggestion is the min-content size in the relevant axis
# FIXME: clamped, if it has a preferred aspect ratio, by any definite opposite-axis minimum and maximum sizes
# converted through the aspect ratio.
return layout_grid_formatting_context_calculate_min_content_size(this, item, dimension)
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2678 Web::Layout::GridFormattingContext::specified_size_suggestion.
func layout_grid_formatting_context_specified_size_suggestion(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels?:
# https://www.w3.org/TR/css-grid-1/#specified-size-suggestion
# If the item’s preferred size in the relevant axis is definite, then the specified size suggestion is that size.
# It is otherwise undefined.
let has_definite_preferred_size = layout_state_used_values_has_definite_width(item.used_values) if dimension == LayoutGridDimension.column else layout_state_used_values_has_definite_height(item.used_values)
if has_definite_preferred_size:
# FIXME: consider margins, padding and borders because it is outer size.
let containing_block_size = layout_grid_formatting_context_containing_block_size_for_item(this, item, dimension)
let preferred_size = layout_grid_item_preferred_size(item, dimension)
return css_size_to_px(&preferred_size, item.box.layout_node(), containing_block_size)
return none
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2693 Web::Layout::GridFormattingContext::transferred_size_suggestion.
func layout_grid_formatting_context_transferred_size_suggestion(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels?:
_ = this
# https://www.w3.org/TR/css-grid-2/#transferred-size-suggestion
# If the item has a preferred aspect ratio and its preferred size in the opposite axis is definite, then the transferred
# size suggestion is that size (clamped by the opposite-axis minimum and maximum sizes if they are definite), converted
# through the aspect ratio. It is otherwise undefined.
let preferred_aspect_ratio = layout_box_preferred_aspect_ratio(item.box) else return none
let preferred_size_in_opposite_axis = layout_grid_item_preferred_size(item, LayoutGridDimension.row if dimension == LayoutGridDimension.column else LayoutGridDimension.column)
if css_size_is_length(&preferred_size_in_opposite_axis):
let length = css_size_length(&preferred_size_in_opposite_axis)
let opposite_axis_size = css_length_to_px_layout_node(&length, item.box.layout_node())
# FIXME: Clamp by opposite-axis minimum and maximum sizes if they are definite
return opposite_axis_size.mul_fraction(preferred_aspect_ratio)
return none
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2713 Web::Layout::GridFormattingContext::content_based_minimum_size.
func layout_grid_formatting_context_content_based_minimum_size(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
# https://www.w3.org/TR/css-grid-1/#content-based-minimum-size
var result = layout_zero_px()
# The content-based minimum size for a grid item in a given dimension is its specified size suggestion if it exists,
if let specified_size_suggestion = layout_grid_formatting_context_specified_size_suggestion(this, item, dimension):
result = specified_size_suggestion
# otherwise its transferred size suggestion if that exists,
elif let transferred_size_suggestion = layout_grid_formatting_context_transferred_size_suggestion(this, item, dimension):
result = transferred_size_suggestion
# else its content size suggestion.
else:
result = layout_grid_formatting_context_content_size_suggestion(this, item, dimension)
# However, if in a given dimension the grid item spans only grid tracks that have a fixed max track sizing function, then
# its specified size suggestion and content size suggestion in that dimension (and its input from this dimension to the
# transferred size suggestion in the opposite dimension) are further clamped to less than or equal to the stretch fit into
# the grid area’s maximum size in that dimension, as represented by the sum of those grid tracks’ max track sizing functions
# plus any intervening fixed gutters.
# FIXME: Account for intervening fixed gutters.
let tracks = layout_grid_formatting_context_tracks(this, dimension)
let available_size = layout_grid_formatting_context_available_size(this, dimension)
let available_width = layout_grid_formatting_context_available_space(this).width
let item_track_index = layout_grid_item_raw_position(item, dimension)
let item_track_span = layout_grid_item_span(item, dimension)
var spans_only_tracks_with_limited_max_track_sizing_function = true
var sum_of_max_sizing_functions = layout_zero_px()
for index in 0..<item_track_span:
# `item_track_index + index`: int + size_t.
let track = ak.vector_at(tracks, (usize)(i64)item_track_index +% index)
if not css_grid_size_is_fixed(&track.max_track_sizing_function, available_size):
spans_only_tracks_with_limited_max_track_sizing_function = false
break
let max_css_size = css_grid_size_css_size(&track.max_track_sizing_function)
sum_of_max_sizing_functions = sum_of_max_sizing_functions.add(css_size_to_px(&max_css_size, item.box.layout_node(), layout_available_size_to_px_or_zero(&available_width)))
if spans_only_tracks_with_limited_max_track_sizing_function:
result = ak.min(result, sum_of_max_sizing_functions)
# In all cases, the size suggestion is additionally clamped by the maximum size in the affected axis, if it’s definite.
let maximum_size = layout_grid_item_maximum_size(item, dimension)
if css_size_is_length(&maximum_size):
let length = css_size_length(&maximum_size)
let maximum_size_px = css_length_to_px_layout_node(&length, item.box.layout_node())
result = ak.min(result, maximum_size_px)
# If the item is a compressible replaced element, and has a definite preferred size or maximum size in the relevant axis,
# the size suggestion is capped by those sizes; for this purpose, any indefinite percentages in these sizes are resolved
# against zero (and considered definite).
# FIXME: "compressible replaced element" includes more elements than is_replaced_box().
let preferred_size = layout_grid_item_preferred_size(item, dimension)
if layout_node_is_replaced_box(item.box.layout_node()) and (css_size_is_percentage(&preferred_size) or css_size_is_percentage(&maximum_size)):
# NOTE: Implements "for this purpose, any indefinite percentages in these sizes are resolved
# against zero (and considered definite)." part.
result = layout_zero_px()
return result
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2776 Web::Layout::GridFormattingContext::automatic_minimum_size.
func layout_grid_formatting_context_automatic_minimum_size(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
# To provide a more reasonable default minimum size for grid items, the used value of its automatic minimum size
# in a given axis is the content-based minimum size if all of the following are true:
# - it is not a scroll container
# - it spans at least one track in that axis whose min track sizing function is auto
# - if it spans more than one track in that axis, none of those tracks are flexible
let tracks = layout_grid_formatting_context_tracks(this, dimension)
let item_track_index = layout_grid_item_raw_position(item, dimension)
let item_track_span = layout_grid_item_span(item, dimension)
let available_size = layout_grid_formatting_context_available_size(this, dimension)
var spans_auto_tracks = false
var spans_flexible_tracks = false
for index in 0..<item_track_span:
let track = ak.vector_at(tracks, (usize)(i64)item_track_index +% index)
if css_grid_size_is_flexible_length(&track.max_track_sizing_function):
spans_flexible_tracks = true
if css_grid_size_is_auto(&track.min_track_sizing_function, available_size):
spans_auto_tracks = true
if spans_auto_tracks and not layout_node_with_style_is_scroll_container(item.box.layout_node_with_style()) and (item_track_span == 1 or not spans_flexible_tracks):
return layout_grid_formatting_context_content_based_minimum_size(this, item, dimension)
# Otherwise, the automatic minimum size is zero, as usual.
return layout_zero_px()
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2806 Web::Layout::GridFormattingContext::calculate_minimum_contribution.
func layout_grid_formatting_context_calculate_minimum_contribution(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
# The minimum contribution of an item is the smallest outer size it can have.
# Specifically, if the item’s computed preferred size behaves as auto or depends on the size of its
# containing block in the relevant axis, its minimum contribution is the outer size that would
# result from assuming the item’s used minimum size as its preferred size; else the item’s minimum
# contribution is its min-content contribution. Because the minimum contribution often depends on
# the size of the item’s content, it is considered a type of intrinsic size contribution.
let base = this.layout_formatting_context()
# (The C++ copies the preferred size into a local it never reads.)
let should_treat_preferred_size_as_auto = layout_grid_formatting_context_should_treat_preferred_size_as_auto(this, item, dimension, layout_grid_item_available_space(item))
if should_treat_preferred_size_as_auto:
let minimum_size = layout_grid_item_minimum_size(item, dimension)
if css_size_is_auto(&minimum_size):
return layout_grid_item_add_margin_box_sizes(item, layout_grid_formatting_context_automatic_minimum_size(this, item, dimension), dimension)
if css_size_is_min_content(&minimum_size):
return layout_grid_formatting_context_calculate_min_content_contribution(this, item, dimension)
if css_size_is_max_content(&minimum_size):
return layout_grid_formatting_context_calculate_max_content_contribution(this, item, dimension)
var inner_minimum_size: gfx.CssPixels
let item_available_space = layout_grid_item_available_space(item)
if dimension == LayoutGridDimension.column:
inner_minimum_size = layout_formatting_context_calculate_inner_width(base, item.box, item_available_space.width, minimum_size)
else:
inner_minimum_size = layout_formatting_context_calculate_inner_height(base, item.box, item_available_space, minimum_size)
return layout_grid_item_add_margin_box_sizes(item, inner_minimum_size, dimension)
return layout_grid_formatting_context_calculate_min_content_contribution(this, item, dimension)
# mark: Static position =========================================================================
## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2841 Web::Layout::GridFormattingContext::calculate_static_position_rect.
pub func layout_grid_formatting_context_calculate_static_position_rect(this: LayoutGridFormattingContext*, box: LayoutBox*) -> LayoutStaticPositionRect:
# Result of this function is only used when containing block is not a grid container.
# If the containing block is a grid container then static position is a grid area rect and
# layout_absolutely_positioned_element() defined for GFC knows how to handle this case.
var static_position = LayoutStaticPositionRect(rect = gfx.CssPixelRect(), horizontal_alignment = LayoutStaticPositionRectAlignment.start, vertical_alignment = LayoutStaticPositionRectAlignment.start)
let box_state = layout_state_get(this.formatting_context.m_state, box.layout_node_with_style())
static_position.rect = gfx.CssPixelRect(m_location = gfx.CssPixelPoint(m_x = layout_zero_px(), m_y = layout_zero_px()), m_size = gfx.CssPixelSize(m_width = layout_state_used_values_content_width(box_state), m_height = layout_state_used_values_content_height(box_state)))
return static_position