dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / layout / flex_formatting_context_6.lucb
#==============================================================================================
#
# flex_formatting_context_6 - Layout::FlexFormattingContext: automatic sizes, cross-size
# contributions, intrinsic item sizes and static positions
#
# DESCRIPTION:
# Port of LibWeb/Layout/FlexFormattingContext.cpp (lines 2070-2449): when main/cross sizes
# are treated as auto and max sizes as none, the cross-size min/max-content contributions
# of an item, the width used to find an item's intrinsic height, the intrinsic and
# fit-content main and cross sizes of an item, stretched items, the computed main and
# cross sizes, cross-axis auto margins, align-content: stretch, the static-position
# rectangle of an absolutely positioned child, a flex line's sums of flex factors, and
# the main and cross gaps.
#
# Copyright (c) 2021-2025, Andreas Kling <andreas@ladybird.org>
# Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
# Copyright (c) 2025, Jelle Raaijmakers <jelle@ladybird.org>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: Auto sizes and max sizes as none ========================================================
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2070 Web::Layout::FlexFormattingContext::should_treat_main_size_as_auto.
func layout_flex_formatting_context_should_treat_main_size_as_auto(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> bool:
let space = layout_flex_formatting_context_available_space_for_items(this).space
if layout_flex_formatting_context_main_axis_is_horizontal(this):
return layout_formatting_context_should_treat_width_as_auto(this.layout_formatting_context(), box, space)
return layout_formatting_context_should_treat_height_as_auto(this.layout_formatting_context(), box, space)
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2077 Web::Layout::FlexFormattingContext::should_treat_cross_size_as_auto.
func layout_flex_formatting_context_should_treat_cross_size_as_auto(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> bool:
let space = layout_flex_formatting_context_available_space_for_items(this).space
if layout_flex_formatting_context_cross_axis_is_horizontal(this):
return layout_formatting_context_should_treat_width_as_auto(this.layout_formatting_context(), box, space)
return layout_formatting_context_should_treat_height_as_auto(this.layout_formatting_context(), box, space)
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2084 Web::Layout::FlexFormattingContext::should_treat_main_max_size_as_none.
func layout_flex_formatting_context_should_treat_main_max_size_as_none(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> bool:
let space = layout_flex_formatting_context_available_space_for_items(this).space
if layout_flex_formatting_context_main_axis_is_horizontal(this):
return layout_formatting_context_should_treat_max_width_as_none(this.layout_formatting_context(), box, space.width)
return layout_formatting_context_should_treat_max_height_as_none(this.layout_formatting_context(), box, space.height)
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2091 Web::Layout::FlexFormattingContext::should_treat_cross_max_size_as_none.
func layout_flex_formatting_context_should_treat_cross_max_size_as_none(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> bool:
let space = layout_flex_formatting_context_available_space_for_items(this).space
if layout_flex_formatting_context_cross_axis_is_horizontal(this):
return layout_formatting_context_should_treat_max_width_as_none(this.layout_formatting_context(), box, space.width)
return layout_formatting_context_should_treat_max_height_as_none(this.layout_formatting_context(), box, space.height)
# mark: Cross-size contributions of an item =====================================================
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2098 Web::Layout::FlexFormattingContext::calculate_cross_min_content_contribution.
func layout_flex_formatting_context_calculate_cross_min_content_contribution(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*, resolve_percentage_min_max_sizes: bool) -> gfx.CssPixels:
let cross_size_auto = layout_flex_formatting_context_should_treat_cross_size_as_auto(this, item.box)
var size: gfx.CssPixels
if cross_size_auto:
size = layout_flex_formatting_context_calculate_min_content_cross_size(this, item)
elif layout_flex_formatting_context_cross_axis_is_horizontal(this):
size = layout_flex_formatting_context_get_pixel_width(this, item, layout_flex_formatting_context_computed_cross_size(this, item.box))
else:
size = layout_flex_formatting_context_get_pixel_height(this, item, layout_flex_formatting_context_computed_cross_size(this, item.box))
if cross_size_auto and layout_box_has_preferred_aspect_ratio(item.box):
size = layout_flex_formatting_context_adjust_cross_size_through_aspect_ratio_for_main_size_min_max_constraints(this, item.box, size, layout_flex_formatting_context_computed_main_min_size(this, item.box), layout_flex_formatting_context_computed_main_max_size(this, item.box))
let computed_min_size = layout_flex_formatting_context_computed_cross_min_size(this, item.box)
let computed_max_size = layout_flex_formatting_context_computed_cross_max_size(this, item.box)
let clamp_min = layout_flex_formatting_context_specified_cross_min_size(this, item) if (not css_size_is_auto(&computed_min_size) and (resolve_percentage_min_max_sizes or not css_size_contains_percentage(&computed_min_size))) else layout_zero_px()
let clamp_max = layout_flex_formatting_context_specified_cross_max_size(this, item) if (not layout_flex_formatting_context_should_treat_cross_max_size_as_none(this, item.box) and (resolve_percentage_min_max_sizes or not css_size_contains_percentage(&computed_max_size))) else gfx.css_pixels_max()
let clamped_inner_size = layout_css_clamp(size, clamp_min, clamp_max)
return layout_flex_formatting_context_flex_item_add_cross_margin_box_sizes(item, clamped_inner_size)
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2121 Web::Layout::FlexFormattingContext::calculate_cross_max_content_contribution.
func layout_flex_formatting_context_calculate_cross_max_content_contribution(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*, resolve_percentage_min_max_sizes: bool) -> gfx.CssPixels:
let cross_size_auto = layout_flex_formatting_context_should_treat_cross_size_as_auto(this, item.box)
var size: gfx.CssPixels
if cross_size_auto:
size = layout_flex_formatting_context_calculate_max_content_cross_size(this, item)
elif layout_flex_formatting_context_cross_axis_is_horizontal(this):
size = layout_flex_formatting_context_get_pixel_width(this, item, layout_flex_formatting_context_computed_cross_size(this, item.box))
else:
size = layout_flex_formatting_context_get_pixel_height(this, item, layout_flex_formatting_context_computed_cross_size(this, item.box))
if cross_size_auto and layout_box_has_preferred_aspect_ratio(item.box):
size = layout_flex_formatting_context_adjust_cross_size_through_aspect_ratio_for_main_size_min_max_constraints(this, item.box, size, layout_flex_formatting_context_computed_main_min_size(this, item.box), layout_flex_formatting_context_computed_main_max_size(this, item.box))
let computed_min_size = layout_flex_formatting_context_computed_cross_min_size(this, item.box)
let computed_max_size = layout_flex_formatting_context_computed_cross_max_size(this, item.box)
let clamp_min = layout_flex_formatting_context_specified_cross_min_size(this, item) if (not css_size_is_auto(&computed_min_size) and (resolve_percentage_min_max_sizes or not css_size_contains_percentage(&computed_min_size))) else layout_zero_px()
let clamp_max = layout_flex_formatting_context_specified_cross_max_size(this, item) if (not layout_flex_formatting_context_should_treat_cross_max_size_as_none(this, item.box) and (resolve_percentage_min_max_sizes or not css_size_contains_percentage(&computed_max_size))) else gfx.css_pixels_max()
let clamped_inner_size = layout_css_clamp(size, clamp_min, clamp_max)
return layout_flex_formatting_context_flex_item_add_cross_margin_box_sizes(item, clamped_inner_size)
# mark: Intrinsic sizes of an item ==============================================================
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2144 Web::Layout::FlexFormattingContext::calculate_width_to_use_when_determining_intrinsic_height_of_item.
func layout_flex_formatting_context_calculate_width_to_use_when_determining_intrinsic_height_of_item(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
let box = item.box
let base = this.layout_formatting_context()
let computed_values = layout_box_computed(box)
let computed_width = css_computed_values_width(computed_values)
let computed_min_width = css_computed_values_min_width(computed_values)
let computed_max_width = css_computed_values_max_width(computed_values)
let space = layout_flex_formatting_context_available_space_for_items(this).space
# We can resolve percentage min/max-width if the available width is definite.
let can_resolve_percentages = layout_available_size_is_definite(&space.width)
let clamp_min = layout_flex_formatting_context_get_pixel_width(this, item, computed_min_width) if (not css_size_is_auto(&computed_min_width) and (not css_size_contains_percentage(&computed_min_width) or can_resolve_percentages)) else layout_zero_px()
let clamp_max = layout_flex_formatting_context_get_pixel_width(this, item, computed_max_width) if (not layout_formatting_context_should_treat_max_width_as_none(base, box, space.width) and (not css_size_contains_percentage(&computed_max_width) or can_resolve_percentages)) else gfx.css_pixels_max()
var width: gfx.CssPixels
if layout_formatting_context_should_treat_width_as_auto(base, box, space) or css_size_is_fit_content(&computed_width):
width = layout_formatting_context_calculate_fit_content_width(base, box, space)
elif css_size_is_min_content(&computed_width):
width = layout_formatting_context_calculate_min_content_width(base, box)
elif css_size_is_max_content(&computed_width):
width = layout_formatting_context_calculate_max_content_width(base, box)
return layout_css_clamp(width, clamp_min, clamp_max)
## `item.used_values.available_inner_space_or_constraints_from(m_available_space_for_items->space)` with an indefinite
## width replaced by the width to use when determining the item's intrinsic height (the common part of
## calculate_{min,max}_content_{main,cross}_size when the size is a height).
func layout_flex_formatting_context_available_space_for_intrinsic_height(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> LayoutAvailableSpace:
var available_space = layout_state_used_values_available_inner_space_or_constraints_from(item.used_values, layout_flex_formatting_context_available_space_for_items(this).space)
if layout_available_size_is_indefinite(&available_space.width):
available_space.width = layout_available_size_make_definite(layout_flex_formatting_context_calculate_width_to_use_when_determining_intrinsic_height_of_item(this, item))
return available_space
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2168 Web::Layout::FlexFormattingContext::calculate_min_content_main_size.
func layout_flex_formatting_context_calculate_min_content_main_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
if layout_flex_formatting_context_main_axis_is_horizontal(this):
return layout_formatting_context_calculate_min_content_width(this.layout_formatting_context(), item.box)
let available_space = layout_flex_formatting_context_available_space_for_intrinsic_height(this, item)
return layout_formatting_context_calculate_min_content_height(this.layout_formatting_context(), item.box, layout_available_size_to_px_or_zero(&available_space.width))
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2180 Web::Layout::FlexFormattingContext::calculate_max_content_main_size.
func layout_flex_formatting_context_calculate_max_content_main_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
if layout_flex_formatting_context_main_axis_is_horizontal(this):
return layout_formatting_context_calculate_max_content_width(this.layout_formatting_context(), item.box)
let available_space = layout_flex_formatting_context_available_space_for_intrinsic_height(this, item)
return layout_formatting_context_calculate_max_content_height(this.layout_formatting_context(), item.box, layout_available_size_to_px_or_zero(&available_space.width))
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2192 Web::Layout::FlexFormattingContext::calculate_fit_content_main_size.
func layout_flex_formatting_context_calculate_fit_content_main_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
let space = layout_flex_formatting_context_available_space_for_items(this).space
if layout_flex_formatting_context_main_axis_is_horizontal(this):
return layout_formatting_context_calculate_fit_content_width(this.layout_formatting_context(), item.box, space)
return layout_formatting_context_calculate_fit_content_height(this.layout_formatting_context(), item.box, space)
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2199 Web::Layout::FlexFormattingContext::calculate_fit_content_cross_size.
pub func layout_flex_formatting_context_calculate_fit_content_cross_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
let space = layout_flex_formatting_context_available_space_for_items(this).space
if layout_flex_formatting_context_cross_axis_is_horizontal(this):
return layout_formatting_context_calculate_fit_content_width(this.layout_formatting_context(), item.box, space)
return layout_formatting_context_calculate_fit_content_height(this.layout_formatting_context(), item.box, space)
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2206 Web::Layout::FlexFormattingContext::calculate_min_content_cross_size.
func layout_flex_formatting_context_calculate_min_content_cross_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
if not layout_flex_formatting_context_cross_axis_is_horizontal(this):
let available_space = layout_flex_formatting_context_available_space_for_intrinsic_height(this, item)
return layout_formatting_context_calculate_min_content_height(this.layout_formatting_context(), item.box, layout_available_size_to_px_or_zero(&available_space.width))
return layout_formatting_context_calculate_min_content_width(this.layout_formatting_context(), item.box)
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2218 Web::Layout::FlexFormattingContext::calculate_max_content_cross_size.
func layout_flex_formatting_context_calculate_max_content_cross_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
if not layout_flex_formatting_context_cross_axis_is_horizontal(this):
let available_space = layout_flex_formatting_context_available_space_for_intrinsic_height(this, item)
return layout_formatting_context_calculate_max_content_height(this.layout_formatting_context(), item.box, layout_available_size_to_px_or_zero(&available_space.width))
return layout_formatting_context_calculate_max_content_width(this.layout_formatting_context(), item.box)
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2231 Web::Layout::FlexFormattingContext::flex_item_is_stretched.
# https://drafts.csswg.org/css-flexbox-1/#stretched
func layout_flex_formatting_context_flex_item_is_stretched(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> bool:
let alignment = layout_flex_formatting_context_alignment_for_item(this, item.box)
if alignment != css_data.AlignItems.stretch and alignment != css_data.AlignItems.normal:
return false
# If the cross size property of the flex item computes to auto, and neither of the cross-axis margins are auto, the flex item is stretched.
let computed_cross_size = layout_flex_formatting_context_computed_cross_size(this, item.box)
return css_size_is_auto(&computed_cross_size) and not item.margins.cross_before_is_auto and not item.margins.cross_after_is_auto
# mark: Computed sizes ==========================================================================
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2241 Web::Layout::FlexFormattingContext::computed_main_size.
func layout_flex_formatting_context_computed_main_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> CssSize:
return css_computed_values_width(layout_box_computed(box)) if layout_flex_formatting_context_main_axis_is_horizontal(this) else css_computed_values_height(layout_box_computed(box))
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2246 Web::Layout::FlexFormattingContext::computed_main_min_size.
func layout_flex_formatting_context_computed_main_min_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> CssSize:
return css_computed_values_min_width(layout_box_computed(box)) if layout_flex_formatting_context_main_axis_is_horizontal(this) else css_computed_values_min_height(layout_box_computed(box))
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2251 Web::Layout::FlexFormattingContext::computed_main_max_size.
func layout_flex_formatting_context_computed_main_max_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> CssSize:
return css_computed_values_max_width(layout_box_computed(box)) if layout_flex_formatting_context_main_axis_is_horizontal(this) else css_computed_values_max_height(layout_box_computed(box))
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2256 Web::Layout::FlexFormattingContext::computed_cross_size.
func layout_flex_formatting_context_computed_cross_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> CssSize:
return css_computed_values_width(layout_box_computed(box)) if layout_flex_formatting_context_cross_axis_is_horizontal(this) else css_computed_values_height(layout_box_computed(box))
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2261 Web::Layout::FlexFormattingContext::computed_cross_min_size.
func layout_flex_formatting_context_computed_cross_min_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> CssSize:
return css_computed_values_min_width(layout_box_computed(box)) if layout_flex_formatting_context_cross_axis_is_horizontal(this) else css_computed_values_min_height(layout_box_computed(box))
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2266 Web::Layout::FlexFormattingContext::computed_cross_max_size.
func layout_flex_formatting_context_computed_cross_max_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> CssSize:
return css_computed_values_max_width(layout_box_computed(box)) if layout_flex_formatting_context_cross_axis_is_horizontal(this) else css_computed_values_max_height(layout_box_computed(box))
# mark: Cross-axis auto margins and align-content: stretch ======================================
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2272 Web::Layout::FlexFormattingContext::resolve_cross_axis_auto_margins.
# https://drafts.csswg.org/css-flexbox-1/#algo-cross-margins
func layout_flex_formatting_context_resolve_cross_axis_auto_margins(this: LayoutFlexFormattingContext*):
let lines = ak.vector_span(&this.m_flex_lines)
for line in &lines:
for item in ak.vector_span(&line.items):
# If a flex item has auto cross-axis margins:
if not item.margins.cross_before_is_auto and not item.margins.cross_after_is_auto:
continue
# If its outer cross size (treating those auto margins as zero) is less than the cross size of its flex line,
# distribute the difference in those sizes equally to the auto margins.
# NB: Auto cross-axis margins are stored as 0, so including them here treats them as zero while keeping
# non-auto cross-axis margins in the outer cross size.
let cross_size = item.cross_size else trap("VERIFY: the item's cross size is determined")
let outer_cross_size = cross_size.add(item.padding.cross_before).add(item.padding.cross_after).add(item.borders.cross_before).add(item.borders.cross_after).add(item.margins.cross_before).add(item.margins.cross_after)
if outer_cross_size.lt(line.cross_size):
let remainder = line.cross_size.sub(outer_cross_size)
if item.margins.cross_before_is_auto and item.margins.cross_after_is_auto:
item.margins.cross_before = layout_div_int(remainder, 2)
item.margins.cross_after = layout_div_int(remainder, 2)
elif item.margins.cross_before_is_auto:
item.margins.cross_before = remainder
else:
item.margins.cross_after = remainder
else:
# FIXME: Otherwise, if the block-start or inline-start margin (whichever is in the cross axis) is auto, set it to zero.
# Set the opposite margin so that the outer cross size of the item equals the cross size of its flex line.
_ = 0
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2308 Web::Layout::FlexFormattingContext::handle_align_content_stretch.
# https://drafts.csswg.org/css-flexbox-1/#algo-line-stretch
func layout_flex_formatting_context_handle_align_content_stretch(this: LayoutFlexFormattingContext*):
# If the flex container has a definite cross size,
if not layout_flex_formatting_context_has_definite_cross_size_layout_state_used_values(this, this.m_flex_container_state):
return
# align-content is stretch,
let align_content = css_computed_values_align_content(layout_box_computed(layout_flex_formatting_context_flex_container(this)))
if align_content != css_data.AlignContent.stretch and align_content != css_data.AlignContent.normal:
return
# and the sum of the flex lines' cross sizes is less than the flex container’s inner cross size,
let lines = ak.vector_span(&this.m_flex_lines)
var sum_of_flex_line_cross_sizes = layout_zero_px()
for summed_line in lines:
sum_of_flex_line_cross_sizes = sum_of_flex_line_cross_sizes.add(summed_line.cross_size)
# CSS-FLEXBOX-2: Account for gap between flex lines.
sum_of_flex_line_cross_sizes = sum_of_flex_line_cross_sizes.add(layout_flex_formatting_context_mul_count(layout_flex_formatting_context_cross_gap(this), lines.length -% 1))
if sum_of_flex_line_cross_sizes.ge(layout_flex_formatting_context_inner_cross_size_layout_state_used_values(this, this.m_flex_container_state)):
return
# increase the cross size of each flex line by equal amounts
# such that the sum of their cross sizes exactly equals the flex container’s inner cross size.
let remainder = layout_flex_formatting_context_inner_cross_size_layout_state_used_values(this, this.m_flex_container_state).sub(sum_of_flex_line_cross_sizes)
let extra_per_line = layout_div_int(remainder, (i64)lines.length)
for line in &lines:
line.cross_size = line.cross_size.add(extra_per_line)
# mark: Absolutely positioned children ==========================================================
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2339 Web::Layout::FlexFormattingContext::calculate_static_position_rect.
# https://drafts.csswg.org/css-flexbox-1/#abspos-items
pub func layout_flex_formatting_context_calculate_static_position_rect(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> LayoutStaticPositionRect:
# The cross-axis edges of the static-position rectangle of an absolutely-positioned child
# of a flex container are the content edges of the flex container.
var cross_axis_alignment = LayoutStaticPositionRectAlignment.start
match layout_flex_formatting_context_alignment_for_item(this, box):
.baseline, .flex_start, .stretch, .normal:
# (Baseline:) FIXME: Implement this
# Fallthrough
cross_axis_alignment = LayoutStaticPositionRectAlignment.end if layout_flex_formatting_context_cross_axis_is_reverse(this) else LayoutStaticPositionRectAlignment.start
.flex_end:
cross_axis_alignment = LayoutStaticPositionRectAlignment.start if layout_flex_formatting_context_cross_axis_is_reverse(this) else LayoutStaticPositionRectAlignment.end
.start, .self_start:
cross_axis_alignment = LayoutStaticPositionRectAlignment.start
.end, .self_end:
cross_axis_alignment = LayoutStaticPositionRectAlignment.end
.center:
cross_axis_alignment = LayoutStaticPositionRectAlignment.center
_:
_ = 0
# The main-axis edges of the static-position rectangle are where the margin edges of the child
# would be positioned if it were the sole flex item in the flex container,
# assuming both the child and the flex container were fixed-size boxes of their used size.
# (For this purpose, auto margins are treated as zero.
var main_axis_alignment = LayoutStaticPositionRectAlignment.start
match css_computed_values_justify_content(layout_box_computed(layout_flex_formatting_context_flex_container(this))):
.start, .left:
main_axis_alignment = LayoutStaticPositionRectAlignment.start
.stretch, .normal, .flex_start, .space_between:
main_axis_alignment = LayoutStaticPositionRectAlignment.end if layout_flex_formatting_context_is_direction_reverse(this) else LayoutStaticPositionRectAlignment.start
.end:
main_axis_alignment = LayoutStaticPositionRectAlignment.end
.right:
main_axis_alignment = LayoutStaticPositionRectAlignment.end
.flex_end:
main_axis_alignment = LayoutStaticPositionRectAlignment.end if not layout_flex_formatting_context_is_direction_reverse(this) else LayoutStaticPositionRectAlignment.start
.center, .space_around, .space_evenly:
main_axis_alignment = LayoutStaticPositionRectAlignment.center
_:
# The C++ switch has no default: other values keep Start.
_ = 0
let main_axis_is_horizontal = layout_flex_formatting_context_main_axis_is_horizontal(this)
let flex_container_width = layout_flex_formatting_context_inner_main_size_layout_state_used_values(this, this.m_flex_container_state) if main_axis_is_horizontal else layout_flex_formatting_context_inner_cross_size_layout_state_used_values(this, this.m_flex_container_state)
let flex_container_height = layout_flex_formatting_context_inner_cross_size_layout_state_used_values(this, this.m_flex_container_state) if main_axis_is_horizontal else layout_flex_formatting_context_inner_main_size_layout_state_used_values(this, this.m_flex_container_state)
var static_position_rect = LayoutStaticPositionRect()
static_position_rect.rect = gfx.CssPixelRect(gfx.CssPixelPoint(layout_zero_px(), layout_zero_px()), gfx.CssPixelSize(flex_container_width, flex_container_height))
static_position_rect.horizontal_alignment = main_axis_alignment if main_axis_is_horizontal else cross_axis_alignment
static_position_rect.vertical_alignment = cross_axis_alignment if main_axis_is_horizontal else main_axis_alignment
return static_position_rect
# mark: Flex lines and gaps =====================================================================
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2415 Web::Layout::FlexFormattingContext::FlexLine::sum_of_flex_factor_of_unfrozen_items.
func layout_flex_formatting_context_flex_line_sum_of_flex_factor_of_unfrozen_items(this: const LayoutFlexFormattingContextFlexLine*) -> f64:
var sum = 0.0
for item in ak.vector_span_const(&this.items):
if not item.frozen:
sum += item.flex_factor else trap("VERIFY: the item has a flex factor")
return sum
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2425 Web::Layout::FlexFormattingContext::FlexLine::sum_of_scaled_flex_shrink_factor_of_unfrozen_items.
func layout_flex_formatting_context_flex_line_sum_of_scaled_flex_shrink_factor_of_unfrozen_items(this: const LayoutFlexFormattingContextFlexLine*) -> f64:
var sum = 0.0
for item in ak.vector_span_const(&this.items):
if not item.frozen:
sum += item.scaled_flex_shrink_factor
return sum
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2435 Web::Layout::FlexFormattingContext::main_gap.
func layout_flex_formatting_context_main_gap(this: LayoutFlexFormattingContext*) -> gfx.CssPixels:
let computed_values = layout_box_computed(layout_flex_formatting_context_flex_container(this))
let gap = css_computed_values_column_gap(computed_values) if layout_flex_formatting_context_is_row_layout(this) else css_computed_values_row_gap(computed_values)
return layout_formatting_context_gap_to_px(this.layout_formatting_context(), gap, layout_flex_formatting_context_inner_main_size_layout_state_used_values(this, this.m_flex_container_state))
## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2442 Web::Layout::FlexFormattingContext::cross_gap.
func layout_flex_formatting_context_cross_gap(this: LayoutFlexFormattingContext*) -> gfx.CssPixels:
let computed_values = layout_box_computed(layout_flex_formatting_context_flex_container(this))
let gap = css_computed_values_row_gap(computed_values) if layout_flex_formatting_context_is_row_layout(this) else css_computed_values_column_gap(computed_values)
return layout_formatting_context_gap_to_px(this.layout_formatting_context(), gap, layout_flex_formatting_context_inner_cross_size_layout_state_used_values(this, this.m_flex_container_state))