From 55ddfa9348d4000c564f35f59d547e13d1090ce5 Mon Sep 17 00:00:00 2001 From: Sam Atkins Date: Fri, 4 Nov 2022 20:18:48 +0000 Subject: [PATCH] LibWeb: Convert GridFormattingContext to new pixel units --- .../LibWeb/Layout/GridFormattingContext.cpp | 68 +++++++++---------- .../LibWeb/Layout/GridFormattingContext.h | 26 +++---- 2 files changed, 47 insertions(+), 47 deletions(-) diff --git a/Userland/Libraries/LibWeb/Layout/GridFormattingContext.cpp b/Userland/Libraries/LibWeb/Layout/GridFormattingContext.cpp index b1f6cd894d0..42479eeeafd 100644 --- a/Userland/Libraries/LibWeb/Layout/GridFormattingContext.cpp +++ b/Userland/Libraries/LibWeb/Layout/GridFormattingContext.cpp @@ -17,7 +17,7 @@ GridFormattingContext::GridFormattingContext(LayoutState& state, BlockContainer GridFormattingContext::~GridFormattingContext() = default; -float GridFormattingContext::resolve_definite_track_size(CSS::GridSize const& grid_size, AvailableSpace const& available_space, Box const& box) +CSSPixels GridFormattingContext::resolve_definite_track_size(CSS::GridSize const& grid_size, AvailableSpace const& available_space, Box const& box) { VERIFY(grid_size.is_definite()); switch (grid_size.type()) { @@ -55,7 +55,7 @@ size_t GridFormattingContext::count_of_gap_rows() return count; } -float GridFormattingContext::resolve_size(CSS::Size const& size, AvailableSize const& available_size, Box const& box) +CSSPixels GridFormattingContext::resolve_size(CSS::Size const& size, AvailableSize const& available_size, Box const& box) { if (size.is_length() && size.length().is_calculated()) { if (size.length().calculated_style_value()->contains_percentage()) { @@ -72,7 +72,7 @@ float GridFormattingContext::resolve_size(CSS::Size const& size, AvailableSize c if (size.is_percentage()) { if (!available_size.is_definite()) return 0; - return available_size.to_px().value() * size.percentage().as_fraction(); + return available_size.to_px() * size.percentage().as_fraction(); } return 0; } @@ -109,7 +109,7 @@ int GridFormattingContext::count_of_repeated_auto_fill_or_fit_tracks(Vector(get_free_space_x(available_space) / sum_of_grid_track_sizes)); + return max(1, static_cast((get_free_space_x(available_space) / sum_of_grid_track_sizes).value())); // For the purpose of finding the number of auto-repeated tracks in a standalone axis, the UA must // floor the track size to a UA-specified value to avoid division by zero. It is suggested that this @@ -781,7 +781,7 @@ void GridFormattingContext::calculate_sizes_of_columns(Box const& box, Available // result from assuming the item’s used minimum size as its preferred size; else the item’s minimum // contribution is its min-content contribution. Because the minimum contribution often depends on // the size of the item’s content, it is considered a type of intrinsic size contribution. - float grid_column_width = 0; + CSSPixels grid_column_width = 0; for (auto& box_of_column : boxes_of_column) grid_column_width = max(grid_column_width, calculate_min_content_width(box_of_column).value()); grid_column.base_size = grid_column_width; @@ -887,7 +887,7 @@ void GridFormattingContext::calculate_sizes_of_columns(Box const& box, Available // 12.5.1. Distributing Extra Space Across Spanned Tracks // To distribute extra space by increasing the affected sizes of a set of tracks as required by a // set of intrinsic size contributions, - float sum_of_track_sizes = 0; + CSSPixels sum_of_track_sizes = 0; for (auto& it : m_grid_columns) sum_of_track_sizes += it.base_size; @@ -909,10 +909,10 @@ void GridFormattingContext::calculate_sizes_of_columns(Box const& box, Available for (auto& grid_column : m_grid_columns) { if (grid_column.is_gap) continue; - grid_column.space_to_distribute = max(0, (grid_column.growth_limit == -1 ? grid_column.base_size : grid_column.growth_limit) - grid_column.base_size); + grid_column.space_to_distribute = max(CSSPixels(0), (grid_column.growth_limit == -1 ? grid_column.base_size : grid_column.growth_limit) - grid_column.base_size); } - auto remaining_free_space = available_space.width.is_definite() ? available_space.width.to_px().value() - sum_of_track_sizes : 0; + auto remaining_free_space = available_space.width.is_definite() ? available_space.width.to_px() - sum_of_track_sizes : 0; // 2.2. Distribute space up to limits: Find the item-incurred increase for each spanned track with an // affected size by: distributing the space equally among such tracks, freezing a track’s // item-incurred increase as its affected size + item-incurred increase reaches its limit (and @@ -1024,13 +1024,13 @@ void GridFormattingContext::calculate_sizes_of_columns(Box const& box, Available column_flex_factor_sum = 1; // See 12.7.1. - float sized_column_widths = 0; + CSSPixels sized_column_widths = 0; for (auto& grid_column : m_grid_columns) { if (!grid_column.min_track_sizing_function.is_flexible_length()) sized_column_widths += grid_column.base_size; } // Let leftover space be the space to fill minus the base sizes of the non-flexible grid tracks. - double free_horizontal_space = available_space.width.is_definite() ? available_space.width.to_px().value() - sized_column_widths : 0; + CSSPixels free_horizontal_space = available_space.width.is_definite() ? available_space.width.to_px() - sized_column_widths : 0; // If the free space is zero or if sizing the grid container under a min-content constraint: // The used flex fraction is zero. @@ -1044,7 +1044,7 @@ void GridFormattingContext::calculate_sizes_of_columns(Box const& box, Available if (grid_column.min_track_sizing_function.is_flexible_length()) { // See 12.7.1. // Let the hypothetical fr size be the leftover space divided by the flex factor sum. - auto hypothetical_fr_size = static_cast(1.0 / column_flex_factor_sum) * free_horizontal_space; + auto hypothetical_fr_size = free_horizontal_space / column_flex_factor_sum; // For each flexible track, if the product of the used flex fraction and the track’s flex factor is // greater than the track’s base size, set its base size to that product. grid_column.base_size = max(grid_column.base_size, hypothetical_fr_size); @@ -1097,13 +1097,13 @@ void GridFormattingContext::calculate_sizes_of_columns(Box const& box, Available // positive, definite free space equally amongst them. If the free space is indefinite, but the grid // container has a definite min-width/height, use that size to calculate the free space for this // step instead. - float used_horizontal_space = 0; + CSSPixels used_horizontal_space = 0; for (auto& grid_column : m_grid_columns) { if (!(grid_column.max_track_sizing_function.is_length() && grid_column.max_track_sizing_function.length().is_auto())) used_horizontal_space += grid_column.base_size; } - float remaining_horizontal_space = available_space.width.is_definite() ? available_space.width.to_px().value() - used_horizontal_space : 0; + CSSPixels remaining_horizontal_space = available_space.width.is_definite() ? available_space.width.to_px() - used_horizontal_space : 0; auto count_of_auto_max_column_tracks = 0; for (auto& grid_column : m_grid_columns) { if (grid_column.max_track_sizing_function.is_length() && grid_column.max_track_sizing_function.length().is_auto()) @@ -1239,9 +1239,9 @@ void GridFormattingContext::calculate_sizes_of_rows(Box const& box) // result from assuming the item’s used minimum size as its preferred size; else the item’s minimum // contribution is its min-content contribution. Because the minimum contribution often depends on // the size of the item’s content, it is considered a type of intrinsic size contribution. - float grid_row_height = 0; + CSSPixels grid_row_height = 0; for (auto& positioned_box : positioned_boxes_of_row) - grid_row_height = max(grid_row_height, calculate_min_content_height(positioned_box.box, AvailableSize::make_definite(m_grid_columns[positioned_box.column].base_size)).value()); + grid_row_height = max(grid_row_height, calculate_min_content_height(positioned_box.box, AvailableSize::make_definite(m_grid_columns[positioned_box.column].base_size))); grid_row.base_size = grid_row_height; // - For min-content maximums: @@ -1425,13 +1425,13 @@ void GridFormattingContext::calculate_sizes_of_rows(Box const& box) row_flex_factor_sum = 1; // See 12.7.1. - float sized_row_heights = 0; + CSSPixels sized_row_heights = 0; for (auto& grid_row : m_grid_rows) { if (!grid_row.min_track_sizing_function.is_flexible_length()) sized_row_heights += grid_row.base_size; } // Let leftover space be the space to fill minus the base sizes of the non-flexible grid tracks. - double free_vertical_space = box_state.content_height() - sized_row_heights; + CSSPixels free_vertical_space = CSSPixels(box_state.content_height()) - sized_row_heights; // If the free space is zero or if sizing the grid container under a min-content constraint: // The used flex fraction is zero. @@ -1445,7 +1445,7 @@ void GridFormattingContext::calculate_sizes_of_rows(Box const& box) if (grid_row.min_track_sizing_function.is_flexible_length()) { // See 12.7.1. // Let the hypothetical fr size be the leftover space divided by the flex factor sum. - auto hypothetical_fr_size = static_cast(1.0 / row_flex_factor_sum) * free_vertical_space; + auto hypothetical_fr_size = free_vertical_space / row_flex_factor_sum; // For each flexible track, if the product of the used flex fraction and the track’s flex factor is // greater than the track’s base size, set its base size to that product. grid_row.base_size = max(grid_row.base_size, hypothetical_fr_size); @@ -1498,13 +1498,13 @@ void GridFormattingContext::calculate_sizes_of_rows(Box const& box) // positive, definite free space equally amongst them. If the free space is indefinite, but the grid // container has a definite min-width/height, use that size to calculate the free space for this // step instead. - float used_vertical_space = 0; + CSSPixels used_vertical_space = 0; for (auto& grid_row : m_grid_rows) { if (!(grid_row.max_track_sizing_function.is_length() && grid_row.max_track_sizing_function.length().is_auto())) used_vertical_space += grid_row.base_size; } - float remaining_vertical_space = box_state.content_height() - used_vertical_space; + CSSPixels remaining_vertical_space = CSSPixels(box_state.content_height()) - used_vertical_space; auto count_of_auto_max_row_tracks = 0; for (auto& grid_row : m_grid_rows) { if (grid_row.max_track_sizing_function.is_length() && grid_row.max_track_sizing_function.length().is_auto()) @@ -1720,10 +1720,10 @@ void GridFormattingContext::run(Box const& box, LayoutMode, AvailableSpace const auto layout_box = [&](int row_start, int row_end, int column_start, int column_end, Box const& child_box) -> void { auto& child_box_state = m_state.get_mutable(child_box); - float x_start = 0; - float x_end = 0; - float y_start = 0; - float y_end = 0; + CSSPixels x_start = 0; + CSSPixels x_end = 0; + CSSPixels y_start = 0; + CSSPixels y_end = 0; for (int i = 0; i < column_start; i++) x_start += m_grid_columns[i].base_size; for (int i = 0; i < column_end; i++) @@ -1732,8 +1732,8 @@ void GridFormattingContext::run(Box const& box, LayoutMode, AvailableSpace const y_start += m_grid_rows[i].base_size; for (int i = 0; i < row_end; i++) y_end += m_grid_rows[i].base_size; - child_box_state.set_content_width(x_end - x_start); - child_box_state.set_content_height(y_end - y_start); + child_box_state.set_content_width((x_end - x_start).value()); + child_box_state.set_content_height((y_end - y_start).value()); child_box_state.offset = { x_start, y_start }; auto available_space_for_children = AvailableSpace(AvailableSize::make_definite(child_box_state.content_width()), AvailableSize::make_definite(child_box_state.content_height())); @@ -1764,7 +1764,7 @@ void GridFormattingContext::run(Box const& box, LayoutMode, AvailableSpace const positioned_box.box); } - float total_y = 0; + CSSPixels total_y = 0; for (auto& grid_row : m_grid_rows) total_y += grid_row.base_size; m_automatic_content_height = total_y; @@ -1790,7 +1790,7 @@ bool GridFormattingContext::is_auto_positioned_track(CSS::GridTrackPlacement con return grid_track_start.is_auto_positioned() && grid_track_end.is_auto_positioned(); } -float GridFormattingContext::get_free_space_x(AvailableSpace const& available_space) +CSSPixels GridFormattingContext::get_free_space_x(AvailableSpace const& available_space) { // https://www.w3.org/TR/css-grid-2/#algo-terms // free space: Equal to the available grid space minus the sum of the base sizes of all the grid @@ -1799,24 +1799,24 @@ float GridFormattingContext::get_free_space_x(AvailableSpace const& available_sp // FIXME: do indefinite space if (!available_space.width.is_definite()) return 0; - auto sum_base_sizes = 0; + CSSPixels sum_base_sizes = 0; for (auto& grid_column : m_grid_columns) sum_base_sizes += grid_column.base_size; - return max(0, available_space.width.to_px().value() - sum_base_sizes); + return max(CSSPixels(0), available_space.width.to_px() - sum_base_sizes); } -float GridFormattingContext::get_free_space_y(Box const& box) +CSSPixels GridFormattingContext::get_free_space_y(Box const& box) { // https://www.w3.org/TR/css-grid-2/#algo-terms // free space: Equal to the available grid space minus the sum of the base sizes of all the grid // tracks (including gutters), floored at zero. If available grid space is indefinite, the free // space is indefinite as well. - auto sum_base_sizes = 0; + CSSPixels sum_base_sizes = 0; for (auto& grid_row : m_grid_rows) sum_base_sizes += grid_row.base_size; auto& box_state = m_state.get_mutable(box); if (box_state.has_definite_height()) - return max(0, absolute_content_rect(box, m_state).height() - sum_base_sizes); + return max(CSSPixels(0), CSSPixels(absolute_content_rect(box, m_state).height()) - sum_base_sizes); return -1; } diff --git a/Userland/Libraries/LibWeb/Layout/GridFormattingContext.h b/Userland/Libraries/LibWeb/Layout/GridFormattingContext.h index 65316519a92..01f21ab7afc 100644 --- a/Userland/Libraries/LibWeb/Layout/GridFormattingContext.h +++ b/Userland/Libraries/LibWeb/Layout/GridFormattingContext.h @@ -40,7 +40,7 @@ public: virtual CSSPixels automatic_content_height() const override; private: - float m_automatic_content_height { 0 }; + CSSPixels m_automatic_content_height { 0 }; bool is_auto_positioned_row(CSS::GridTrackPlacement const&, CSS::GridTrackPlacement const&) const; bool is_auto_positioned_column(CSS::GridTrackPlacement const&, CSS::GridTrackPlacement const&) const; bool is_auto_positioned_track(CSS::GridTrackPlacement const&, CSS::GridTrackPlacement const&) const; @@ -56,10 +56,10 @@ private: struct TemporaryTrack { CSS::GridSize min_track_sizing_function; CSS::GridSize max_track_sizing_function; - float base_size { 0 }; - float growth_limit { 0 }; - float space_to_distribute { 0 }; - float planned_increase { 0 }; + CSSPixels base_size { 0 }; + CSSPixels growth_limit { 0 }; + CSSPixels space_to_distribute { 0 }; + CSSPixels planned_increase { 0 }; bool is_gap { false }; TemporaryTrack(CSS::GridSize min_track_sizing_function, CSS::GridSize max_track_sizing_function) @@ -74,10 +74,10 @@ private: { } - TemporaryTrack(float size_in_px, bool is_gap) - : min_track_sizing_function(CSS::GridSize(CSS::Length(size_in_px, CSS::Length::Type::Px))) - , max_track_sizing_function(CSS::GridSize(CSS::Length(size_in_px, CSS::Length::Type::Px))) - , base_size(size_in_px) + TemporaryTrack(CSSPixels size, bool is_gap) + : min_track_sizing_function(CSS::GridSize(CSS::Length::make_px(size))) + , max_track_sizing_function(CSS::GridSize(CSS::Length::make_px(size))) + , base_size(size) , is_gap(is_gap) { } @@ -96,14 +96,14 @@ private: Vector m_positioned_boxes; Vector m_boxes_to_place; - float get_free_space_x(AvailableSpace const& available_space); - float get_free_space_y(Box const&); + CSSPixels get_free_space_x(AvailableSpace const& available_space); + CSSPixels get_free_space_y(Box const&); int get_line_index_by_line_name(DeprecatedString const& line_name, CSS::GridTrackSizeList); - float resolve_definite_track_size(CSS::GridSize const&, AvailableSpace const&, Box const&); + CSSPixels resolve_definite_track_size(CSS::GridSize const&, AvailableSpace const&, Box const&); size_t count_of_gap_columns(); size_t count_of_gap_rows(); - float resolve_size(CSS::Size const&, AvailableSize const&, Box const&); + CSSPixels resolve_size(CSS::Size const&, AvailableSize const&, Box const&); int count_of_repeated_auto_fill_or_fit_tracks(Vector const& track_list, AvailableSpace const&, Box const&); int get_count_of_tracks(Vector const&, AvailableSpace const&, Box const&);