Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / layout / grid_formatting_context_1.lucb

#==============================================================================================
#
#   grid_formatting_context_1 - Layout::GridFormattingContext: grid items, alignment keywords,
#                               grid tracks, construction and repeat() counts
#
#   DESCRIPTION:
#       Port of LibWeb/Layout/GridFormattingContext.cpp (lines 1-269) and the inline members of
#       GridFormattingContext.h: a grid item's spans, positions, sizes and margins in either
#       dimension, the occupation grid's inline members, the context's inline members (the
#       grid container, gaps, flexible tracks, and the traversal of the tracks and gaps an item
#       spans as an iterator), the four to_alignment conversions, the GridTrack factories, the
#       constructor, the size of a definite track and the number of auto-fill / auto-fit
#       repetitions (https://www.w3.org/TR/css-grid-2/#auto-repeat).
#
#       Copyright (c) 2023-2025, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
#       Copyright (c) 2022-2023, Martin Falisse <mfalisse@outlook.com>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: GridItem (GridFormattingContext.h) ======================================================

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:36 Web::Layout::GridItem::span.
pub func layout_grid_item_span(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> usize:
    if dimension == LayoutGridDimension.column:
        return this.column_span else trap("VERIFY: the grid item's column span has a value")
    return this.row_span else trap("VERIFY: the grid item's row span has a value")

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:41 Web::Layout::GridItem::raw_position.
pub func layout_grid_item_raw_position(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> i32:
    if dimension == LayoutGridDimension.column:
        return this.column else trap("VERIFY: the grid item's column has a value")
    return this.row else trap("VERIFY: the grid item's row has a value")

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:46 Web::Layout::GridItem::add_margin_box_sizes.
pub func layout_grid_item_add_margin_box_sizes(this: const LayoutGridItem*, content_size: gfx.CssPixels, dimension: LayoutGridDimension) -> gfx.CssPixels:
    if dimension == LayoutGridDimension.column:
        return layout_state_used_values_margin_box_left(this.used_values).add(content_size).add(layout_state_used_values_margin_box_right(this.used_values))
    return layout_state_used_values_margin_box_top(this.used_values).add(content_size).add(layout_state_used_values_margin_box_bottom(this.used_values))

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:53 Web::Layout::GridItem::gap_adjusted_position.
pub func layout_grid_item_gap_adjusted_position(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> i32:
    if dimension == LayoutGridDimension.column:
        return layout_grid_item_gap_adjusted_column(this)
    return layout_grid_item_gap_adjusted_row(this)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:61 Web::Layout::GridItem::computed_values.
pub func layout_grid_item_computed_values(this: const LayoutGridItem*) -> const CssComputedValues*:
    return layout_box_computed(this.box)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:66 Web::Layout::GridItem::minimum_size.
pub func layout_grid_item_minimum_size(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> CssSize:
    if dimension == LayoutGridDimension.column:
        return css_computed_values_min_width(layout_grid_item_computed_values(this))
    return css_computed_values_min_height(layout_grid_item_computed_values(this))

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:71 Web::Layout::GridItem::maximum_size.
pub func layout_grid_item_maximum_size(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> CssSize:
    if dimension == LayoutGridDimension.column:
        return css_computed_values_max_width(layout_grid_item_computed_values(this))
    return css_computed_values_max_height(layout_grid_item_computed_values(this))

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:76 Web::Layout::GridItem::preferred_size.
pub func layout_grid_item_preferred_size(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> CssSize:
    if dimension == LayoutGridDimension.column:
        return css_computed_values_width(layout_grid_item_computed_values(this))
    return css_computed_values_height(layout_grid_item_computed_values(this))

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:81 Web::Layout::GridItem::margin_start.
pub func layout_grid_item_margin_start(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> CssLengthPercentageOrAuto:
    let margin = css_computed_values_margin(layout_grid_item_computed_values(this))
    if dimension == LayoutGridDimension.column:
        return css_length_box_left_const(&margin)
    return css_length_box_top_const(&margin)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:86 Web::Layout::GridItem::margin_end.
pub func layout_grid_item_margin_end(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> CssLengthPercentageOrAuto:
    let margin = css_computed_values_margin(layout_grid_item_computed_values(this))
    if dimension == LayoutGridDimension.column:
        return css_length_box_right_const(&margin)
    return css_length_box_bottom_const(&margin)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:91 Web::Layout::GridItem::used_margin_box_start.
pub func layout_grid_item_used_margin_box_start(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    if dimension == LayoutGridDimension.column:
        return layout_state_used_values_margin_box_left(this.used_values)
    return layout_state_used_values_margin_box_top(this.used_values)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:96 Web::Layout::GridItem::used_margin_box_end.
pub func layout_grid_item_used_margin_box_end(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    if dimension == LayoutGridDimension.column:
        return layout_state_used_values_margin_box_right(this.used_values)
    return layout_state_used_values_margin_box_bottom(this.used_values)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:101 Web::Layout::GridItem::used_margin_start.
pub func layout_grid_item_used_margin_start(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    if dimension == LayoutGridDimension.column:
        return this.used_values.margin_left
    return this.used_values.margin_top

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:106 Web::Layout::GridItem::used_margin_end.
pub func layout_grid_item_used_margin_end(this: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    if dimension == LayoutGridDimension.column:
        return this.used_values.margin_right
    return this.used_values.margin_bottom

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:111 Web::Layout::GridItem::available_space.
pub func layout_grid_item_available_space(this: const LayoutGridItem*) -> LayoutAvailableSpace:
    let available_width = layout_available_size_make_definite(layout_state_used_values_content_width(this.used_values)) if layout_state_used_values_has_definite_width(this.used_values) else layout_available_size_make_indefinite()
    let available_height = layout_available_size_make_definite(layout_state_used_values_content_height(this.used_values)) if layout_state_used_values_has_definite_height(this.used_values) else layout_available_size_make_indefinite()
    return LayoutAvailableSpace(width = available_width, height = available_height)

# mark: OccupationGrid (GridFormattingContext.h) ================================================

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:126 Web::Layout::OccupationGrid::OccupationGrid.
pub func layout_occupation_grid_construct_usize(this: LayoutOccupationGrid*, columns_count: usize, rows_count: usize):
    layout_occupation_grid_construct(this)
    # `max(0, columns_count - 1)` is AK::max<int>: the size_t difference is converted to int.
    this.m_max_column_index = ak.max[i32](0, (i32)(columns_count -% 1))
    this.m_max_row_index = ak.max[i32](0, (i32)(rows_count -% 1))

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:131 Web::Layout::OccupationGrid::OccupationGrid.
pub func layout_occupation_grid_construct(this: LayoutOccupationGrid*):
    this.m_occupation_grid = ak.HashTable[LayoutGridPosition, LayoutGridPositionTraits]()
    this.m_min_column_index = 0
    this.m_max_column_index = 0
    this.m_min_row_index = 0
    this.m_max_row_index = 0

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:135 Web::Layout::OccupationGrid::column_count.
pub func layout_occupation_grid_column_count(this: const LayoutOccupationGrid*) -> usize:
    return (usize)(i64)(ak.abs_i32(this.m_min_column_index) + this.m_max_column_index + 1)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:140 Web::Layout::OccupationGrid::row_count.
pub func layout_occupation_grid_row_count(this: const LayoutOccupationGrid*) -> usize:
    return (usize)(i64)(ak.abs_i32(this.m_min_row_index) + this.m_max_row_index + 1)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:145 Web::Layout::OccupationGrid::set_max_column_index.
pub func layout_occupation_grid_set_max_column_index(this: LayoutOccupationGrid*, max_column_index: usize):
    this.m_max_column_index = (i32)max_column_index

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:147 Web::Layout::OccupationGrid::min_column_index.
pub func layout_occupation_grid_min_column_index(this: const LayoutOccupationGrid*) -> i32:
    return this.m_min_column_index

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:148 Web::Layout::OccupationGrid::max_column_index.
pub func layout_occupation_grid_max_column_index(this: const LayoutOccupationGrid*) -> i32:
    return this.m_max_column_index

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:149 Web::Layout::OccupationGrid::min_row_index.
pub func layout_occupation_grid_min_row_index(this: const LayoutOccupationGrid*) -> i32:
    return this.m_min_row_index

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:150 Web::Layout::OccupationGrid::max_row_index.
pub func layout_occupation_grid_max_row_index(this: const LayoutOccupationGrid*) -> i32:
    return this.m_max_row_index

# mark: GridFormattingContext's inline members (GridFormattingContext.h) ========================

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:171 Web::Layout::GridFormattingContext::inhibits_floating (override).
pub func layout_grid_formatting_context_inhibits_floating_impl(base: LayoutFormattingContext*) -> bool:
    _ = base
    return true

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:178 Web::Layout::GridFormattingContext::grid_container.
pub func layout_grid_formatting_context_grid_container(this: LayoutGridFormattingContext*) -> LayoutBox*:
    return layout_formatting_context_context_box(this.layout_formatting_context())

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:220 Web::Layout::GridFormattingContext::has_gaps.
func layout_grid_formatting_context_has_gaps(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension) -> bool:
    let computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
    let gap = css_computed_values_column_gap(computed_values) if dimension == LayoutGridDimension.column else css_computed_values_row_gap(computed_values)
    match gap:
        .css_normal_gap(_): return false
        _: return true

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:230 Web::Layout::GridFormattingContext::for_each_spanned_track_by_item:
## `for track in layout_grid_formatting_context_for_each_spanned_track_by_item(this, item, dimension)` visits each
## track the item spans, each followed by the gap after it unless it is the last spanned track (DESIGN.md §2.9).
func layout_grid_formatting_context_for_each_spanned_track_by_item(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> LayoutGridFormattingContextSpannedTracks:
    let tracks = &this.m_grid_columns if dimension == LayoutGridDimension.column else &this.m_grid_rows
    let gaps = &this.m_column_gap_tracks if dimension == LayoutGridDimension.column else &this.m_row_gap_tracks
    let has_gaps = layout_grid_formatting_context_has_gaps(this, dimension)
    let item_span = layout_grid_item_span(item, dimension)
    let item_index = layout_grid_item_raw_position(item, dimension)
    return LayoutGridFormattingContextSpannedTracks(tracks = tracks, gaps = gaps, has_gaps = has_gaps, item_span = item_span, item_index = item_index)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:254 Web::Layout::GridFormattingContext::for_each_spanned_track_by_item
## (the const overload, the same traversal).
func layout_grid_formatting_context_for_each_spanned_track_by_item_const(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> LayoutGridFormattingContextSpannedTracks:
    return layout_grid_formatting_context_for_each_spanned_track_by_item(this, item, dimension)

## The tracks and gaps a grid item spans, as an iterable (for_each_spanned_track_by_item's loop).
pub struct LayoutGridFormattingContextSpannedTracks: luce.Iterable[LayoutGridFormattingContextGridTrack*, LayoutGridFormattingContextSpannedTrackIterator]:
    pub var tracks: ak.Vector[LayoutGridFormattingContextGridTrack]*
    pub var gaps: ak.Vector[LayoutGridFormattingContextGridTrack]*
    pub var has_gaps: bool
    pub var item_span: usize
    pub var item_index: i32

    func iterator() -> LayoutGridFormattingContextSpannedTrackIterator:
        return LayoutGridFormattingContextSpannedTrackIterator(spanned = self, span = 0, pending_gap_index = none)

## The iterator of LayoutGridFormattingContextSpannedTracks: `callback(track)` for each spanned track, then
## `callback(gap)` for the gap that follows it.
pub struct LayoutGridFormattingContextSpannedTrackIterator: luce.Iterator[LayoutGridFormattingContextGridTrack*]:
    pub var spanned: LayoutGridFormattingContextSpannedTracks
    pub var span: usize
    pub var pending_gap_index: usize?

    func next() -> LayoutGridFormattingContextGridTrack*?:
        if let gap_index = self.pending_gap_index:
            self.pending_gap_index = none
            return ak.vector_at(self.spanned.gaps, gap_index)
        if self.span >= self.spanned.item_span:
            return none
        # `item_index + span` is size_t arithmetic: a negative index wraps past the tracks and ends the walk.
        let track_index = (usize)(i64)self.spanned.item_index +% self.span
        if track_index >= ak.vector_size(self.spanned.tracks):
            return none

        let track = ak.vector_at(self.spanned.tracks, track_index)

        let is_last_spanned_track = self.span == self.spanned.item_span - 1
        if self.spanned.has_gaps and not is_last_spanned_track:
            self.pending_gap_index = track_index
        self.span += 1
        return track

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.h:289 Web::Layout::GridFormattingContext::has_flexible_tracks.
func layout_grid_formatting_context_has_flexible_tracks(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension) -> bool:
    return this.m_has_flexible_column_tracks if dimension == LayoutGridDimension.column else this.m_has_flexible_row_tracks

## `m_available_space.value()` (and `m_available_space->`): VERIFYs that run() has set it.
func layout_grid_formatting_context_available_space(this: LayoutGridFormattingContext*) -> LayoutAvailableSpace:
    return this.m_available_space else trap("VERIFY: m_available_space has a value")

## `dimension == GridDimension::Column ? m_available_space->width : m_available_space->height`.
func layout_grid_formatting_context_available_size(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension) -> LayoutAvailableSize:
    let available_space = layout_grid_formatting_context_available_space(this)
    return available_space.width if dimension == LayoutGridDimension.column else available_space.height

## `dimension == GridDimension::Column ? m_grid_columns : m_grid_rows`.
func layout_grid_formatting_context_tracks(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension) -> ak.Vector[LayoutGridFormattingContextGridTrack]*:
    return &this.m_grid_columns if dimension == LayoutGridDimension.column else &this.m_grid_rows

## `dimension == GridDimension::Column ? m_grid_columns_and_gaps : m_grid_rows_and_gaps`.
func layout_grid_formatting_context_tracks_and_gaps(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension) -> ak.Vector[LayoutGridFormattingContextGridTrack*]*:
    return &this.m_grid_columns_and_gaps if dimension == LayoutGridDimension.column else &this.m_grid_rows_and_gaps

## `value / count` read as CSSPixels for a size_t count: `CSSPixels / size_t` is a CSSPixelFraction over
## CSSPixels(Unsigned), which saturates, converted by its operator CSSPixels.
func layout_grid_formatting_context_div_count(value: gfx.CssPixels, count: usize) -> gfx.CssPixels:
    let fraction = value.div(gfx.css_pixels_from_unsigned((u64)count))
    return gfx.css_pixel_fraction_to_css_pixels(&fraction)

# mark: to_alignment ============================================================================

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:17 Web::Layout::to_alignment.
func layout_to_alignment_justify_content(value: css_data.JustifyContent) -> LayoutAlignment:
    match value:
        .left: return LayoutAlignment.start
        .right: return LayoutAlignment.end
        .flex_start, .start: return LayoutAlignment.start
        .flex_end, .end: return LayoutAlignment.end
        .center: return LayoutAlignment.center
        .space_between: return LayoutAlignment.space_between
        .space_around: return LayoutAlignment.space_around
        .space_evenly: return LayoutAlignment.space_evenly
        .stretch: return LayoutAlignment.stretch
        .normal: return LayoutAlignment.normal
        _: trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:47 Web::Layout::to_alignment.
func layout_to_alignment_justify_items(value: css_data.JustifyItems) -> LayoutAlignment:
    match value:
        .baseline: return LayoutAlignment.baseline
        .center: return LayoutAlignment.center
        .end: return LayoutAlignment.end
        .flex_end: return LayoutAlignment.end
        .flex_start: return LayoutAlignment.start
        .legacy: return LayoutAlignment.normal
        .normal: return LayoutAlignment.normal
        .safe: return LayoutAlignment.safe
        .self_end: return LayoutAlignment.self_end
        .self_start: return LayoutAlignment.self_start
        .start: return LayoutAlignment.start
        .stretch: return LayoutAlignment.stretch
        .unsafe: return LayoutAlignment.unsafe
        .left: return LayoutAlignment.start
        .right: return LayoutAlignment.end
        _: trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:85 Web::Layout::to_alignment.
func layout_to_alignment_align_content(value: css_data.AlignContent) -> LayoutAlignment:
    match value:
        .start: return LayoutAlignment.start
        .end: return LayoutAlignment.end
        .center: return LayoutAlignment.center
        .space_between: return LayoutAlignment.space_between
        .space_around: return LayoutAlignment.space_around
        .space_evenly: return LayoutAlignment.space_evenly
        .stretch: return LayoutAlignment.stretch
        .normal: return LayoutAlignment.normal
        .flex_start: return LayoutAlignment.start
        .flex_end: return LayoutAlignment.end
        _: trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:113 Web::Layout::to_alignment.
func layout_to_alignment_align_items(value: css_data.AlignItems) -> LayoutAlignment:
    match value:
        .baseline: return LayoutAlignment.baseline
        .center: return LayoutAlignment.center
        .end: return LayoutAlignment.end
        .flex_end: return LayoutAlignment.end
        .flex_start: return LayoutAlignment.start
        .normal: return LayoutAlignment.normal
        .safe: return LayoutAlignment.safe
        .self_end: return LayoutAlignment.self_end
        .self_start: return LayoutAlignment.self_start
        .start: return LayoutAlignment.start
        .stretch: return LayoutAlignment.stretch
        .unsafe: return LayoutAlignment.unsafe
        _: trap("VERIFY_NOT_REACHED")

# mark: GridTrack ===============================================================================

## A GridTrack with its C++ default member initializers and the given sizing functions.
func layout_grid_formatting_context_grid_track_new(min_track_sizing_function: CssGridSize, max_track_sizing_function: CssGridSize) -> LayoutGridFormattingContextGridTrack:
    return LayoutGridFormattingContextGridTrack(min_track_sizing_function = min_track_sizing_function, max_track_sizing_function = max_track_sizing_function, growth_limit = layout_zero_px())

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:145 Web::Layout::GridFormattingContext::GridTrack::create_from_definition.
func layout_grid_formatting_context_grid_track_create_from_definition(definition: const CssExplicitGridTrack*, is_auto_fit: bool = false) -> LayoutGridFormattingContextGridTrack:
    # NOTE: repeat() is expected to be expanded beforehand.
    assert(not css_explicit_grid_track_is_repeat(definition))

    if css_explicit_grid_track_is_minmax(definition):
        let minmax = css_explicit_grid_track_minmax(definition)
        var track = layout_grid_formatting_context_grid_track_new(css_grid_min_max_min_grid_size(&minmax), css_grid_min_max_max_grid_size(&minmax))
        track.is_auto_fit = is_auto_fit
        return track

    # https://drafts.csswg.org/css-grid-2/#algo-terms
    # min track sizing function:
    # If the track was sized with a minmax() function, this is the first argument to that function.
    # If the track was sized with a <flex> value or fit-content() function, auto. Otherwise, the track’s sizing function.
    var min_track_sizing_function = css_explicit_grid_track_grid_size(definition)
    if css_grid_size_is_flexible_length(&min_track_sizing_function) or css_grid_size_is_fit_content(&min_track_sizing_function):
        min_track_sizing_function = css_grid_size_make_auto()
    let max_track_sizing_function = css_explicit_grid_track_grid_size(definition)

    var track = layout_grid_formatting_context_grid_track_new(min_track_sizing_function, max_track_sizing_function)
    track.is_auto_fit = is_auto_fit
    return track

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:175 Web::Layout::GridFormattingContext::GridTrack::create_auto.
func layout_grid_formatting_context_grid_track_create_auto() -> LayoutGridFormattingContextGridTrack:
    return layout_grid_formatting_context_grid_track_new(css_grid_size_make_auto(), css_grid_size_make_auto())

## `CSS::GridSize(CSS::LengthStyleValue::create(CSS::Length::make_px(size)))`.
func layout_grid_formatting_context_px_grid_size(size: gfx.CssPixels) -> CssGridSize:
    return css_grid_size_new(css_length_style_value_create(css_length_make_px_css_pixels(size)).css_style_value())

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:183 Web::Layout::GridFormattingContext::GridTrack::create_gap.
func layout_grid_formatting_context_grid_track_create_gap(size: gfx.CssPixels) -> LayoutGridFormattingContextGridTrack:
    var track = layout_grid_formatting_context_grid_track_new(layout_grid_formatting_context_px_grid_size(size), layout_grid_formatting_context_px_grid_size(size))
    track.base_size = size
    track.is_gap = true
    return track

# mark: Construction ============================================================================

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:193 Web::Layout::GridFormattingContext::GridFormattingContext.
pub func layout_grid_formatting_context_construct(this: LayoutGridFormattingContext*, state: LayoutState*, layout_mode: LayoutMode, grid_container: LayoutBox*, parent: LayoutFormattingContext*?):
    layout_formatting_context_construct(this.layout_formatting_context(), LayoutFormattingContextType.grid, layout_mode, state, grid_container, parent)
    layout_formatting_context_set_class(this.layout_formatting_context(), &layout_grid_formatting_context_class)
    this.m_grid_container_used_values = layout_state_get_mutable(state, grid_container.layout_node_with_style())
    # The other members start as their default member initializers: zero, empty, none.
    layout_occupation_grid_construct(&this.m_occupation_grid)
    this.m_available_space = none

# GridFormattingContext::~GridFormattingContext() is the default destructor (GridFormattingContext.cpp:199):
# layout_formatting_context_destruct has nothing to run for this context.

# mark: Definite track sizes and repeat() counts ================================================

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:201 Web::Layout::GridFormattingContext::resolve_definite_track_size.
func layout_grid_formatting_context_resolve_definite_track_size(this: LayoutGridFormattingContext*, grid_size: const CssGridSize*, available_space: LayoutAvailableSpace) -> gfx.CssPixels:
    assert(css_grid_size_is_definite(grid_size))
    let css_size = css_grid_size_css_size(grid_size)
    return css_size_to_px(&css_size, layout_grid_formatting_context_grid_container(this).layout_node(), layout_available_size_to_px_or_zero(&available_space.width))

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:207 Web::Layout::GridFormattingContext::count_of_repeated_auto_fill_or_fit_tracks.
func layout_grid_formatting_context_count_of_repeated_auto_fill_or_fit_tracks(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension, repeated_track: const CssExplicitGridTrack*) -> i32:
    # https://www.w3.org/TR/css-grid-2/#auto-repeat
    # 7.2.3.2. Repeat-to-fill: auto-fill and auto-fit repetitions
    # On a subgridded axis, the auto-fill keyword is only valid once per <line-name-list>, and repeats
    # enough times for the name list to match the subgrid’s specified grid span (falling back to 0 if
    # the span is already fulfilled).

    # Otherwise on a standalone axis, when auto-fill is given as the repetition number
    # If the grid container has a definite size or max size in the relevant axis, then the number of
    # repetitions is the largest possible positive integer that does not cause the grid to overflow the
    # content box of its grid container

    let grid_computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
    let available_space = layout_grid_formatting_context_available_space(this)
    var size_of_repeated_tracks = layout_zero_px()
    # (treating each track as its max track sizing function if that is definite or its minimum track sizing
    # function otherwise, flooring the max track sizing function by the min track sizing function if both
    # are definite, and taking gap into account)
    let repeat = css_explicit_grid_track_repeat(repeated_track)
    let repeat_grid_track_size_list = css_grid_repeat_grid_track_size_list(&repeat)
    let repeat_track_list = css_grid_track_size_list_track_list(&repeat_grid_track_size_list)
    let repeat_tracks = ak.vector_span_const(&repeat_track_list)
    for explicit_grid_track in &repeat_tracks:
        let track_sizing_function = explicit_grid_track
        var track_size = layout_zero_px()
        if css_explicit_grid_track_is_minmax(track_sizing_function):
            let minmax = css_explicit_grid_track_minmax(track_sizing_function)
            let min_size = css_grid_min_max_min_grid_size(&minmax)
            let max_size = css_grid_min_max_max_grid_size(&minmax)
            if css_grid_size_is_definite(&max_size):
                track_size = layout_grid_formatting_context_resolve_definite_track_size(this, &max_size, available_space)
                if css_grid_size_is_definite(&min_size):
                    track_size = ak.min(track_size, layout_grid_formatting_context_resolve_definite_track_size(this, &min_size, available_space))
            elif css_grid_size_is_definite(&min_size):
                track_size = layout_grid_formatting_context_resolve_definite_track_size(this, &min_size, available_space)
            else:
                trap("VERIFY_NOT_REACHED")
        else:
            let grid_size = css_explicit_grid_track_grid_size(track_sizing_function)
            track_size = layout_grid_formatting_context_resolve_definite_track_size(this, &grid_size, available_space)
        size_of_repeated_tracks = size_of_repeated_tracks.add(track_size)

    if gfx.eq_css_pixels_int(size_of_repeated_tracks, 0):
        return 0

    let available_size = layout_grid_formatting_context_available_size(this, dimension)
    let gap = css_computed_values_column_gap(grid_computed_values) if dimension == LayoutGridDimension.column else css_computed_values_row_gap(grid_computed_values)
    let gap_px = layout_formatting_context_gap_to_px(this.layout_formatting_context(), gap, layout_available_size_to_px_or_zero(&available_size))
    # `repeat_track_list.size() * gap_px`: CSSPixels(size_t) * CSSPixels.
    let size_of_repeated_tracks_with_gap = size_of_repeated_tracks.add(gfx.css_pixels_from_unsigned((u64)ak.vector_size(&repeat_track_list)).mul(gap_px))
    # Otherwise, if the grid container has a definite min size in the relevant axis, the number of repetitions is the
    # smallest possible positive integer that fulfills that minimum requirement
    if layout_available_size_is_definite(&available_size):
        # NOTE: Gap size is added to free space to compensate for the fact that the last track does not have a gap
        let free_space = layout_available_size_to_px_or_zero(&available_size)
        let repetitions = free_space.add(gap_px).div(size_of_repeated_tracks_with_gap)
        let number_of_repetitions = gfx.css_pixel_fraction_to_int(&repetitions)
        # If any number of repetitions would overflow, then 1 repetition.
        return ak.max[i32](1, number_of_repetitions)
    # Otherwise, the specified track list repeats only once.
    return 1

    # For the purpose of finding the number of auto-repeated tracks in a standalone axis, the UA must
    # floor the track size to a UA-specified value to avoid division by zero. It is suggested that this
    # floor be 1px.