Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-31 21:30:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibWeb/Layout/GridFormattingContext.h

295 lines
11 KiB
C
Raw Normal View History

LibWeb: Add GridFormattingContext
2022-08-23 10:36:27 +02:00
/*
LibWeb+Base: Fix row-height bug in Grid when there is a column gap This fixes a bug in the CSS Grid when there is a column and/or row gap, as previously it would take the index of the incorrect column when finding the `AvailableSize`. There is a mild complication in the GridFormattingContext as the OccupationGrid does not take into account the gap columns and rows that later appear in the `Vector<TemporaryTrack>` columns and rows. The PositionedBoxes are kind of a connection between the two, and so it's now more explicit whether you would like to refer to a column by its position taking into the gap columns/rows or not.
2023-03-10 17:40:24 +01:00
* Copyright (c) 2022-2023, Martin Falisse <mfalisse@outlook.com>
LibWeb: Add GridFormattingContext
2022-08-23 10:36:27 +02:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
LibWeb: Use fixed-size tracks for grid gap Previously were incorrectly initializing the grid gap tracks as were using the GridSize float constructor, which creates a flexible length. What is actually wanted is a fixed-size track of a certain size, indicated in pixels.
2022-11-15 22:23:40 +01:00
#include <LibWeb/CSS/Length.h>
LibWeb: Add GridFormattingContext
2022-08-23 10:36:27 +02:00
#include <LibWeb/Layout/FormattingContext.h>
namespace Web::Layout {
LibWeb: Consolidate track sizing code for rows and columns in GFC Although the algorithm for sizing tracks (rows or columns) is defined once for both dimensions in the specification (https://www.w3.org/TR/css-grid-2/#algo-track-sizing), we have implemented it twice separately for sizing rows and columns. In addition to code duplication, another issue is that these implementations of the same algorithm have already diverged in some places, and this divergence is likely to become even worse as our implementation evolves. This change unifies code for both dimension into one method that runs track sizing. While this change brings a bit of collateral damange (border.html and minmax.html got changes in layout snaphots) it ultimately brings more benefits because now we can evolve layout for both rows and colums without duplicating the code :)
2023-05-06 04:22:35 +03:00
enum class GridDimension {
Row,
Column
};
LibWeb: Represent OccupationGrid using HashTable in GFC Using HashTable of grid positions to represent OccupationGrid allows to simplify positioning code. For example maybe_add_row() and maybe_add_column() calls are not needed anymore because there is no Vector<Vector<bool>> that need to be resized. No observable changes in grid layout are expected :)
2023-05-21 01:04:58 +03:00
struct GridPosition {
LibWeb: Add support for grid items with negative column-start in GFC This changes grid items position storage type from unsigned to signed integer so it can represent negative offsets and also updates placement for grid items with specified column to correctly handle negative offsets.
2023-06-07 12:00:01 +03:00
int row;
int column;
LibWeb: Represent OccupationGrid using HashTable in GFC Using HashTable of grid positions to represent OccupationGrid allows to simplify positioning code. For example maybe_add_row() and maybe_add_column() calls are not needed anymore because there is no Vector<Vector<bool>> that need to be resized. No observable changes in grid layout are expected :)
2023-05-21 01:04:58 +03:00
inline bool operator==(GridPosition const&) const = default;
};
LibWeb: Transform GridItem from a class to a struct in GFC GridItem is simple enough to be a struct. No behavior change.
2023-06-13 02:41:07 +03:00
struct GridItem {
JS::NonnullGCPtr<Box const> box;
LibWeb+Base: Fix row-height bug in Grid when there is a column gap This fixes a bug in the CSS Grid when there is a column and/or row gap, as previously it would take the index of the incorrect column when finding the `AvailableSize`. There is a mild complication in the GridFormattingContext as the OccupationGrid does not take into account the gap columns and rows that later appear in the `Vector<TemporaryTrack>` columns and rows. The PositionedBoxes are kind of a connection between the two, and so it's now more explicit whether you would like to refer to a column by its position taking into the gap columns/rows or not.
2023-03-10 17:40:24 +01:00
LibWeb: Transform GridItem from a class to a struct in GFC GridItem is simple enough to be a struct. No behavior change.
2023-06-13 02:41:07 +03:00
int row;
size_t row_span;
int column;
size_t column_span;
LibWeb+Base: Fix row-height bug in Grid when there is a column gap This fixes a bug in the CSS Grid when there is a column and/or row gap, as previously it would take the index of the incorrect column when finding the `AvailableSize`. There is a mild complication in the GridFormattingContext as the OccupationGrid does not take into account the gap columns and rows that later appear in the `Vector<TemporaryTrack>` columns and rows. The PositionedBoxes are kind of a connection between the two, and so it's now more explicit whether you would like to refer to a column by its position taking into the gap columns/rows or not.
2023-03-10 17:40:24 +01:00
LibWeb: Transform GridItem from a class to a struct in GFC GridItem is simple enough to be a struct. No behavior change.
2023-06-13 02:41:07 +03:00
[[nodiscard]] size_t span(GridDimension const dimension) const
LibWeb: Separate grid tracks from gaps in GFC This change is supposed to solve the problem that currenty when grid tracks are interleaved with gaps it is impossible to iterate tracks spanned by a specific grid item. There is a pair of functions: gap_adjusted_row() and gap_adjusted_column() but they won't work when it comes to items spanning > 1 track. Separating gaps from tracks is going to make it possible to iterate just tracks or both tracks and gaps when it is required. And now tracks spanned by an item can be accessed by just index without doing any additional math.
2023-05-14 15:23:39 +03:00
{
LibWeb: Transform GridItem from a class to a struct in GFC GridItem is simple enough to be a struct. No behavior change.
2023-06-13 02:41:07 +03:00
return dimension == GridDimension::Column ? column_span : row_span;
LibWeb: Separate grid tracks from gaps in GFC This change is supposed to solve the problem that currenty when grid tracks are interleaved with gaps it is impossible to iterate tracks spanned by a specific grid item. There is a pair of functions: gap_adjusted_row() and gap_adjusted_column() but they won't work when it comes to items spanning > 1 track. Separating gaps from tracks is going to make it possible to iterate just tracks or both tracks and gaps when it is required. And now tracks spanned by an item can be accessed by just index without doing any additional math.
2023-05-14 15:23:39 +03:00
}
LibWeb: Transform GridItem from a class to a struct in GFC GridItem is simple enough to be a struct. No behavior change.
2023-06-13 02:41:07 +03:00
[[nodiscard]] int raw_position(GridDimension const dimension) const
LibWeb: Separate grid tracks from gaps in GFC This change is supposed to solve the problem that currenty when grid tracks are interleaved with gaps it is impossible to iterate tracks spanned by a specific grid item. There is a pair of functions: gap_adjusted_row() and gap_adjusted_column() but they won't work when it comes to items spanning > 1 track. Separating gaps from tracks is going to make it possible to iterate just tracks or both tracks and gaps when it is required. And now tracks spanned by an item can be accessed by just index without doing any additional math.
2023-05-14 15:23:39 +03:00
{
LibWeb: Transform GridItem from a class to a struct in GFC GridItem is simple enough to be a struct. No behavior change.
2023-06-13 02:41:07 +03:00
return dimension == GridDimension::Column ? column : row;
LibWeb: Separate grid tracks from gaps in GFC This change is supposed to solve the problem that currenty when grid tracks are interleaved with gaps it is impossible to iterate tracks spanned by a specific grid item. There is a pair of functions: gap_adjusted_row() and gap_adjusted_column() but they won't work when it comes to items spanning > 1 track. Separating gaps from tracks is going to make it possible to iterate just tracks or both tracks and gaps when it is required. And now tracks spanned by an item can be accessed by just index without doing any additional math.
2023-05-14 15:23:39 +03:00
}
LibWeb: Use grid item *outer* size when calculating minimum contribution Previously we used the border box, which meant that tracks did not grow to accommodate item margins.
2023-06-12 14:30:00 +02:00
[[nodiscard]] CSSPixels add_margin_box_sizes(CSSPixels content_size, GridDimension dimension, LayoutState const& state) const
LibWeb: Remove borders from TemporaryTrack in GFC This change makes grid items be responsible for their borders instead of grid tracks which can not have borders itself. There are changes in layout tests but those are improvements :)
2023-05-17 08:34:48 +03:00
{
LibWeb: Transform GridItem from a class to a struct in GFC GridItem is simple enough to be a struct. No behavior change.
2023-06-13 02:41:07 +03:00
auto const& box_state = state.get(box);
LibWeb: Use grid item *outer* size when calculating minimum contribution Previously we used the border box, which meant that tracks did not grow to accommodate item margins.
2023-06-12 14:30:00 +02:00
if (dimension == GridDimension::Column)
return box_state.margin_box_left() + content_size + box_state.margin_box_right();
return box_state.margin_box_top() + content_size + box_state.margin_box_bottom();
LibWeb: Remove borders from TemporaryTrack in GFC This change makes grid items be responsible for their borders instead of grid tracks which can not have borders itself. There are changes in layout tests but those are improvements :)
2023-05-17 08:34:48 +03:00
}
LibWeb: Transform GridItem from a class to a struct in GFC GridItem is simple enough to be a struct. No behavior change.
2023-06-13 02:41:07 +03:00
[[nodiscard]] int gap_adjusted_row(Box const& grid_box) const;
[[nodiscard]] int gap_adjusted_column(Box const& grid_box) const;
LibWeb+Base: Fix row-height bug in Grid when there is a column gap This fixes a bug in the CSS Grid when there is a column and/or row gap, as previously it would take the index of the incorrect column when finding the `AvailableSize`. There is a mild complication in the GridFormattingContext as the OccupationGrid does not take into account the gap columns and rows that later appear in the `Vector<TemporaryTrack>` columns and rows. The PositionedBoxes are kind of a connection between the two, and so it's now more explicit whether you would like to refer to a column by its position taking into the gap columns/rows or not.
2023-03-10 17:40:24 +01:00
};
LibWeb: Add support for grid items with negative column-start in GFC This changes grid items position storage type from unsigned to signed integer so it can represent negative offsets and also updates placement for grid items with specified column to correctly handle negative offsets.
2023-06-07 12:00:01 +03:00
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);
Everywhere: Remove needless trailing semi-colons after functions This is a new option in clang-format-16.
2023-07-07 22:48:11 -04:00
}
LibWeb: Add support for grid items with negative column-start in GFC This changes grid items position storage type from unsigned to signed integer so it can represent negative offsets and also updates placement for grid items with specified column to correctly handle negative offsets.
2023-06-07 12:00:01 +03:00
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;
}
LibWeb: Adjust grid columns size to fit spanning items This change implements following paragraph from placement algorithm in the spec: "If the largest column span among all the items without a definite column position is larger than the width of the implicit grid, add columns to the end of the implicit grid to accommodate that column span." There were places in the grid implementation code with copies of this text, but those were completely unrelated to the code where they were being pasted so I removed them.
2023-07-13 15:49:07 +02:00
void set_max_column_index(size_t max_column_index) { m_max_column_index = max_column_index; }
LibWeb: Add support for grid items with negative column-start in GFC This changes grid items position storage type from unsigned to signed integer so it can represent negative offsets and also updates placement for grid items with specified column to correctly handle negative offsets.
2023-06-07 12:00:01 +03:00
int min_column_index() const { return m_min_column_index; }
Everywhere: Remove needless trailing semi-colons after functions This is a new option in clang-format-16.
2023-07-07 22:48:11 -04:00
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; }
LibWeb: Add support for grid items with negative column-start in GFC This changes grid items position storage type from unsigned to signed integer so it can represent negative offsets and also updates placement for grid items with specified column to correctly handle negative offsets.
2023-06-07 12:00:01 +03:00
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 };
};
LibWeb: Make grid containers be Layout::Box Grid containers were incorrectly represented as BlockContainer before. Furthermore, GridFormattingContext had a bogus inheritance relationship with BlockFormattingContext. This patch brings our architecture closer to spec by making grid containers be plain boxes and making GFC not inherit from BFC.
2023-01-23 15:19:32 +01:00
class GridFormattingContext final : public FormattingContext {
LibWeb: Add GridFormattingContext
2022-08-23 10:36:27 +02:00
public:
LibWeb: Make grid containers be Layout::Box Grid containers were incorrectly represented as BlockContainer before. Furthermore, GridFormattingContext had a bogus inheritance relationship with BlockFormattingContext. This patch brings our architecture closer to spec by making grid containers be plain boxes and making GFC not inherit from BFC.
2023-01-23 15:19:32 +01:00
explicit GridFormattingContext(LayoutState&, Box const& grid_container, FormattingContext* parent);
LibWeb: Add GridFormattingContext
2022-08-23 10:36:27 +02:00
~GridFormattingContext();
LibWeb: Reorganize layout algorithms around available space This is a big and messy change, and here's the gist: - AvaliableSpace is now 2x AvailableSize (width and height) - Layout algorithms are redesigned around the idea of available space - When doing layout across nested formatting contexts, the parent context tells the child context how much space is available for the child's root box in both axes. - "Available space" replaces "containing block width" in most places. - The width and height in a box's UsedValues are considered to be definite after they're assigned to. Marking something as having definite size is no longer a separate step, This probably introduces various regressions, but the big win here is that our layout system now works with available space, just like the specs are written. Fixing issues will be much easier going forward, since you don't need to do nearly as much conversion from "spec logic" to "LibWeb logic" as you previously did.
2022-09-27 15:29:17 +02:00
virtual void run(Box const&, LayoutMode, AvailableSpace const& available_space) override;
LibWeb: Let FormattingContext decide the automatic width of its root Instead of special-casing FlexFormattingContext in the intrinsic sizing layout helpers, add FormattingContext::automatic_content_width() and let each context subclass decide what that means. No behavior change here, just moving this responsibility.
2023-03-19 09:57:31 +01:00
virtual CSSPixels automatic_content_width() const override;
LibWeb: Convert FormattingContext to new pixel units Just FormattingContext and AvailableSpace, and the minor adjustments to make everything else work.
2022-11-23 17:46:10 +00:00
virtual CSSPixels automatic_content_height() const override;
LibWeb: Add FormattingContext::automatic_content_height() This function should return the automatic height of the formatting context's root box. Until now, we've been relying on some magical handshakes between parent and child context, when negotiating the height of child context root boxes. This is a step towards something more reasonable.
2022-09-24 13:39:43 +02:00
LibWeb: Consolidate track sizing code for rows and columns in GFC Although the algorithm for sizing tracks (rows or columns) is defined once for both dimensions in the specification (https://www.w3.org/TR/css-grid-2/#algo-track-sizing), we have implemented it twice separately for sizing rows and columns. In addition to code duplication, another issue is that these implementations of the same algorithm have already diverged in some places, and this divergence is likely to become even worse as our implementation evolves. This change unifies code for both dimension into one method that runs track sizing. While this change brings a bit of collateral damange (border.html and minmax.html got changes in layout snaphots) it ultimately brings more benefits because now we can evolve layout for both rows and colums without duplicating the code :)
2023-05-06 04:22:35 +03:00
Box const& grid_container() const { return context_box(); }
LibWeb: Add FormattingContext::automatic_content_height() This function should return the automatic height of the formatting context's root box. Until now, we've been relying on some magical handshakes between parent and child context, when negotiating the height of child context root boxes. This is a step towards something more reasonable.
2022-09-24 13:39:43 +02:00
private:
LibWeb: Respect justify-items property of grid container
2023-07-14 20:57:36 +02:00
CSS::JustifyItems justification_for_item(Box const& box) const;
LibWeb: Add support for `align-items` and `align-self` in CSS grid
2023-07-27 13:18:32 -04:00
CSS::AlignItems alignment_for_item(Box const& box) const;
LibWeb: Respect justify-items property of grid container
2023-07-14 20:57:36 +02:00
LibWeb: Resolve percentage padding and margins for grid items in GFC 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 :)
2023-06-08 02:49:30 +03:00
void resolve_items_box_metrics(GridDimension const dimension);
LibWeb: Convert GridFormattingContext to new pixel units
2022-11-04 20:18:48 +00:00
CSSPixels m_automatic_content_height { 0 };
LibWeb: Make it easier to check if grid track is auto positioned Add some helper functions for checking if a grid-track is auto-positioned. I think this makes the code more legible.
2022-09-17 18:14:11 +02:00
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;
LibWeb: Refactor GridTrack maintenance in the GFC Refactor the m_grid_columns and m_grid_rows to be maintained in the class, which will make it easier to later create functions relating to them.
2022-10-15 12:51:00 +02:00
LibWeb: Rename TemporaryTrack to GridTrack in GFC The word "Temporary" seems to lack any meaningful connection when applied to grid tracks.
2023-06-10 01:50:48 +03:00
struct GridTrack {
LibWeb: Refactor GridTrackSize classes Refactor various classes in the GridTrackSize file for the incoming named_tracks feature. Previously the ExplicitTrackSizing had mixed responsiblities with the newly-named GridRepeat class. This made it so it was not possible to have multiple repeats within a single 'GridTrackSizeList' definition. The MetaGridTrackSize class had both the responsibilities of being a container for minmax values as well as for simple GridSizes. By uniting the different possible values (repeat, minmax, default) into the ExplicitGridTrack class are able to be more expressive as to the different grid size modalities. The GridTrackSizeList will be useful as compared to a Vector<ExplicitGridTrack> since this way can keep track of the declared line names. These same line names are able to be declared within the values of a repeat function, hence the presence of a GridTrackSizeList inside the GridRepeat class.
2022-10-30 13:27:57 +01:00
CSS::GridSize min_track_sizing_function;
CSS::GridSize max_track_sizing_function;
LibWeb: Implement more of spanning tracks sizing in GFC Implements more parts of sizing algorithm for tracks with spanning items to archive parity with implementation for sizing of tracks with non-spanning items.
2023-05-20 17:46:21 +03:00
LibWeb: Convert GridFormattingContext to new pixel units
2022-11-04 20:18:48 +00:00
CSSPixels base_size { 0 };
LibWeb: Implement more of spanning tracks sizing in GFC Implements more parts of sizing algorithm for tracks with spanning items to archive parity with implementation for sizing of tracks with non-spanning items.
2023-05-20 17:46:21 +03:00
bool base_size_frozen { false };
LibWeb: Use empty Optional to represent infinte growth limit in GFC In c66dbc99ee69995c09e08b5e137b2096f694959c GFC was updated to use -1 as special value for the infinite growth limit. However, using Optional instead reduces the risk of accidentally using -1 special value in layout calculations.
2023-07-25 23:09:04 +02:00
Optional<CSSPixels> growth_limit { 0 };
LibWeb: Implement more of spanning tracks sizing in GFC Implements more parts of sizing algorithm for tracks with spanning items to archive parity with implementation for sizing of tracks with non-spanning items.
2023-05-20 17:46:21 +03:00
bool growth_limit_frozen { false };
bool infinitely_growable { false };
LibWeb: Convert GridFormattingContext to new pixel units
2022-11-04 20:18:48 +00:00
CSSPixels space_to_distribute { 0 };
CSSPixels planned_increase { 0 };
LibWeb: Start implementing sizing for tracks with span > 1 items in GFC Partially implements: - Increase sizes to accommodate spanning items crossing content-sized tracks - Increase sizes to accommodate spanning items crossing flexible tracks from https://www.w3.org/TR/css-grid-2/#algo-content
2023-05-14 19:16:26 +03:00
CSSPixels item_incurred_increase { 0 };
LibWeb: Implement more of spanning tracks sizing in GFC Implements more parts of sizing algorithm for tracks with spanning items to archive parity with implementation for sizing of tracks with non-spanning items.
2023-05-20 17:46:21 +03:00
LibWeb: Implement gap in CSS Grid
2022-11-06 13:45:05 +01:00
bool is_gap { false };
LibWeb: Add some helpers for TemporaryTrack Add some helpers to the TemporaryTrack struct to assist in making future commits more legible.
2022-11-06 13:37:26 +01:00
LibWeb: Add GridTrack::create_from_definition() in GFC Introducing method to construct grid track from definition allows to reduce duplication in layout code.
2023-06-11 21:58:19 +03:00
static GridTrack create_from_definition(CSS::ExplicitGridTrack const& definition);
LibWeb: Use static factory methods to construct GridTrack in GFC This allows to be more explicit in layout code about whether a track is going to be created from definition or be auto-sized or a gap.
2023-06-11 22:45:31 +03:00
static GridTrack create_auto();
static GridTrack create_gap(CSSPixels size);
LibWeb: Refactor GridTrack maintenance in the GFC Refactor the m_grid_columns and m_grid_rows to be maintained in the class, which will make it easier to later create functions relating to them.
2022-10-15 12:51:00 +02:00
};
LibWeb: Calculate valid grid areas When starting the GridFormattingContext, calculate the valid grid areas as declared in the `grid-template-areas` property. Since this doesn't change, are able to do this once and store the results.
2023-01-17 13:50:41 +01:00
struct GridArea {
String name;
LibWeb: Use size_t instead of int when appropriate in GFC size_t should be used instead of int in loop counter and to store rows/columns positions because they can't be negative values. This allows to remove some static casts to int.
2023-05-09 19:53:26 +03:00
size_t row_start { 0 };
size_t row_end { 1 };
size_t column_start { 0 };
size_t column_end { 1 };
LibWeb: Calculate valid grid areas When starting the GridFormattingContext, calculate the valid grid areas as declared in the `grid-template-areas` property. Since this doesn't change, are able to do this once and store the results.
2023-01-17 13:50:41 +01:00
};
LibWeb: Use HashMap instead of Vector to store grid areas in GFC Grid areas are accessed by their name (string) so HashMap is more appropriate data structure to store them.
2023-05-28 22:02:53 +03:00
HashMap<String, GridArea> m_grid_areas;
LibWeb: Calculate valid grid areas When starting the GridFormattingContext, calculate the valid grid areas as declared in the `grid-template-areas` property. Since this doesn't change, are able to do this once and store the results.
2023-01-17 13:50:41 +01:00
LibWeb: Rename TemporaryTrack to GridTrack in GFC The word "Temporary" seems to lack any meaningful connection when applied to grid tracks.
2023-06-10 01:50:48 +03:00
Vector<GridTrack> m_grid_rows;
Vector<GridTrack> m_grid_columns;
LibWeb: Implement auto-fill and auto-fit Implement auto-fill and auto-fit for the grid, which allow for placing as many columns as will fit within a given container size.
2022-10-15 13:21:43 +02:00
LibWeb: Include gaps in for_each_spanned_track_by_item in GFC This fixes the issue when left free space is calculated incorrectly because for_each_spanned_track_by_item does not include gap tracks.
2023-06-10 00:41:15 +03:00
bool has_gaps(GridDimension const dimension) const
{
if (dimension == GridDimension::Column) {
return !grid_container().computed_values().column_gap().is_auto();
} else {
return !grid_container().computed_values().row_gap().is_auto();
}
}
LibWeb: Add for_each_spanned_track to iterate spanned tracks in GFC Introducing for_each_spanned_track that allows to iterate tracks spanned by a specific items allow to delete a lot of repeated code.
2023-05-17 15:34:33 +03:00
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;
LibWeb: Include gaps in for_each_spanned_track_by_item in GFC This fixes the issue when left free space is calculated incorrectly because for_each_spanned_track_by_item does not include gap tracks.
2023-06-10 00:41:15 +03:00
auto& gaps = dimension == GridDimension::Column ? m_column_gap_tracks : m_row_gap_tracks;
auto has_gaps = this->has_gaps(dimension);
auto item_span = item.span(dimension);
auto item_index = item.raw_position(dimension);
for (size_t span = 0; span < item_span; span++) {
auto track_index = item_index + span;
if (track_index >= tracks.size())
LibWeb: Add for_each_spanned_track to iterate spanned tracks in GFC Introducing for_each_spanned_track that allows to iterate tracks spanned by a specific items allow to delete a lot of repeated code.
2023-05-17 15:34:33 +03:00
break;
LibWeb: Include gaps in for_each_spanned_track_by_item in GFC This fixes the issue when left free space is calculated incorrectly because for_each_spanned_track_by_item does not include gap tracks.
2023-06-10 00:41:15 +03:00
auto& track = tracks[track_index];
LibWeb: Add for_each_spanned_track to iterate spanned tracks in GFC Introducing for_each_spanned_track that allows to iterate tracks spanned by a specific items allow to delete a lot of repeated code.
2023-05-17 15:34:33 +03:00
callback(track);
LibWeb: Include gaps in for_each_spanned_track_by_item in GFC This fixes the issue when left free space is calculated incorrectly because for_each_spanned_track_by_item does not include gap tracks.
2023-06-10 00:41:15 +03:00
auto is_last_spanned_track = span == item_span - 1;
if (has_gaps && !is_last_spanned_track) {
auto& gap = gaps[track_index];
callback(gap);
}
LibWeb: Add for_each_spanned_track to iterate spanned tracks in GFC Introducing for_each_spanned_track that allows to iterate tracks spanned by a specific items allow to delete a lot of repeated code.
2023-05-17 15:34:33 +03:00
}
}
template<typename Callback>
void for_each_spanned_track_by_item(GridItem const& item, GridDimension const dimension, Callback callback) const
{
LibWeb: Include gaps in for_each_spanned_track_by_item in GFC This fixes the issue when left free space is calculated incorrectly because for_each_spanned_track_by_item does not include gap tracks.
2023-06-10 00:41:15 +03:00
auto& tracks = dimension == GridDimension::Column ? m_grid_columns : m_grid_rows;
auto& gaps = dimension == GridDimension::Column ? m_column_gap_tracks : m_row_gap_tracks;
auto has_gaps = this->has_gaps(dimension);
auto item_span = item.span(dimension);
auto item_index = item.raw_position(dimension);
for (size_t span = 0; span < item_span; span++) {
auto track_index = item_index + span;
if (track_index >= tracks.size())
LibWeb: Add for_each_spanned_track to iterate spanned tracks in GFC Introducing for_each_spanned_track that allows to iterate tracks spanned by a specific items allow to delete a lot of repeated code.
2023-05-17 15:34:33 +03:00
break;
LibWeb: Include gaps in for_each_spanned_track_by_item in GFC This fixes the issue when left free space is calculated incorrectly because for_each_spanned_track_by_item does not include gap tracks.
2023-06-10 00:41:15 +03:00
auto& track = tracks[track_index];
LibWeb: Add for_each_spanned_track to iterate spanned tracks in GFC Introducing for_each_spanned_track that allows to iterate tracks spanned by a specific items allow to delete a lot of repeated code.
2023-05-17 15:34:33 +03:00
callback(track);
LibWeb: Include gaps in for_each_spanned_track_by_item in GFC This fixes the issue when left free space is calculated incorrectly because for_each_spanned_track_by_item does not include gap tracks.
2023-06-10 00:41:15 +03:00
auto is_last_spanned_track = span == item_span - 1;
if (has_gaps && !is_last_spanned_track) {
auto& gap = gaps[track_index];
callback(gap);
}
LibWeb: Add for_each_spanned_track to iterate spanned tracks in GFC Introducing for_each_spanned_track that allows to iterate tracks spanned by a specific items allow to delete a lot of repeated code.
2023-05-17 15:34:33 +03:00
}
}
LibWeb: Rename TemporaryTrack to GridTrack in GFC The word "Temporary" seems to lack any meaningful connection when applied to grid tracks.
2023-06-10 01:50:48 +03:00
Vector<GridTrack> m_row_gap_tracks;
Vector<GridTrack> m_column_gap_tracks;
LibWeb: Separate grid tracks from gaps in GFC This change is supposed to solve the problem that currenty when grid tracks are interleaved with gaps it is impossible to iterate tracks spanned by a specific grid item. There is a pair of functions: gap_adjusted_row() and gap_adjusted_column() but they won't work when it comes to items spanning > 1 track. Separating gaps from tracks is going to make it possible to iterate just tracks or both tracks and gaps when it is required. And now tracks spanned by an item can be accessed by just index without doing any additional math.
2023-05-14 15:23:39 +03:00
LibWeb: Rename TemporaryTrack to GridTrack in GFC The word "Temporary" seems to lack any meaningful connection when applied to grid tracks.
2023-06-10 01:50:48 +03:00
Vector<GridTrack&> m_grid_rows_and_gaps;
Vector<GridTrack&> m_grid_columns_and_gaps;
LibWeb: Separate grid tracks from gaps in GFC This change is supposed to solve the problem that currenty when grid tracks are interleaved with gaps it is impossible to iterate tracks spanned by a specific grid item. There is a pair of functions: gap_adjusted_row() and gap_adjusted_column() but they won't work when it comes to items spanning > 1 track. Separating gaps from tracks is going to make it possible to iterate just tracks or both tracks and gaps when it is required. And now tracks spanned by an item can be accessed by just index without doing any additional math.
2023-05-14 15:23:39 +03:00
LibWeb: Add support for grid items with negative column-start in GFC This changes grid items position storage type from unsigned to signed integer so it can represent negative offsets and also updates placement for grid items with specified column to correctly handle negative offsets.
2023-06-07 12:00:01 +03:00
size_t m_explicit_rows_line_count { 0 };
size_t m_explicit_columns_line_count { 0 };
LibWeb: Refactor GridFormattingContext For legibility, split up the run() function of the GridFormattingContext into individual components.
2022-12-28 10:12:30 +01:00
OccupationGrid m_occupation_grid;
LibWeb: Rename PositionedBox to GridItem This seems like a more accurate description of what this class really is, and easier to understand in my opinion.
2023-04-01 17:43:25 +02:00
Vector<GridItem> m_grid_items;
LibWeb: Refactor GridFormattingContext For legibility, split up the run() function of the GridFormattingContext into individual components.
2022-12-28 10:12:30 +01:00
LibWeb: Treat unresolvable percentages as auto to resolve sizes in GFC Fixes the bug that currently we always consider tracks with percentage size as ones with "fixed" length even when available size is not definite. With this change tracks with percentage size when available size is not definite will be considered as "intrinsic" sized.
2023-05-28 19:31:26 +03:00
Optional<AvailableSpace> m_available_space;
LibWeb: Do not layout grid items during grid container intrinsic sizing There is not need to run layout inside grid items for intrinsic sizing of grid container.
2023-05-15 15:54:25 +03:00
void determine_grid_container_height();
LibWeb: Implement grid container intrinsic sizes calculation When a width/height constraint is applied to GFC it should set its own width/height to the sum of track sizes according to the spec. Changes in layout tests are improvement over what we had before.
2023-05-13 11:55:09 +03:00
void determine_intrinsic_size_of_grid_container(AvailableSpace const& available_space);
LibWeb: Support positioning of abspos boxes inside grid container - Out-of-flow items should not affect grid layout - "The static position of an absolutely-positioned child of a grid container is determined as if it were the sole grid item in a grid area whose edges coincide with the content edges of the grid container."
2023-08-07 17:06:08 +02:00
virtual void parent_context_did_dimension_child_root_box() override;
LibWeb: Use grid item used width as available width during track sizing This change addresses the incorrect assumption that the available width inside a grid item is equal to the width of the track it belongs to. For instance, if a grid item has a width of 200px, the available width inside that item is also 200px regardless of its column(s) base size. To solve this issue, it was necessary to move the final resolution of grid items to occur immediately after the final column track sizes are determined. By doing so, it becomes possible to obtain correct available width inside grid items while resolving the row track sizes.
2023-05-18 17:24:46 +03:00
void resolve_grid_item_widths();
LibWeb: Move resolving grid item heights into separate method in GFC
2023-05-18 22:12:24 +03:00
void resolve_grid_item_heights();
LibWeb: Use grid item used width as available width during track sizing This change addresses the incorrect assumption that the available width inside a grid item is equal to the width of the track it belongs to. For instance, if a grid item has a width of 200px, the available width inside that item is also 200px regardless of its column(s) base size. To solve this issue, it was necessary to move the final resolution of grid items to occur immediately after the final column track sizes are determined. By doing so, it becomes possible to obtain correct available width inside grid items while resolving the row track sizes.
2023-05-18 17:24:46 +03:00
LibWeb: Separate grid tracks from gaps in GFC This change is supposed to solve the problem that currenty when grid tracks are interleaved with gaps it is impossible to iterate tracks spanned by a specific grid item. There is a pair of functions: gap_adjusted_row() and gap_adjusted_column() but they won't work when it comes to items spanning > 1 track. Separating gaps from tracks is going to make it possible to iterate just tracks or both tracks and gaps when it is required. And now tracks spanned by an item can be accessed by just index without doing any additional math.
2023-05-14 15:23:39 +03:00
AvailableSize get_free_space(AvailableSpace const&, GridDimension const) const;
LibWeb+Base: Use line names for positioning grid items When there are grid tracks with line names, use these to resolve line-names passed to positioned grid items.
2022-10-30 13:49:47 +01:00
LibWeb: Use String class in certain CSS Grid classes Converts the remaining instances of DeprecatedString to String in the CSS Grid classes.
2023-01-16 17:29:15 +01:00
int get_line_index_by_line_name(String const& line_name, CSS::GridTrackSizeList);
LibWeb: Use grid_container() to access root grid box in GFC There is grid_container() method that can be used to access root box in GFC without passing it through methods arguments.
2023-05-06 06:04:40 +03:00
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&);
LibWeb: Refactor GridFormattingContext For legibility, split up the run() function of the GridFormattingContext into individual components.
2022-12-28 10:12:30 +01:00
LibWeb: Use HashMap instead of Vector to store grid areas in GFC Grid areas are accessed by their name (string) so HashMap is more appropriate data structure to store them.
2023-05-28 22:02:53 +03:00
void build_grid_areas();
LibWeb: Calculate valid grid areas When starting the GridFormattingContext, calculate the valid grid areas as declared in the `grid-template-areas` property. Since this doesn't change, are able to do this once and store the results.
2023-01-17 13:50:41 +01:00
LibWeb: Move grid items placement algorithm into separate method in GFC Let's follow pattern of other formatting context where steps of layout are separated into method.
2023-05-09 18:25:04 +03:00
void place_grid_items(AvailableSpace const& available_space);
LibWeb: Use grid_container() to access root grid box in GFC There is grid_container() method that can be used to access root box in GFC without passing it through methods arguments.
2023-05-06 06:04:40 +03:00
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);
LibWeb: Refactor GridFormattingContext For legibility, split up the run() function of the GridFormattingContext into individual components.
2022-12-28 10:12:30 +01:00
void place_item_with_no_declared_position(Box const& child_box, int& auto_placement_cursor_x, int& auto_placement_cursor_y);
LibWeb: Rename TemporaryTrack to GridTrack in GFC The word "Temporary" seems to lack any meaningful connection when applied to grid tracks.
2023-06-10 01:50:48 +03:00
void initialize_grid_tracks_from_definition(AvailableSpace const& available_space, Vector<CSS::ExplicitGridTrack> const& tracks_definition, Vector<GridTrack>& tracks);
LibWeb: Refactor tracks initialization in GFC to reduce code duplication This change moves code that was duplicated for rows and columns into separate function.
2023-05-09 19:39:31 +03:00
void initialize_grid_tracks_for_columns_and_rows(AvailableSpace const&);
LibWeb: Move gap tracks initialization into separate method in GFC
2023-05-09 18:38:53 +03:00
void initialize_gap_tracks(AvailableSpace const&);
LibWeb: Split run_track_sizing into smaller method in GFC Splits run_track_sizing into following methods: - initialize_track_sizes (12.4. Initialize Track Sizes) - resolve_intrinsic_track_sizes (12.5. Resolve Intrinsic Track Sizes) - maximize_tracks (12.6. Maximize Tracks) - expand_flexible_tracks (12.7 Expand Flexible Tracks) - stretch_auto_tracks (12.8. Stretch auto Tracks)
2023-05-10 04:21:56 +03:00
LibWeb: Set 0px fixed size to collapsed auto-fit tracks in GFC Fixes the issue that before we set base_size and growth_limit of collapsed tracks to 0px which still allowed them to grow by space distribution.
2023-06-20 18:48:20 +03:00
void collapse_auto_fit_tracks_if_needed(GridDimension const);
LibWeb: Implement distributing space to tracks beyond limits in GFC Implements "Distribute space beyond limits" step from: https://www.w3.org/TR/css-grid-2/#distribute-extra-space
2023-06-22 00:48:46 +03:00
enum class SpaceDistributionPhase {
AccommodateMinimumContribution,
AccommodateMinContentContribution,
AccommodateMaxContentContribution
};
LibWeb: Consider all spanned tracks while finding extra space in GFC This fixes the issue when functions that distribute base_size or growth_limit to tracks only considered *affected* spanned tracks while calculating left extra that is available for distribution while indeed it should be just *all* spanned track by specific item that extra space size.
2023-06-07 19:11:29 +03:00
template<typename Match>
LibWeb: Implement distributing space to tracks beyond limits in GFC Implements "Distribute space beyond limits" step from: https://www.w3.org/TR/css-grid-2/#distribute-extra-space
2023-06-22 00:48:46 +03:00
void distribute_extra_space_across_spanned_tracks_base_size(GridDimension dimension, CSSPixels item_size_contribution, SpaceDistributionPhase phase, Vector<GridTrack&>& spanned_tracks, Match matcher);
LibWeb: Consider all spanned tracks while finding extra space in GFC This fixes the issue when functions that distribute base_size or growth_limit to tracks only considered *affected* spanned tracks while calculating left extra that is available for distribution while indeed it should be just *all* spanned track by specific item that extra space size.
2023-06-07 19:11:29 +03:00
template<typename Match>
LibWeb: Rename TemporaryTrack to GridTrack in GFC The word "Temporary" seems to lack any meaningful connection when applied to grid tracks.
2023-06-10 01:50:48 +03:00
void distribute_extra_space_across_spanned_tracks_growth_limit(CSSPixels item_size_contribution, Vector<GridTrack&>& spanned_tracks, Match matcher);
LibWeb: Consider all spanned tracks while finding extra space in GFC This fixes the issue when functions that distribute base_size or growth_limit to tracks only considered *affected* spanned tracks while calculating left extra that is available for distribution while indeed it should be just *all* spanned track by specific item that extra space size.
2023-06-07 19:11:29 +03:00
LibWeb: Separate grid tracks from gaps in GFC This change is supposed to solve the problem that currenty when grid tracks are interleaved with gaps it is impossible to iterate tracks spanned by a specific grid item. There is a pair of functions: gap_adjusted_row() and gap_adjusted_column() but they won't work when it comes to items spanning > 1 track. Separating gaps from tracks is going to make it possible to iterate just tracks or both tracks and gaps when it is required. And now tracks spanned by an item can be accessed by just index without doing any additional math.
2023-05-14 15:23:39 +03:00
void initialize_track_sizes(AvailableSpace const&, GridDimension const);
void resolve_intrinsic_track_sizes(AvailableSpace const&, GridDimension const);
LibWeb: Implement more of spanning tracks sizing in GFC Implements more parts of sizing algorithm for tracks with spanning items to archive parity with implementation for sizing of tracks with non-spanning items.
2023-05-20 17:46:21 +03:00
void increase_sizes_to_accommodate_spanning_items_crossing_content_sized_tracks(AvailableSpace const&, GridDimension const, size_t span);
LibWeb: Start implementing sizing for tracks with span > 1 items in GFC Partially implements: - Increase sizes to accommodate spanning items crossing content-sized tracks - Increase sizes to accommodate spanning items crossing flexible tracks from https://www.w3.org/TR/css-grid-2/#algo-content
2023-05-14 19:16:26 +03:00
void increase_sizes_to_accommodate_spanning_items_crossing_flexible_tracks(GridDimension const);
LibWeb: Separate grid tracks from gaps in GFC This change is supposed to solve the problem that currenty when grid tracks are interleaved with gaps it is impossible to iterate tracks spanned by a specific grid item. There is a pair of functions: gap_adjusted_row() and gap_adjusted_column() but they won't work when it comes to items spanning > 1 track. Separating gaps from tracks is going to make it possible to iterate just tracks or both tracks and gaps when it is required. And now tracks spanned by an item can be accessed by just index without doing any additional math.
2023-05-14 15:23:39 +03:00
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);
LibWeb: Fix regression in definite grid row heights Fixes a row height bug when a grid item in a row has a definite height.
2023-04-01 19:09:19 +02:00
LibWeb: Align calculate_min/max_content_contribution with the spec This change brings more spec compliant implementation of functions to calculate min/max contributions of grid items in containing block size.
2023-05-13 05:51:39 +03:00
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;
LibWeb: Flesh out basic support of min-width/height for grid items This change brings calculate_minimum_contribution() for grid items and supporting functions.
2023-05-13 15:17:24 +03:00
CSSPixels calculate_limited_min_content_contribution(GridItem const&, GridDimension const) const;
CSSPixels calculate_limited_max_content_contribution(GridItem const&, GridDimension const) const;
LibWeb: Align calculate_min/max_content_contribution with the spec This change brings more spec compliant implementation of functions to calculate min/max contributions of grid items in containing block size.
2023-05-13 05:51:39 +03:00
CSSPixels containing_block_size_for_item(GridItem const&, GridDimension const) const;
AvailableSpace get_available_space_for_item(GridItem const&) const;
LibWeb: Flesh out basic support of min-width/height for grid items This change brings calculate_minimum_contribution() for grid items and supporting functions.
2023-05-13 15:17:24 +03:00
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;
LibWeb: Factor out OccupationGrid functions Clean up the code by using an OccupationGrid class. This was a neat idea proposed by MacDue.
2022-10-01 14:08:34 +02:00
};
LibWeb: Add GridFormattingContext
2022-08-23 10:36:27 +02:00
}
Reference in a new issue Copy permalink