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

256 lines
10 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: Refactor GridFormattingContext For legibility, split up the run() function of the GridFormattingContext into individual components.
2022-12-28 10:12:30 +01:00
class OccupationGrid {
public:
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
OccupationGrid(size_t column_count, size_t row_count);
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();
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
void maybe_add_column(size_t needed_number_of_columns);
void maybe_add_row(size_t needed_number_of_rows);
void set_occupied(size_t column_start, size_t column_end, size_t row_start, size_t row_end);
void set_occupied(size_t column_index, size_t row_index);
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 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 column_count() { return m_occupation_grid[0].size(); }
size_t row_count() { return m_occupation_grid.size(); }
bool is_occupied(size_t column_index, size_t row_index);
LibWeb: Refactor GridFormattingContext For legibility, split up the run() function of the GridFormattingContext into individual components.
2022-12-28 10:12:30 +01:00
private:
Vector<Vector<bool>> 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
class GridItem {
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
public:
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
GridItem(Box const& box, int row, int row_span, int column, int 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
: m_box(box)
, m_row(row)
, m_row_span(row_span)
, m_column(column)
, m_column_span(column_span)
{
}
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
Box const& box() const { return m_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: 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
size_t span(GridDimension const dimension) const
{
return dimension == GridDimension::Column ? m_column_span : m_row_span;
}
size_t raw_position(GridDimension const dimension) const
{
return dimension == GridDimension::Column ? m_column : m_row;
}
LibWeb: Resolve grid item fixed size paddings in GFC Adds support for grid items with fixed size paddings. Supporting percentage paddings will probably require to do second pass of tracks layout: second pass is needed to recalculate tracks sizes when final items sizes are known when percentage paddings are already resolved.
2023-05-18 22:33:40 +03:00
CSSPixels add_border_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: Resolve grid item fixed size paddings in GFC Adds support for grid items with fixed size paddings. Supporting percentage paddings will probably require to do second pass of tracks layout: second pass is needed to recalculate tracks sizes when final items sizes are known when percentage paddings are already resolved.
2023-05-18 22:33:40 +03:00
auto& box_state = state.get(box());
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
if (dimension == GridDimension::Column) {
LibWeb: Resolve grid item fixed size paddings in GFC Adds support for grid items with fixed size paddings. Supporting percentage paddings will probably require to do second pass of tracks layout: second pass is needed to recalculate tracks sizes when final items sizes are known when percentage paddings are already resolved.
2023-05-18 22:33:40 +03:00
return box_state.border_left + box_state.padding_left + content_size + box_state.padding_right + box_state.border_right;
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
} else {
LibWeb: Resolve grid item fixed size paddings in GFC Adds support for grid items with fixed size paddings. Supporting percentage paddings will probably require to do second pass of tracks layout: second pass is needed to recalculate tracks sizes when final items sizes are known when percentage paddings are already resolved.
2023-05-18 22:33:40 +03:00
return box_state.border_top + box_state.padding_top + content_size + box_state.padding_bottom + box_state.border_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: 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
size_t raw_row() const { return m_row; }
size_t raw_column() const { return m_column; }
size_t raw_row_span() const { return m_row_span; }
size_t raw_column_span() const { return m_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: 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 gap_adjusted_row(Box const& grid_box) const;
size_t 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
private:
LibJS+LibWeb: Wrap raw JS::Cell*/& fields in GCPtr/NonnullGCPtr
2023-02-26 16:09:02 -07:00
JS::NonnullGCPtr<Box const> m_box;
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 m_row { 0 };
size_t m_row_span { 1 };
size_t m_column { 0 };
size_t m_column_span { 1 };
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: 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: 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: 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
struct TemporaryTrack {
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: Convert GridFormattingContext to new pixel units
2022-11-04 20:18:48 +00:00
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
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)
{
}
LibWeb: Convert GridFormattingContext to new pixel units
2022-11-04 20:18:48 +00:00
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)
LibWeb: Implement gap in CSS Grid
2022-11-06 13:45:05 +01:00
, is_gap(is_gap)
{
}
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
TemporaryTrack()
: min_track_sizing_function(CSS::GridSize::make_auto())
, max_track_sizing_function(CSS::GridSize::make_auto())
{
}
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
};
Vector<GridArea> m_valid_grid_areas;
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
Vector<TemporaryTrack> m_grid_rows;
Vector<TemporaryTrack> 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: 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;
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);
}
}
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
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;
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;
LibJS+LibWeb: Wrap raw JS::Cell*/& fields in GCPtr/NonnullGCPtr
2023-02-26 16:09:02 -07:00
Vector<JS::NonnullGCPtr<Box const>> m_boxes_to_place;
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: 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: 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 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 build_valid_grid_areas();
LibWeb: Place grid items in grid-areas if applicable If valid grid-template-areas were given, then place grid items within these areas. Grid-template-areas take precedence over named line tracks, meaning if there are grid-areas as well as named tracks, should use the grid-areas.
2023-01-17 14:07:28 +01:00
int find_valid_grid_area(String const& needle);
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: 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_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&);
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: 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 distribute_extra_space_across_spanned_tracks_base_size(CSSPixels item_size_contribution, Vector<TemporaryTrack&>& spanned_tracks);
void distribute_extra_space_across_spanned_tracks_growth_limit(CSSPixels item_size_contribution, Vector<TemporaryTrack&>& spanned_tracks);
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