diff --git a/Userland/Libraries/LibWeb/CSS/GridTrackSize.cpp b/Userland/Libraries/LibWeb/CSS/GridTrackSize.cpp index 64396ade9d..20e75a1c9a 100644 --- a/Userland/Libraries/LibWeb/CSS/GridTrackSize.cpp +++ b/Userland/Libraries/LibWeb/CSS/GridTrackSize.cpp @@ -6,38 +6,31 @@ #include "GridTrackSize.h" #include +#include namespace Web::CSS { -GridSize::GridSize(Length length) - : m_type(Type::Length) - , m_length(length) -{ -} - -GridSize::GridSize(Percentage percentage) - : m_type(Type::Percentage) - , m_length { Length::make_px(0) } - , m_percentage(percentage) -{ -} +GridSize::GridSize(LengthPercentage length_percentage) + : m_type(Type::LengthPercentage) + , m_length_percentage(length_percentage) {}; GridSize::GridSize(float flexible_length) : m_type(Type::FlexibleLength) - , m_length { Length::make_px(0) } + , m_length_percentage { Length::make_px(0) } , m_flexible_length(flexible_length) { } GridSize::GridSize(Type type) - : m_length { Length::make_auto() } + : m_length_percentage { Length::make_auto() } { VERIFY(type == Type::MinContent || type == Type::MaxContent); m_type = type; } GridSize::GridSize() - : m_length { Length::make_auto() } + : m_type(Type::LengthPercentage) + , m_length_percentage { Length::make_auto() } { } @@ -48,13 +41,21 @@ GridSize GridSize::make_auto() return GridSize(CSS::Length::make_auto()); } +Size GridSize::css_size() const +{ + VERIFY(m_type == Type::LengthPercentage); + if (m_length_percentage.is_auto()) + return CSS::Size::make_auto(); + if (m_length_percentage.is_length()) + return CSS::Size::make_length(m_length_percentage.length()); + return CSS::Size::make_percentage(m_length_percentage.percentage()); +} + ErrorOr GridSize::to_string() const { switch (m_type) { - case Type::Length: - return m_length.to_string(); - case Type::Percentage: - return m_percentage.to_string(); + case Type::LengthPercentage: + return m_length_percentage.to_string(); case Type::FlexibleLength: return String::formatted("{}fr", m_flexible_length); case Type::MaxContent: @@ -65,11 +66,6 @@ ErrorOr GridSize::to_string() const VERIFY_NOT_REACHED(); } -Length GridSize::length() const -{ - return m_length; -} - GridMinMax::GridMinMax(GridSize min_grid_size, GridSize max_grid_size) : m_min_grid_size(min_grid_size) , m_max_grid_size(max_grid_size) diff --git a/Userland/Libraries/LibWeb/CSS/GridTrackSize.h b/Userland/Libraries/LibWeb/CSS/GridTrackSize.h index c7ab424df8..5edd250c1c 100644 --- a/Userland/Libraries/LibWeb/CSS/GridTrackSize.h +++ b/Userland/Libraries/LibWeb/CSS/GridTrackSize.h @@ -7,23 +7,20 @@ #pragma once #include -#include -#include +#include namespace Web::CSS { class GridSize { public: enum class Type { - Length, - Percentage, + LengthPercentage, FlexibleLength, MaxContent, MinContent, }; - GridSize(Length); - GridSize(Percentage); + GridSize(LengthPercentage); GridSize(float); GridSize(Type); GridSize(); @@ -33,14 +30,13 @@ public: Type type() const { return m_type; } - bool is_length() const { return m_type == Type::Length; } - bool is_percentage() const { return m_type == Type::Percentage; } + bool is_auto() const { return m_type == Type::LengthPercentage && m_length_percentage.is_auto(); } + bool is_length_percentage() const { return m_type == Type::LengthPercentage; } bool is_flexible_length() const { return m_type == Type::FlexibleLength; } bool is_max_content() const { return m_type == Type::MaxContent; } bool is_min_content() const { return m_type == Type::MinContent; } - Length length() const; - Percentage percentage() const { return m_percentage; } + LengthPercentage length_percentage() const { return m_length_percentage; }; float flexible_length() const { return m_flexible_length; } // https://www.w3.org/TR/css-grid-2/#layout-algorithm @@ -48,29 +44,27 @@ public: // FIXME: Add missing properties once implemented. bool is_intrinsic_track_sizing() const { - return (m_type == Type::Length && m_length.is_auto()) || m_type == Type::MaxContent || m_type == Type::MinContent; + return is_auto() || is_max_content() || is_min_content(); } bool is_definite() const { - return (m_type == Type::Length && !m_length.is_auto()) || is_percentage(); + return type() == Type::LengthPercentage && !m_length_percentage.is_auto(); } + Size css_size() const; + ErrorOr to_string() const; bool operator==(GridSize const& other) const { return m_type == other.type() - && m_length == other.length() - && m_percentage == other.percentage() + && m_length_percentage == other.length_percentage() && m_flexible_length == other.flexible_length(); } private: Type m_type; - // Length includes a RefPtr member, but we can't include the header StyleValue.h as it includes - // this file already. To break the cyclic dependency, we must initialize m_length in the constructor. - Length m_length; - Percentage m_percentage { Percentage(0) }; + LengthPercentage m_length_percentage; float m_flexible_length { 0 }; }; diff --git a/Userland/Libraries/LibWeb/Layout/GridFormattingContext.cpp b/Userland/Libraries/LibWeb/Layout/GridFormattingContext.cpp index cef11e11b2..d789af49be 100644 --- a/Userland/Libraries/LibWeb/Layout/GridFormattingContext.cpp +++ b/Userland/Libraries/LibWeb/Layout/GridFormattingContext.cpp @@ -21,14 +21,12 @@ CSSPixels GridFormattingContext::resolve_definite_track_size(CSS::GridSize const { VERIFY(grid_size.is_definite()); switch (grid_size.type()) { - case CSS::GridSize::Type::Length: - if (grid_size.length().is_auto()) - break; - return grid_size.length().to_px(grid_container()); - case CSS::GridSize::Type::Percentage: - if (available_space.width.is_definite()) - return grid_size.percentage().as_fraction() * available_space.width.to_px().value(); + case CSS::GridSize::Type::LengthPercentage: { + if (!grid_size.length_percentage().is_auto()) { + return grid_size.css_size().to_px(grid_container(), available_space.width.to_px()); + } break; + } default: VERIFY_NOT_REACHED(); } @@ -621,14 +619,11 @@ void GridFormattingContext::initialize_track_sizes(AvailableSize const& availabl switch (track.min_track_sizing_function.type()) { // - A fixed sizing function // Resolve to an absolute length and use that size as the track’s initial base size. - case CSS::GridSize::Type::Length: { - if (!track.min_track_sizing_function.length().is_auto()) - track.base_size = track.min_track_sizing_function.length().to_px(grid_container()); - break; - } - case CSS::GridSize::Type::Percentage: { - if (available_size.is_definite()) - track.base_size = track.min_track_sizing_function.percentage().as_fraction() * available_size.to_px().value(); + case CSS::GridSize::Type::LengthPercentage: { + if (!track.min_track_sizing_function.is_auto()) { + track.base_size = track.min_track_sizing_function.css_size().to_px(grid_container(), available_size.to_px()); + } + break; } // - An intrinsic sizing function @@ -647,18 +642,12 @@ void GridFormattingContext::initialize_track_sizes(AvailableSize const& availabl switch (track.max_track_sizing_function.type()) { // - A fixed sizing function // Resolve to an absolute length and use that size as the track’s initial growth limit. - case CSS::GridSize::Type::Length: { - if (!track.max_track_sizing_function.length().is_auto()) - track.growth_limit = track.max_track_sizing_function.length().to_px(grid_container()); - else - // - An intrinsic sizing function - // Use an initial growth limit of infinity. + case CSS::GridSize::Type::LengthPercentage: { + if (!track.max_track_sizing_function.is_auto()) { + track.growth_limit = track.max_track_sizing_function.css_size().to_px(grid_container(), available_size.to_px()); + } else { track.growth_limit = INFINITY; - break; - } - case CSS::GridSize::Type::Percentage: { - if (available_size.is_definite()) - track.growth_limit = track.max_track_sizing_function.percentage().as_fraction() * available_size.to_px().value(); + } break; } // - A flexible sizing function @@ -766,9 +755,8 @@ void GridFormattingContext::resolve_intrinsic_track_sizes(GridDimension const di } track.base_size = base_size; } break; - case CSS::GridSize::Type::Length: - case CSS::GridSize::Type::Percentage: { - if (track.min_track_sizing_function.length().is_auto() && available_size.is_intrinsic_sizing_constraint()) { + case CSS::GridSize::Type::LengthPercentage: { + if (track.min_track_sizing_function.is_auto() && available_size.is_intrinsic_sizing_constraint()) { // If the track has an auto min track sizing function and the grid container is being sized under a // min-/max-content constraint, set the track’s base size to the maximum of its items’ limited // min-/max-content contributions (respectively), floored at zero. The limited min-/max-content @@ -823,7 +811,7 @@ void GridFormattingContext::resolve_intrinsic_track_sizes(GridDimension const di growth_limit = max(growth_limit, calculate_item_min_content_contribution(item)); } track.growth_limit = growth_limit; - } else if (max_track_sizing_function.is_max_content() || (max_track_sizing_function.is_length() && max_track_sizing_function.length().is_auto())) { + } else if (max_track_sizing_function.is_max_content() || max_track_sizing_function.is_auto()) { // If the track has a max-content max track sizing function, set its growth limit to the maximum of // the items’ max-content contributions. For fit-content() maximums, furthermore clamp this growth // limit by the fit-content() argument. @@ -1142,19 +1130,19 @@ void GridFormattingContext::stretch_auto_tracks(AvailableSize const& available_s // step instead. CSSPixels used_space = 0; for (auto& track : tracks) { - if (!(track.max_track_sizing_function.is_length() && track.max_track_sizing_function.length().is_auto())) + if (!track.max_track_sizing_function.is_auto()) used_space += track.base_size; } CSSPixels remaining_space = available_size.is_definite() ? available_size.to_px() - used_space : 0; auto count_of_auto_max_sizing_tracks = 0; for (auto& track : tracks) { - if (track.max_track_sizing_function.is_length() && track.max_track_sizing_function.length().is_auto()) + if (track.max_track_sizing_function.is_auto()) count_of_auto_max_sizing_tracks++; } for (auto& track : tracks) { - if (track.max_track_sizing_function.is_length() && track.max_track_sizing_function.length().is_auto()) + if (track.max_track_sizing_function.is_auto()) track.base_size = max(track.base_size, remaining_space / count_of_auto_max_sizing_tracks); } }