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

196 lines
7 KiB
C
Raw Normal View History

LibWeb: Reorganize layout system in terms of formatting contexts This is a first (huge) step towards modernizing the layout architecture and bringing it closer to spec language. Layout is now performed by a stack of formatting contexts, operating on the box tree (or layout tree, if you will.) There are currently three types of formatting context: - BlockFormattingContext (BFC) - InlineFormattingContext (IFC) - TableFormattingContext (TFC) Document::layout() creates the initial BlockFormattingContext (BFC) which lays out the initial containing block (ICB), and then we recurse through the tree, creating BFC, IFC or TFC as appropriate and handing over control at the context boundaries. The majority of this patch is just refactoring the old logic spread out in LayoutBlock and LayoutTableRowGroup, and turning into these context classes instead. A lot more cleanup will be needed. There are many architectural wins here, the main one being that layout is no longer performed by boxes themselves, which gives us much greater flexibility in the outer/inner layout of a given box.
2020-11-22 13:38:18 +01:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 13:19:50 +02:00
* Copyright (c) 2020, Andreas Kling <andreas@ladybird.org>
LibWeb: Reorganize layout system in terms of formatting contexts This is a first (huge) step towards modernizing the layout architecture and bringing it closer to spec language. Layout is now performed by a stack of formatting contexts, operating on the box tree (or layout tree, if you will.) There are currently three types of formatting context: - BlockFormattingContext (BFC) - InlineFormattingContext (IFC) - TableFormattingContext (TFC) Document::layout() creates the initial BlockFormattingContext (BFC) which lays out the initial containing block (ICB), and then we recurse through the tree, creating BFC, IFC or TFC as appropriate and handing over control at the context boundaries. The majority of this patch is just refactoring the old logic spread out in LayoutBlock and LayoutTableRowGroup, and turning into these context classes instead. A lot more cleanup will be needed. There are many architectural wins here, the main one being that layout is no longer performed by boxes themselves, which gives us much greater flexibility in the outer/inner layout of a given box.
2020-11-22 13:38:18 +01:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
LibWeb: Reorganize layout system in terms of formatting contexts This is a first (huge) step towards modernizing the layout architecture and bringing it closer to spec language. Layout is now performed by a stack of formatting contexts, operating on the box tree (or layout tree, if you will.) There are currently three types of formatting context: - BlockFormattingContext (BFC) - InlineFormattingContext (IFC) - TableFormattingContext (TFC) Document::layout() creates the initial BlockFormattingContext (BFC) which lays out the initial containing block (ICB), and then we recurse through the tree, creating BFC, IFC or TFC as appropriate and handing over control at the context boundaries. The majority of this patch is just refactoring the old logic spread out in LayoutBlock and LayoutTableRowGroup, and turning into these context classes instead. A lot more cleanup will be needed. There are many architectural wins here, the main one being that layout is no longer performed by boxes themselves, which gives us much greater flexibility in the outer/inner layout of a given box.
2020-11-22 13:38:18 +01:00
*/
#pragma once
#include <AK/Forward.h>
LibWeb: Inherit TableFormattingContext from FC instead of BFC
2022-12-04 21:57:21 +03:00
#include <LibWeb/Layout/FormattingContext.h>
LibWeb: Move table grid slots functionality to separate module
2023-08-20 03:08:38 +00:00
#include <LibWeb/Layout/TableGrid.h>
LibWeb: Table box width should be relative to wrapper containing block
2023-01-14 15:05:08 +01:00
#include <LibWeb/Layout/TableWrapper.h>
LibWeb: Reorganize layout system in terms of formatting contexts This is a first (huge) step towards modernizing the layout architecture and bringing it closer to spec language. Layout is now performed by a stack of formatting contexts, operating on the box tree (or layout tree, if you will.) There are currently three types of formatting context: - BlockFormattingContext (BFC) - InlineFormattingContext (IFC) - TableFormattingContext (TFC) Document::layout() creates the initial BlockFormattingContext (BFC) which lays out the initial containing block (ICB), and then we recurse through the tree, creating BFC, IFC or TFC as appropriate and handing over control at the context boundaries. The majority of this patch is just refactoring the old logic spread out in LayoutBlock and LayoutTableRowGroup, and turning into these context classes instead. A lot more cleanup will be needed. There are many architectural wins here, the main one being that layout is no longer performed by boxes themselves, which gives us much greater flexibility in the outer/inner layout of a given box.
2020-11-22 13:38:18 +01:00
namespace Web::Layout {
LibWeb: Some row span fixes when combined with nested tables Add logic to compute {min, max}-height and use min-height when calculating table height, per specifications. Fixes some issues with phylogenetic tree visualizations on Wikipedia.
2023-06-08 03:37:26 +00:00
enum class TableDimension {
Row,
Column
};
LibWeb: Inherit TableFormattingContext from FC instead of BFC
2022-12-04 21:57:21 +03:00
class TableFormattingContext final : public FormattingContext {
LibWeb: Reorganize layout system in terms of formatting contexts This is a first (huge) step towards modernizing the layout architecture and bringing it closer to spec language. Layout is now performed by a stack of formatting contexts, operating on the box tree (or layout tree, if you will.) There are currently three types of formatting context: - BlockFormattingContext (BFC) - InlineFormattingContext (IFC) - TableFormattingContext (TFC) Document::layout() creates the initial BlockFormattingContext (BFC) which lays out the initial containing block (ICB), and then we recurse through the tree, creating BFC, IFC or TFC as appropriate and handing over control at the context boundaries. The majority of this patch is just refactoring the old logic spread out in LayoutBlock and LayoutTableRowGroup, and turning into these context classes instead. A lot more cleanup will be needed. There are many architectural wins here, the main one being that layout is no longer performed by boxes themselves, which gives us much greater flexibility in the outer/inner layout of a given box.
2020-11-22 13:38:18 +01:00
public:
LibWeb: Save layout mode inside formatting context object FormattingContext::run() does not allow reentrancy, so it's safe to save and access layout mode from FC object. This avoids need to drill it through methods of a formatting context and makes it clear that this value could never be changed after FC construction.
2024-09-11 01:03:02 +02:00
explicit TableFormattingContext(LayoutState&, LayoutMode, Box const&, FormattingContext* parent);
LibWeb: Reorganize layout system in terms of formatting contexts This is a first (huge) step towards modernizing the layout architecture and bringing it closer to spec language. Layout is now performed by a stack of formatting contexts, operating on the box tree (or layout tree, if you will.) There are currently three types of formatting context: - BlockFormattingContext (BFC) - InlineFormattingContext (IFC) - TableFormattingContext (TFC) Document::layout() creates the initial BlockFormattingContext (BFC) which lays out the initial containing block (ICB), and then we recurse through the tree, creating BFC, IFC or TFC as appropriate and handing over control at the context boundaries. The majority of this patch is just refactoring the old logic spread out in LayoutBlock and LayoutTableRowGroup, and turning into these context classes instead. A lot more cleanup will be needed. There are many architectural wins here, the main one being that layout is no longer performed by boxes themselves, which gives us much greater flexibility in the outer/inner layout of a given box.
2020-11-22 13:38:18 +01:00
~TableFormattingContext();
LibWeb: Remove `box` argument from FormattingContext::run() Root formatting context box is passed into constructor and saved in FC, so it's possible to access it from there instead of passing the same box into run().
2024-09-11 00:28:22 +02:00
void run_until_width_calculation(AvailableSpace const& available_space);
LibWeb: Skip cells layout in table box width calculation There is no need to run full table layout if we are only interested in calculating its width. This change reduces compute_table_box_width_inside_table_wrapper() from ~30% to ~15% in profiles of "File changed" pages on github.
2024-03-19 10:18:49 +01:00
LibWeb: Save layout mode inside formatting context object FormattingContext::run() does not allow reentrancy, so it's safe to save and access layout mode from FC object. This avoids need to drill it through methods of a formatting context and makes it clear that this value could never be changed after FC construction.
2024-09-11 01:03:02 +02:00
virtual void run(AvailableSpace const&) 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: Define static position calculation separately for each FC Static position of a box is defined by formatting context type it belongs to, so let's define this algorithm separately for each FC instead of assuming FormattingContext::calculate_static_position_rect() understands how to handle all of them. Also with this change calculate_static_position_rect() is no longer virtual function.
2024-10-05 22:18:53 +02:00
StaticPositionRect calculate_static_position_rect(Box const&) const;
LibWeb: Reorganize layout system in terms of formatting contexts This is a first (huge) step towards modernizing the layout architecture and bringing it closer to spec language. Layout is now performed by a stack of formatting contexts, operating on the box tree (or layout tree, if you will.) There are currently three types of formatting context: - BlockFormattingContext (BFC) - InlineFormattingContext (IFC) - TableFormattingContext (TFC) Document::layout() creates the initial BlockFormattingContext (BFC) which lays out the initial containing block (ICB), and then we recurse through the tree, creating BFC, IFC or TFC as appropriate and handing over control at the context boundaries. The majority of this patch is just refactoring the old logic spread out in LayoutBlock and LayoutTableRowGroup, and turning into these context classes instead. A lot more cleanup will be needed. There are many architectural wins here, the main one being that layout is no longer performed by boxes themselves, which gives us much greater flexibility in the outer/inner layout of a given box.
2020-11-22 13:38:18 +01:00
LibWeb: Remove Layout::TableBox Solves conflict in layout tree "type system" when elements <label> (or <button>) can't have `display: table` because Box can't be Layout::Label (or Layout::ButtonBox) and Layout::TableBox at the same time.
2023-05-29 14:11:19 +03:00
Box const& table_box() const { return context_box(); }
LibWeb: Table box width should be relative to wrapper containing block
2023-01-14 15:05:08 +01:00
TableWrapper const& table_wrapper() const
{
AK+Everywhere: Rename `verify_cast` to `as` Follow-up to fc20e61e7249006247b43f84a3189d5a37fa103e.
2025-01-21 09:12:05 -05:00
return as<TableWrapper>(*table_box().containing_block());
LibWeb: Table box width should be relative to wrapper containing block
2023-01-14 15:05:08 +01:00
}
LibWeb: Use `table_box()` to get root box in TFC Introduce `table_box()` function that returns table formatting context root box casted to `TableBox` similar to how it's done in other formatting contexts like `root()` in BFC and `flex_container` in FFC. And replace `context_box()` calls in TFC with calls to `table_box()`.
2023-01-08 01:54:25 +03:00
LibWeb: Some improvements for painting of collapsed table borders Follow the specification in making the borders centered on the grid lines. This avoids visual bugs due to double-rendering of borders on either side of an edge and paves the way for a full implementation of the harmonization algorithm for collapsed borders. Currently, this still lacks complete handling of row and column spans. Also, the box model for cells still considers the full width of the internal borders instead of just half, as the specification requires. Some additional handling of rounding issues will be needed to avoid very subtle visual bugs. Despite these limitations, this improves the appearance of all the tables with collapsed borders I've tried while limiting the amount of change to something reasonable.
2023-07-01 03:06:21 +00:00
static bool border_is_less_specific(const CSS::BorderData& a, const CSS::BorderData& b);
LibWeb: Assign static position for abspos boxes nested into TFC TFC is not aware of how to correctly calculate a static position for abspos boxes, but assigning (0, 0) is better than crashing during abspos item layout. Fixes https://github.com/LadybirdBrowser/ladybird/issues/1382
2024-09-13 22:42:43 +02:00
virtual void parent_context_did_dimension_child_root_box() override;
LibWeb: Reorganize layout system in terms of formatting contexts This is a first (huge) step towards modernizing the layout architecture and bringing it closer to spec language. Layout is now performed by a stack of formatting contexts, operating on the box tree (or layout tree, if you will.) There are currently three types of formatting context: - BlockFormattingContext (BFC) - InlineFormattingContext (IFC) - TableFormattingContext (TFC) Document::layout() creates the initial BlockFormattingContext (BFC) which lays out the initial containing block (ICB), and then we recurse through the tree, creating BFC, IFC or TFC as appropriate and handing over control at the context boundaries. The majority of this patch is just refactoring the old logic spread out in LayoutBlock and LayoutTableRowGroup, and turning into these context classes instead. A lot more cleanup will be needed. There are many architectural wins here, the main one being that layout is no longer performed by boxes themselves, which gives us much greater flexibility in the outer/inner layout of a given box.
2020-11-22 13:38:18 +01:00
private:
LibWeb: Save layout mode inside formatting context object FormattingContext::run() does not allow reentrancy, so it's safe to save and access layout mode from FC object. This avoids need to drill it through methods of a formatting context and makes it clear that this value could never be changed after FC construction.
2024-09-11 01:03:02 +02:00
CSSPixels run_caption_layout(CSS::CaptionSide);
LibWeb: Add support for table caption Adds layout support and the CSS caption-side property.
2023-06-07 02:10:55 +00:00
CSSPixels compute_capmin();
LibWeb: Check column or row size attributes for constrainedness Better aligns our implementation with the specification, which requires that columns and groups of columns are checked too.
2023-07-15 01:12:10 +00:00
void compute_constrainedness();
LibWeb: Use cell width instead available width to compute height Overall available width should only affect later stages of the table layout algorithm and have no impact on cell measures.
2023-08-12 23:48:36 +00:00
void compute_cell_measures();
LibWeb: Use column and row size for cell outer sizes Better aligns our implementation with the specification, which requires that we check columns and column groups too.
2023-07-15 01:41:42 +00:00
void compute_outer_content_sizes();
LibWeb: Some row span fixes when combined with nested tables Add logic to compute {min, max}-height and use min-height when calculating table height, per specifications. Fixes some issues with phylogenetic tree visualizations on Wikipedia.
2023-06-08 03:37:26 +00:00
template<class RowOrColumn>
LibWeb: Fix min-content initialization for row measures This ensures that min-content contributions from cells with no content are computed using their calculated values, which are never considered for min-content before then. The specification diverges from column measures algorithm, which doesn't use specified width of cells anywhere.
2023-06-26 02:48:09 +00:00
void initialize_table_measures();
template<class RowOrColumn>
LibWeb: Start implementation of CSS Table 3 spec Here I try to address bug where content of table overflows it's width (hacker news is an example of such site) by reimplementing some parts of table formatting context. Now TFC implements first steps of: https://www.w3.org/TR/css-tables-3/#table-layout-algorithm but column width and row height distribution steps are still very incomplete.
2022-12-04 22:39:38 +03:00
void compute_table_measures();
LibWeb: Implement iterative percentage size for spanning table cells Follow the computing column measures section of the specification, which gives an algorithm for setting intrinsic percentage widths when spanning columns are involved.
2023-07-17 01:22:11 +00:00
template<class RowOrColumn>
void compute_intrinsic_percentage(size_t max_cell_span);
LibWeb: Consider percent and fixed widths in table column distribution Change column distribution to take in account is_length() and is_percentage() width values instead of treating all cells like they have auto width by implementing it in the way described in CSS Tables 3 spec: https://www.w3.org/TR/css-tables-3/#width-distribution-algorithm distribute_width_to_column() is structured to follow schema: w3.org/TR/css-tables-3/images/CSS-Tables-Column-Width-Assignment.svg
2023-01-05 18:56:34 +03:00
void compute_table_width();
void distribute_width_to_columns();
LibWeb: Distribute excess width to columns as in specification
2023-07-15 02:46:47 +00:00
void distribute_excess_width_to_columns(CSSPixels available_width);
LibWeb: Implement fixed table layout
2023-08-07 01:33:37 +00:00
void distribute_excess_width_to_columns_fixed_mode(CSSPixels excess_width);
LibWeb: Save layout mode inside formatting context object FormattingContext::run() does not allow reentrancy, so it's safe to save and access layout mode from FC object. This avoids need to drill it through methods of a formatting context and makes it clear that this value could never be changed after FC construction.
2024-09-11 01:03:02 +02:00
void compute_table_height();
LibWeb: Implement "distribute height to rows" step in TFC This commit implements following missing steps in table layout: - Calculate final table height - Resolve percentage height of cells and rows using final table height - Distribute avilable height to table rows
2023-04-29 00:43:05 +03:00
void distribute_height_to_rows();
LibWeb: Take specified height into account for automatic table height Track table grid height stretched to the specified height and use it to set the final box height in TFC. Fixes #19563.
2023-06-22 17:22:12 +00:00
void position_row_boxes();
LibWeb: Move cells positioning in separate function in TFC
2023-01-08 00:57:57 +03:00
void position_cell_boxes();
LibWeb: Add partial implementation of border conflict resolution Fix handling of border style specified per column as well.
2023-06-04 14:21:20 +00:00
void border_conflict_resolution();
LibWeb: Add layout support for border spacing When border-collapse is separate, border-spacing affects layout. Implement most of that functionality.
2023-06-16 02:48:56 +00:00
CSSPixels border_spacing_horizontal() const;
CSSPixels border_spacing_vertical() const;
LibWeb: Move table grid slots functionality to separate module
2023-08-20 03:08:38 +00:00
void finish_grid_initialization(TableGrid const&);
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: Distribute excess width to columns as in specification
2023-07-15 02:46:47 +00:00
CSSPixels compute_columns_total_used_width() const;
void commit_candidate_column_widths(Vector<CSSPixels> const& candidate_widths);
void assign_columns_width_linear_combination(Vector<CSSPixels> const& candidate_widths, CSSPixels available_width);
LibWeb: Implement fixed table layout
2023-08-07 01:33:37 +00:00
template<class ColumnFilter, class BaseWidthGetter>
bool distribute_excess_width_proportionally_to_base_width(CSSPixels excess_width, ColumnFilter column_filter, BaseWidthGetter base_width_getter);
LibWeb: Distribute excess width to columns as in specification
2023-07-15 02:46:47 +00:00
template<class ColumnFilter>
bool distribute_excess_width_equally(CSSPixels excess_width, ColumnFilter column_filter);
template<class ColumnFilter>
bool distribute_excess_width_by_intrinsic_percentage(CSSPixels excess_width, ColumnFilter column_filter);
LibWeb: Implement fixed table layout
2023-08-07 01:33:37 +00:00
bool use_fixed_mode_layout() const;
LibWeb: Implement "distribute height to rows" step in TFC This commit implements following missing steps in table layout: - Calculate final table height - Resolve percentage height of cells and rows using final table height - Distribute avilable height to table rows
2023-04-29 00:43:05 +03:00
CSSPixels m_table_height { 0 };
LibWeb: Convert TableFormattingContext to new pixel units
2022-12-15 12:57:36 +00:00
CSSPixels m_automatic_content_height { 0 };
LibWeb: Start implementation of CSS Table 3 spec Here I try to address bug where content of table overflows it's width (hacker news is an example of such site) by reimplementing some parts of table formatting context. Now TFC implements first steps of: https://www.w3.org/TR/css-tables-3/#table-layout-algorithm but column width and row height distribution steps are still very incomplete.
2022-12-04 22:39:38 +03:00
LibWeb: Use available space to resolve table cells width It is not possible to use width of containing block to resolve cells width because by the time compute_table_measures() is called row width is not known yet.
2023-01-05 18:44:04 +03:00
Optional<AvailableSpace> m_available_space;
LibWeb: Start implementation of CSS Table 3 spec Here I try to address bug where content of table overflows it's width (hacker news is an example of such site) by reimplementing some parts of table formatting context. Now TFC implements first steps of: https://www.w3.org/TR/css-tables-3/#table-layout-algorithm but column width and row height distribution steps are still very incomplete.
2022-12-04 22:39:38 +03:00
struct Column {
LibWeb: Convert TableFormattingContext to new pixel units
2022-12-15 12:57:36 +00:00
CSSPixels left_offset { 0 };
LibWeb: Some row span fixes when combined with nested tables Add logic to compute {min, max}-height and use min-height when calculating table height, per specifications. Fixes some issues with phylogenetic tree visualizations on Wikipedia.
2023-06-08 03:37:26 +00:00
CSSPixels min_size { 0 };
CSSPixels max_size { 0 };
LibWeb: Convert TableFormattingContext to new pixel units
2022-12-15 12:57:36 +00:00
CSSPixels used_width { 0 };
LibWeb: Use intrinsic_percentage instead of percentage_{width, height} Follow the terminology from specification.
2023-07-17 00:23:07 +00:00
bool has_intrinsic_percentage { false };
double intrinsic_percentage { 0 };
LibWeb: Don't distribute excess width to constrained columns Bring our implementation closer to the specification, which distributes excess width to unconstrained columns first.
2023-06-28 03:06:03 +00:00
// Store whether the column is constrained: https://www.w3.org/TR/css-tables-3/#constrainedness
bool is_constrained { false };
LibWeb: Distribute excess width to columns as in specification
2023-07-15 02:46:47 +00:00
// Store whether the column has originating cells, defined in https://www.w3.org/TR/css-tables-3/#terminology.
bool has_originating_cells { false };
LibWeb: Start implementation of CSS Table 3 spec Here I try to address bug where content of table overflows it's width (hacker news is an example of such site) by reimplementing some parts of table formatting context. Now TFC implements first steps of: https://www.w3.org/TR/css-tables-3/#table-layout-algorithm but column width and row height distribution steps are still very incomplete.
2022-12-04 22:39:38 +03:00
};
LibWeb: Move table grid slots functionality to separate module
2023-08-20 03:08:38 +00:00
using Cell = TableGrid::Cell;
using Row = TableGrid::Row;
LibWeb: Start implementation of CSS Table 3 spec Here I try to address bug where content of table overflows it's width (hacker news is an example of such site) by reimplementing some parts of table formatting context. Now TFC implements first steps of: https://www.w3.org/TR/css-tables-3/#table-layout-algorithm but column width and row height distribution steps are still very incomplete.
2022-12-04 22:39:38 +03:00
LibWeb: Some row span fixes when combined with nested tables Add logic to compute {min, max}-height and use min-height when calculating table height, per specifications. Fixes some issues with phylogenetic tree visualizations on Wikipedia.
2023-06-08 03:37:26 +00:00
// Accessors to enable direction-agnostic table measurement.
template<class RowOrColumn>
static size_t cell_span(Cell const& cell);
template<class RowOrColumn>
static size_t cell_index(Cell const& cell);
template<class RowOrColumn>
static CSSPixels cell_min_size(Cell const& cell);
template<class RowOrColumn>
static CSSPixels cell_max_size(Cell const& cell);
LibWeb: Implement iterative percentage size for spanning table cells Follow the computing column measures section of the specification, which gives an algorithm for setting intrinsic percentage widths when spanning columns are involved.
2023-07-17 01:22:11 +00:00
template<class RowOrColumn>
static double cell_percentage_contribution(Cell const& cell);
template<class RowOrColumn>
static bool cell_has_intrinsic_percentage(Cell const& cell);
template<class RowOrColumn>
void initialize_intrinsic_percentages_from_rows_or_columns();
template<class RowOrColumn>
void initialize_intrinsic_percentages_from_cells();
LibWeb: Add layout support for border spacing When border-collapse is separate, border-spacing affects layout. Implement most of that functionality.
2023-06-16 02:48:56 +00:00
template<class RowOrColumn>
CSSPixels border_spacing();
LibWeb: Some row span fixes when combined with nested tables Add logic to compute {min, max}-height and use min-height when calculating table height, per specifications. Fixes some issues with phylogenetic tree visualizations on Wikipedia.
2023-06-08 03:37:26 +00:00
template<class RowOrColumn>
Vector<RowOrColumn>& table_rows_or_columns();
LibWeb: Implement table rowspan Adjust computing the table height and positioning of cells to account for the rowspan property. Fixes #18952.
2023-05-18 03:55:39 +00:00
CSSPixels compute_row_content_height(Cell const& cell) const;
LibWeb: Resolve table border conflicts at edge level This better conforms to specification, which describes border conflict resolution by edge, not by element.
2023-07-02 03:39:06 +00:00
enum class ConflictingSide {
LibWeb: Add partial implementation of border conflict resolution Fix handling of border style specified per column as well.
2023-06-04 14:21:20 +00:00
Top,
Bottom,
Left,
LibWeb: Resolve table border conflicts at edge level This better conforms to specification, which describes border conflict resolution by edge, not by element.
2023-07-02 03:39:06 +00:00
Right,
LibWeb: Add partial implementation of border conflict resolution Fix handling of border style specified per column as well.
2023-06-04 14:21:20 +00:00
};
LibWeb: Resolve table border conflicts at edge level This better conforms to specification, which describes border conflict resolution by edge, not by element.
2023-07-02 03:39:06 +00:00
struct ConflictingEdge {
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<Node const> element;
LibWeb: Complete table border conflict resolution Add the element type and grid position to the algorithm and change the table borders painting to apply the new criteria to corners as well.
2023-07-12 04:20:37 +00:00
Painting::PaintableBox::ConflictingElementKind element_kind;
LibWeb: Resolve table border conflicts at edge level This better conforms to specification, which describes border conflict resolution by edge, not by element.
2023-07-02 03:39:06 +00:00
ConflictingSide side;
LibWeb: Complete table border conflict resolution Add the element type and grid position to the algorithm and change the table borders painting to apply the new criteria to corners as well.
2023-07-12 04:20:37 +00:00
Optional<size_t> row;
Optional<size_t> column;
LibWeb: Resolve table border conflicts at edge level This better conforms to specification, which describes border conflict resolution by edge, not by element.
2023-07-02 03:39:06 +00:00
};
LibWeb: Complete table border conflict resolution Add the element type and grid position to the algorithm and change the table borders painting to apply the new criteria to corners as well.
2023-07-12 04:20:37 +00:00
static TableFormattingContext::ConflictingEdge const& winning_conflicting_edge(TableFormattingContext::ConflictingEdge const& a, TableFormattingContext::ConflictingEdge const& b);
LibWeb: Resolve table border conflicts with cells Build a mapping from coordinates to cells and use it to resolve border conflicts between adjacent cells.
2023-07-09 03:02:54 +00:00
static const CSS::BorderData& border_data_conflicting_edge(ConflictingEdge const& conflicting_edge);
LibWeb: Skip cells layout in table box width calculation There is no need to run full table layout if we are only interested in calculating its width. This change reduces compute_table_box_width_inside_table_wrapper() from ~30% to ~15% in profiles of "File changed" pages on github.
2024-03-19 10:18:49 +01:00
static Painting::PaintableBox::BorderDataWithElementKind const border_data_with_element_kind_from_conflicting_edge(ConflictingEdge const& conflicting_edge);
LibWeb: Resolve table border conflicts at edge level This better conforms to specification, which describes border conflict resolution by edge, not by element.
2023-07-02 03:39:06 +00:00
LibWeb: Add partial implementation of border conflict resolution Fix handling of border style specified per column as well.
2023-06-04 14:21:20 +00:00
class BorderConflictFinder {
public:
BorderConflictFinder(TableFormattingContext const* context);
LibWeb: Resolve table border conflicts at edge level This better conforms to specification, which describes border conflict resolution by edge, not by element.
2023-07-02 03:39:06 +00:00
Vector<ConflictingEdge> conflicting_edges(Cell const&, ConflictingSide) const;
LibWeb: Add partial implementation of border conflict resolution Fix handling of border style specified per column as well.
2023-06-04 14:21:20 +00:00
private:
void collect_conflicting_col_elements();
LibWeb: Add border conflict resolution with rowgroup
2023-07-09 23:04:24 +00:00
void collect_conflicting_row_group_elements();
LibWeb: Split BorderConflictFinder::conflicting_edges method Make it clearer which edges and elements are considered at each step.
2023-07-19 03:07:39 +00:00
void collect_cell_conflicting_edges(Vector<ConflictingEdge>&, Cell const&, ConflictingSide) const;
void collect_row_conflicting_edges(Vector<ConflictingEdge>&, Cell const&, ConflictingSide) const;
void collect_row_group_conflicting_edges(Vector<ConflictingEdge>&, Cell const&, ConflictingSide) const;
void collect_column_group_conflicting_edges(Vector<ConflictingEdge>&, Cell const&, ConflictingSide) const;
void collect_table_box_conflicting_edges(Vector<ConflictingEdge>&, Cell const&, ConflictingSide) const;
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<Node const> get_col_element(size_t index) const
LibWeb: Fix out-of-bound crash when there's more table cells than cols Added a getter to ensure we are within a valid range. This behavior is accepted by other browsers, and crashed on some pages.
2024-11-05 01:13:57 +01:00
{
if (index >= m_col_elements_by_index.size())
return {};
return m_col_elements_by_index[index];
}
LibWeb: Add border conflict resolution with rowgroup
2023-07-09 23:04:24 +00:00
struct RowGroupInfo {
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<Node const> row_group;
LibWeb: Add border conflict resolution with rowgroup
2023-07-09 23:04:24 +00:00
size_t start_index;
size_t row_count;
};
LibWeb: Add partial implementation of border conflict resolution Fix handling of border style specified per column as well.
2023-06-04 14:21:20 +00:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
Vector<GC::Ptr<Node const>> m_col_elements_by_index;
LibWeb: Add border conflict resolution with rowgroup
2023-07-09 23:04:24 +00:00
Vector<Optional<RowGroupInfo>> m_row_group_elements_by_index;
LibWeb: Add partial implementation of border conflict resolution Fix handling of border style specified per column as well.
2023-06-04 14:21:20 +00:00
TableFormattingContext const* m_context;
};
LibWeb: Start implementation of CSS Table 3 spec Here I try to address bug where content of table overflows it's width (hacker news is an example of such site) by reimplementing some parts of table formatting context. Now TFC implements first steps of: https://www.w3.org/TR/css-tables-3/#table-layout-algorithm but column width and row height distribution steps are still very incomplete.
2022-12-04 22:39:38 +03:00
Vector<Cell> m_cells;
LibWeb: Resolve table border conflicts with cells Build a mapping from coordinates to cells and use it to resolve border conflicts between adjacent cells.
2023-07-09 03:02:54 +00:00
Vector<Vector<Optional<Cell const&>>> m_cells_by_coordinate;
LibWeb: Start implementation of CSS Table 3 spec Here I try to address bug where content of table overflows it's width (hacker news is an example of such site) by reimplementing some parts of table formatting context. Now TFC implements first steps of: https://www.w3.org/TR/css-tables-3/#table-layout-algorithm but column width and row height distribution steps are still very incomplete.
2022-12-04 22:39:38 +03:00
Vector<Column> m_columns;
Vector<Row> m_rows;
LibWeb: Reorganize layout system in terms of formatting contexts This is a first (huge) step towards modernizing the layout architecture and bringing it closer to spec language. Layout is now performed by a stack of formatting contexts, operating on the box tree (or layout tree, if you will.) There are currently three types of formatting context: - BlockFormattingContext (BFC) - InlineFormattingContext (IFC) - TableFormattingContext (TFC) Document::layout() creates the initial BlockFormattingContext (BFC) which lays out the initial containing block (ICB), and then we recurse through the tree, creating BFC, IFC or TFC as appropriate and handing over control at the context boundaries. The majority of this patch is just refactoring the old logic spread out in LayoutBlock and LayoutTableRowGroup, and turning into these context classes instead. A lot more cleanup will be needed. There are many architectural wins here, the main one being that layout is no longer performed by boxes themselves, which gives us much greater flexibility in the outer/inner layout of a given box.
2020-11-22 13:38:18 +01:00
};
}
Reference in a new issue Copy permalink