1c979e0ed7
Adds a second pass to resolve percentage paddings and margins of grid items after track sizes are known. If resolving percentage paddings or margins affects tracks sizes then second pass to re-resolve track sizes might also be needed but I cannot come up with an example to reproduce that so we can leave it to improve in the future :)
294 lines
11 KiB
C++
294 lines
11 KiB
C++
/*
|
|
* Copyright (c) 2022-2023, Martin Falisse <mfalisse@outlook.com>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <LibWeb/CSS/Length.h>
|
|
#include <LibWeb/Layout/FormattingContext.h>
|
|
|
|
namespace Web::Layout {
|
|
|
|
enum class GridDimension {
|
|
Row,
|
|
Column
|
|
};
|
|
|
|
struct GridPosition {
|
|
int row;
|
|
int column;
|
|
inline bool operator==(GridPosition const&) const = default;
|
|
};
|
|
|
|
class GridItem {
|
|
public:
|
|
GridItem(Box const& box, int row, int row_span, int column, int column_span)
|
|
: m_box(box)
|
|
, m_row(row)
|
|
, m_row_span(row_span)
|
|
, m_column(column)
|
|
, m_column_span(column_span)
|
|
{
|
|
}
|
|
|
|
Box const& box() const { return m_box; }
|
|
|
|
size_t span(GridDimension const dimension) const
|
|
{
|
|
return dimension == GridDimension::Column ? m_column_span : m_row_span;
|
|
}
|
|
|
|
int raw_position(GridDimension const dimension) const
|
|
{
|
|
return dimension == GridDimension::Column ? m_column : m_row;
|
|
}
|
|
|
|
CSSPixels add_border_box_sizes(CSSPixels content_size, GridDimension dimension, LayoutState const& state) const
|
|
{
|
|
auto& box_state = state.get(box());
|
|
if (dimension == GridDimension::Column) {
|
|
return box_state.border_left + box_state.padding_left + content_size + box_state.padding_right + box_state.border_right;
|
|
} else {
|
|
return box_state.border_top + box_state.padding_top + content_size + box_state.padding_bottom + box_state.border_bottom;
|
|
}
|
|
}
|
|
|
|
int raw_row() const { return m_row; }
|
|
void set_raw_row(int row) { m_row = row; }
|
|
|
|
int raw_column() const { return m_column; }
|
|
void set_raw_column(int column) { m_column = column; }
|
|
|
|
size_t raw_row_span() const { return m_row_span; }
|
|
size_t raw_column_span() const { return m_column_span; }
|
|
|
|
int gap_adjusted_row(Box const& grid_box) const;
|
|
int gap_adjusted_column(Box const& grid_box) const;
|
|
|
|
private:
|
|
JS::NonnullGCPtr<Box const> m_box;
|
|
int m_row { 0 };
|
|
size_t m_row_span { 1 };
|
|
int m_column { 0 };
|
|
size_t m_column_span { 1 };
|
|
};
|
|
|
|
class OccupationGrid {
|
|
public:
|
|
OccupationGrid(size_t columns_count, size_t rows_count)
|
|
{
|
|
m_max_column_index = max(0, columns_count - 1);
|
|
m_max_row_index = max(0, rows_count - 1);
|
|
};
|
|
OccupationGrid() {};
|
|
|
|
void set_occupied(int column_start, int column_end, int row_start, int row_end);
|
|
|
|
size_t column_count() const
|
|
{
|
|
return abs(m_min_column_index) + m_max_column_index + 1;
|
|
}
|
|
|
|
size_t row_count() const
|
|
{
|
|
return abs(m_min_row_index) + m_max_row_index + 1;
|
|
}
|
|
|
|
int min_column_index() const { return m_min_column_index; }
|
|
int max_column_index() const { return m_max_column_index; };
|
|
int min_row_index() const { return m_min_row_index; };
|
|
int max_row_index() const { return m_max_row_index; };
|
|
|
|
bool is_occupied(int column_index, int row_index) const;
|
|
|
|
private:
|
|
HashTable<GridPosition> m_occupation_grid;
|
|
|
|
int m_min_column_index { 0 };
|
|
int m_max_column_index { 0 };
|
|
int m_min_row_index { 0 };
|
|
int m_max_row_index { 0 };
|
|
};
|
|
|
|
class GridFormattingContext final : public FormattingContext {
|
|
public:
|
|
explicit GridFormattingContext(LayoutState&, Box const& grid_container, FormattingContext* parent);
|
|
~GridFormattingContext();
|
|
|
|
virtual void run(Box const&, LayoutMode, AvailableSpace const& available_space) override;
|
|
virtual CSSPixels automatic_content_width() const override;
|
|
virtual CSSPixels automatic_content_height() const override;
|
|
|
|
Box const& grid_container() const { return context_box(); }
|
|
|
|
private:
|
|
void resolve_items_box_metrics(GridDimension const dimension);
|
|
|
|
CSSPixels m_automatic_content_height { 0 };
|
|
bool is_auto_positioned_row(CSS::GridTrackPlacement const&, CSS::GridTrackPlacement const&) const;
|
|
bool is_auto_positioned_column(CSS::GridTrackPlacement const&, CSS::GridTrackPlacement const&) const;
|
|
bool is_auto_positioned_track(CSS::GridTrackPlacement const&, CSS::GridTrackPlacement const&) const;
|
|
|
|
struct TemporaryTrack {
|
|
CSS::GridSize min_track_sizing_function;
|
|
CSS::GridSize max_track_sizing_function;
|
|
|
|
CSSPixels base_size { 0 };
|
|
bool base_size_frozen { false };
|
|
|
|
CSSPixels growth_limit { 0 };
|
|
bool growth_limit_frozen { false };
|
|
bool infinitely_growable { false };
|
|
|
|
CSSPixels space_to_distribute { 0 };
|
|
CSSPixels planned_increase { 0 };
|
|
CSSPixels item_incurred_increase { 0 };
|
|
|
|
bool is_gap { false };
|
|
|
|
TemporaryTrack(CSS::GridSize min_track_sizing_function, CSS::GridSize max_track_sizing_function)
|
|
: min_track_sizing_function(min_track_sizing_function)
|
|
, max_track_sizing_function(max_track_sizing_function)
|
|
{
|
|
}
|
|
|
|
TemporaryTrack(CSS::GridSize track_sizing_function)
|
|
: min_track_sizing_function(track_sizing_function)
|
|
, max_track_sizing_function(track_sizing_function)
|
|
{
|
|
}
|
|
|
|
TemporaryTrack(CSSPixels size, bool is_gap)
|
|
: min_track_sizing_function(CSS::GridSize(CSS::Length::make_px(size)))
|
|
, max_track_sizing_function(CSS::GridSize(CSS::Length::make_px(size)))
|
|
, base_size(size)
|
|
, is_gap(is_gap)
|
|
{
|
|
}
|
|
|
|
TemporaryTrack()
|
|
: min_track_sizing_function(CSS::GridSize::make_auto())
|
|
, max_track_sizing_function(CSS::GridSize::make_auto())
|
|
{
|
|
}
|
|
};
|
|
|
|
struct GridArea {
|
|
String name;
|
|
size_t row_start { 0 };
|
|
size_t row_end { 1 };
|
|
size_t column_start { 0 };
|
|
size_t column_end { 1 };
|
|
};
|
|
|
|
HashMap<String, GridArea> m_grid_areas;
|
|
|
|
Vector<TemporaryTrack> m_grid_rows;
|
|
Vector<TemporaryTrack> m_grid_columns;
|
|
|
|
template<typename Callback>
|
|
void for_each_spanned_track_by_item(GridItem const& item, GridDimension const dimension, Callback callback)
|
|
{
|
|
auto& tracks = dimension == GridDimension::Column ? m_grid_columns : m_grid_rows;
|
|
for (size_t span = 0; span < item.span(dimension); span++) {
|
|
if (item.raw_position(dimension) + span >= tracks.size())
|
|
break;
|
|
|
|
auto& track = tracks[item.raw_position(dimension) + span];
|
|
callback(track);
|
|
}
|
|
}
|
|
|
|
template<typename Callback>
|
|
void for_each_spanned_track_by_item(GridItem const& item, GridDimension const dimension, Callback callback) const
|
|
{
|
|
auto const& tracks = dimension == GridDimension::Column ? m_grid_columns : m_grid_rows;
|
|
for (size_t span = 0; span < item.span(dimension); span++) {
|
|
if (item.raw_position(dimension) + span >= tracks.size())
|
|
break;
|
|
|
|
auto const& track = tracks[item.raw_position(dimension) + span];
|
|
callback(track);
|
|
}
|
|
}
|
|
|
|
Vector<TemporaryTrack> m_row_gap_tracks;
|
|
Vector<TemporaryTrack> m_column_gap_tracks;
|
|
|
|
Vector<TemporaryTrack&> m_grid_rows_and_gaps;
|
|
Vector<TemporaryTrack&> m_grid_columns_and_gaps;
|
|
|
|
size_t m_explicit_rows_line_count { 0 };
|
|
size_t m_explicit_columns_line_count { 0 };
|
|
|
|
OccupationGrid m_occupation_grid;
|
|
Vector<GridItem> m_grid_items;
|
|
Vector<JS::NonnullGCPtr<Box const>> m_boxes_to_place;
|
|
|
|
Optional<AvailableSpace> m_available_space;
|
|
|
|
void determine_grid_container_height();
|
|
void determine_intrinsic_size_of_grid_container(AvailableSpace const& available_space);
|
|
|
|
void resolve_grid_item_widths();
|
|
void resolve_grid_item_heights();
|
|
|
|
AvailableSize get_free_space(AvailableSpace const&, GridDimension const) const;
|
|
|
|
int get_line_index_by_line_name(String const& line_name, CSS::GridTrackSizeList);
|
|
CSSPixels resolve_definite_track_size(CSS::GridSize const&, AvailableSpace const&);
|
|
int count_of_repeated_auto_fill_or_fit_tracks(Vector<CSS::ExplicitGridTrack> const& track_list, AvailableSpace const&);
|
|
int get_count_of_tracks(Vector<CSS::ExplicitGridTrack> const&, AvailableSpace const&);
|
|
|
|
void build_grid_areas();
|
|
|
|
void place_grid_items(AvailableSpace const& available_space);
|
|
void place_item_with_row_and_column_position(Box const& child_box);
|
|
void place_item_with_row_position(Box const& child_box);
|
|
void place_item_with_column_position(Box const& child_box, int& auto_placement_cursor_x, int& auto_placement_cursor_y);
|
|
void place_item_with_no_declared_position(Box const& child_box, int& auto_placement_cursor_x, int& auto_placement_cursor_y);
|
|
|
|
void initialize_grid_tracks_from_definition(AvailableSpace const& available_space, Vector<CSS::ExplicitGridTrack> const& tracks_definition, Vector<TemporaryTrack>& tracks);
|
|
void initialize_grid_tracks_for_columns_and_rows(AvailableSpace const&);
|
|
void initialize_gap_tracks(AvailableSpace const&);
|
|
|
|
template<typename Match>
|
|
void distribute_extra_space_across_spanned_tracks_base_size(CSSPixels item_size_contribution, Vector<TemporaryTrack&>& spanned_tracks, Match matcher);
|
|
|
|
template<typename Match>
|
|
void distribute_extra_space_across_spanned_tracks_growth_limit(CSSPixels item_size_contribution, Vector<TemporaryTrack&>& spanned_tracks, Match matcher);
|
|
|
|
void initialize_track_sizes(AvailableSpace const&, GridDimension const);
|
|
void resolve_intrinsic_track_sizes(AvailableSpace const&, GridDimension const);
|
|
void increase_sizes_to_accommodate_spanning_items_crossing_content_sized_tracks(AvailableSpace const&, GridDimension const, size_t span);
|
|
void increase_sizes_to_accommodate_spanning_items_crossing_flexible_tracks(GridDimension const);
|
|
void maximize_tracks(AvailableSpace const&, GridDimension const);
|
|
void expand_flexible_tracks(AvailableSpace const&, GridDimension const);
|
|
void stretch_auto_tracks(AvailableSpace const&, GridDimension const);
|
|
void run_track_sizing(AvailableSpace const&, GridDimension const);
|
|
|
|
CSS::Size const& get_item_preferred_size(GridItem const&, GridDimension const) const;
|
|
|
|
CSSPixels calculate_min_content_size(GridItem const&, GridDimension const) const;
|
|
CSSPixels calculate_max_content_size(GridItem const&, GridDimension const) const;
|
|
|
|
CSSPixels calculate_min_content_contribution(GridItem const&, GridDimension const) const;
|
|
CSSPixels calculate_max_content_contribution(GridItem const&, GridDimension const) const;
|
|
|
|
CSSPixels calculate_limited_min_content_contribution(GridItem const&, GridDimension const) const;
|
|
CSSPixels calculate_limited_max_content_contribution(GridItem const&, GridDimension const) const;
|
|
|
|
CSSPixels containing_block_size_for_item(GridItem const&, GridDimension const) const;
|
|
AvailableSpace get_available_space_for_item(GridItem const&) const;
|
|
|
|
CSS::Size const& get_item_minimum_size(GridItem const&, GridDimension const) const;
|
|
CSSPixels content_size_suggestion(GridItem const&, GridDimension const) const;
|
|
Optional<CSSPixels> specified_size_suggestion(GridItem const&, GridDimension const) const;
|
|
CSSPixels content_based_minimum_size(GridItem const&, GridDimension const) const;
|
|
CSSPixels automatic_minimum_size(GridItem const&, GridDimension const) const;
|
|
CSSPixels calculate_minimum_contribution(GridItem const&, GridDimension const) const;
|
|
};
|
|
|
|
}
|