RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 19:47:44 +00:00
Code Issues Activity Actions

LibWeb: Make FFC line and item vectors members instead of locals

Browse source 
This gives all member functions access to these vectors without having
to pass them as arguments.
This commit is contained in:
Andreas Kling 2021-10-13 22:44:54 +02:00
parent c793797e61
commit 1580c59f39
2 changed files with 89 additions and 94 deletions
Download patch file Download diff file Expand all files Collapse all files

124
Userland/Libraries/LibWeb/Layout/FlexFormattingContext.cpp
View file

@ -32,48 +32,14 @@ FlexFormattingContext::~FlexFormattingContext()
{
}
struct DirectionAgnosticMargins {
float main_before { 0 };
float main_after { 0 };
float cross_before { 0 };
float cross_after { 0 };
};
struct FlexItem {
Box& box;
float flex_base_size { 0 };
float hypothetical_main_size { 0 };
float hypothetical_cross_size { 0 };
float hypothetical_cross_size_with_margins() { return hypothetical_cross_size + margins.cross_before + margins.cross_after; }
float target_main_size { 0 };
bool frozen { false };
Optional<float> flex_factor {};
float scaled_flex_shrink_factor { 0 };
float max_content_flex_fraction { 0 };
float main_size { 0 };
float cross_size { 0 };
float main_offset { 0 };
float cross_offset { 0 };
DirectionAgnosticMargins margins {};
bool is_min_violation { false };
bool is_max_violation { false };
};
struct FlexLine {
Vector<FlexItem*> items;
float cross_size { 0 };
};
void FlexFormattingContext::run(Box& flex_container, LayoutMode)
{
// This implements https://www.w3.org/TR/css-flexbox-1/#layout-algorithm
// FIXME: Implement reverse and ordering.
Vector<FlexItem> flex_items;
// 1. Generate anonymous flex items
generate_anonymous_flex_items(flex_container, flex_items);
generate_anonymous_flex_items(flex_container);
// 2. Determine the available main and cross space for the flex items
float main_max_size = NumericLimits<float>::max();
@ -88,28 +54,28 @@ void FlexFormattingContext::run(Box& flex_container, LayoutMode)
[[maybe_unused]] auto cross_available_size = available_space.cross;
// 3. Determine the flex base size and hypothetical main size of each item
for (auto& flex_item : flex_items) {
for (auto& flex_item : m_flex_items) {
determine_flex_base_size_and_hypothetical_main_size(flex_container, flex_item);
}
// 4. Determine the main size of the flex container
determine_main_size_of_flex_container(flex_container, flex_items, main_is_constrained, main_size_is_infinite, main_available_size, main_min_size, main_max_size);
determine_main_size_of_flex_container(flex_container, main_is_constrained, main_size_is_infinite, main_available_size, main_min_size, main_max_size);
// 5. Collect flex items into flex lines:
// After this step no additional items are to be added to flex_lines or any of its items!
auto flex_lines = collect_flex_items_into_flex_lines(flex_container, flex_items, main_available_size);
collect_flex_items_into_flex_lines(flex_container, main_available_size);
// 6. Resolve the flexible lengths
resolve_flexible_lengths(flex_lines, main_available_size);
resolve_flexible_lengths(main_available_size);
// Cross Size Determination
// 7. Determine the hypothetical cross size of each item
for (auto& flex_item : flex_items) {
for (auto& flex_item : m_flex_items) {
flex_item.hypothetical_cross_size = determine_hypothetical_cross_size_of_item(flex_item.box);
}
// 8. Calculate the cross size of each flex line.
calculate_cross_size_of_each_flex_line(flex_container, flex_lines, cross_min_size, cross_max_size);
calculate_cross_size_of_each_flex_line(flex_container, cross_min_size, cross_max_size);
// 9. Handle 'align-content: stretch'.
// FIXME: This
@ -118,25 +84,25 @@ void FlexFormattingContext::run(Box& flex_container, LayoutMode)
// FIXME: This
// 11. Determine the used cross size of each flex item.
determine_used_cross_size_of_each_flex_item(flex_container, flex_lines);
determine_used_cross_size_of_each_flex_item(flex_container);
// 12. Distribute any remaining free space.
distribute_any_remaining_free_space(flex_container, flex_lines, main_available_size);
distribute_any_remaining_free_space(flex_container, main_available_size);
// 13. Resolve cross-axis auto margins.
// FIXME: This
// 14. Align all flex items along the cross-axis
align_all_flex_items_along_the_cross_axis(flex_container, flex_lines);
align_all_flex_items_along_the_cross_axis(flex_container);
// 15. Determine the flex container’s used cross size:
determine_flex_container_used_cross_size(flex_container, flex_lines, cross_min_size, cross_max_size);
determine_flex_container_used_cross_size(flex_container, cross_min_size, cross_max_size);
// 16. Align all flex lines (per align-content)
align_all_flex_lines(flex_lines);
align_all_flex_lines();
}
static void populate_specified_margins(FlexItem& item, CSS::FlexDirection flex_direction)
void FlexFormattingContext::populate_specified_margins(FlexItem& item, CSS::FlexDirection flex_direction) const
{
auto width_of_containing_block = item.box.width_of_logical_containing_block();
// FIXME: This should also take reverse-ness into account
@ -154,7 +120,7 @@ static void populate_specified_margins(FlexItem& item, CSS::FlexDirection flex_d
};
// https://www.w3.org/TR/css-flexbox-1/#flex-items
void FlexFormattingContext::generate_anonymous_flex_items(Box& flex_container, Vector<FlexItem>& flex_items)
void FlexFormattingContext::generate_anonymous_flex_items(Box& flex_container)
{
// More like, sift through the already generated items.
// After this step no items are to be added or removed from flex_items!
@ -197,7 +163,7 @@ void FlexFormattingContext::generate_anonymous_flex_items(Box& flex_container, V
child_box.set_flex_item(true);
FlexItem flex_item = { child_box };
populate_specified_margins(flex_item, m_flex_direction);
flex_items.append(move(flex_item));
m_flex_items.append(move(flex_item));
return IterationDecision::Continue;
});
}
@ -527,14 +493,14 @@ void FlexFormattingContext::determine_flex_base_size_and_hypothetical_main_size(
}
// https://www.w3.org/TR/css-flexbox-1/#algo-main-container
void FlexFormattingContext::determine_main_size_of_flex_container(Box& flex_container, Vector<FlexItem>& flex_items, bool const main_is_constrained, bool const main_size_is_infinite, float& main_available_size, float const main_min_size, float const main_max_size)
void FlexFormattingContext::determine_main_size_of_flex_container(Box& flex_container, bool const main_is_constrained, bool const main_size_is_infinite, float& main_available_size, float const main_min_size, float const main_max_size)
{
if ((!main_is_constrained && main_size_is_infinite) || main_available_size == 0) {
// Uses https://www.w3.org/TR/css-flexbox-1/#intrinsic-main-sizes
// 9.9.1
// 1.
float largest_max_content_flex_fraction = 0;
for (auto& flex_item : flex_items) {
for (auto& flex_item : m_flex_items) {
// FIXME: This needs some serious work.
float max_content_contribution = calculated_main_size(flex_item.box);
float max_content_flex_fraction = max_content_contribution - flex_item.flex_base_size;
@ -552,7 +518,7 @@ void FlexFormattingContext::determine_main_size_of_flex_container(Box& flex_cont
// 2. Omitted
// 3.
float result = 0;
for (auto& flex_item : flex_items) {
for (auto& flex_item : m_flex_items) {
auto product = 0;
if (flex_item.max_content_flex_fraction > 0) {
product = largest_max_content_flex_fraction * flex_item.box.computed_values().flex_grow_factor().value_or(1);
@ -567,37 +533,33 @@ void FlexFormattingContext::determine_main_size_of_flex_container(Box& flex_cont
}
// https://www.w3.org/TR/css-flexbox-1/#algo-line-break
Vector<FlexLine> FlexFormattingContext::collect_flex_items_into_flex_lines(Box const& flex_container, Vector<FlexItem>& flex_items, float const main_available_size)
void FlexFormattingContext::collect_flex_items_into_flex_lines(Box const& flex_container, float const main_available_size)
{
Vector<FlexLine> flex_lines;
// FIXME: Also support wrap-reverse
if (flex_container.computed_values().flex_wrap() == CSS::FlexWrap::Nowrap) {
FlexLine line;
for (auto& flex_item : flex_items) {
for (auto& flex_item : m_flex_items) {
line.items.append(&flex_item);
}
flex_lines.append(line);
m_flex_lines.append(line);
} else {
FlexLine line;
float line_main_size = 0;
for (auto& flex_item : flex_items) {
for (auto& flex_item : m_flex_items) {
if ((line_main_size + flex_item.hypothetical_main_size) > main_available_size) {
flex_lines.append(line);
m_flex_lines.append(line);
line = {};
line_main_size = 0;
}
line.items.append(&flex_item);
line_main_size += flex_item.hypothetical_main_size;
}
flex_lines.append(line);
m_flex_lines.append(line);
}
return flex_lines;
}
// https://www.w3.org/TR/css-flexbox-1/#resolve-flexible-lengths
void FlexFormattingContext::resolve_flexible_lengths(Vector<FlexLine>& flex_lines, float const main_available_size)
void FlexFormattingContext::resolve_flexible_lengths(float const main_available_size)
{
enum FlexFactor {
FlexGrowFactor,
@ -606,7 +568,7 @@ void FlexFormattingContext::resolve_flexible_lengths(Vector<FlexLine>& flex_line
FlexFactor used_flex_factor;
// 6.1. Determine used flex factor
for (auto& flex_line : flex_lines) {
for (auto& flex_line : m_flex_lines) {
size_t number_of_unfrozen_items_on_line = flex_line.items.size();
float sum_of_hypothetical_main_sizes = 0;
@ -797,17 +759,17 @@ float FlexFormattingContext::determine_hypothetical_cross_size_of_item(Box& box)
}
// https://www.w3.org/TR/css-flexbox-1/#algo-cross-line
void FlexFormattingContext::calculate_cross_size_of_each_flex_line(const Box& flex_container, Vector<FlexLine>& flex_lines, float const cross_min_size, float const cross_max_size)
void FlexFormattingContext::calculate_cross_size_of_each_flex_line(Box const& flex_container, float const cross_min_size, float const cross_max_size)
{
if (flex_lines.size() == 1 && has_definite_cross_size(flex_container)) {
flex_lines[0].cross_size = specified_cross_size(flex_container);
if (m_flex_lines.size() == 1 && has_definite_cross_size(flex_container)) {
m_flex_lines[0].cross_size = specified_cross_size(flex_container);
} else {
for (auto& flex_line : flex_lines) {
for (auto& flex_line : m_flex_lines) {
// FIXME: Implement 8.1
// FIXME: This isn't spec but makes sense here
if (has_definite_cross_size(flex_container) && flex_container.computed_values().align_items() == CSS::AlignItems::Stretch) {
flex_line.cross_size = specified_cross_size(flex_container) / flex_lines.size();
flex_line.cross_size = specified_cross_size(flex_container) / m_flex_lines.size();
continue;
}
@ -822,17 +784,17 @@ void FlexFormattingContext::calculate_cross_size_of_each_flex_line(const Box& fl
flex_line.cross_size = max(0.0f, largest_hypothetical_cross_size);
}
if (flex_lines.size() == 1) {
clamp(flex_lines[0].cross_size, cross_min_size, cross_max_size);
if (m_flex_lines.size() == 1) {
clamp(m_flex_lines[0].cross_size, cross_min_size, cross_max_size);
}
}
}
// https://www.w3.org/TR/css-flexbox-1/#algo-stretch
void FlexFormattingContext::determine_used_cross_size_of_each_flex_item(Box const& flex_container, Vector<FlexLine>& flex_lines)
void FlexFormattingContext::determine_used_cross_size_of_each_flex_item(Box const& flex_container)
{
// FIXME: Get the alignment via "align-self" of the item (which accesses "align-items" of the parent if unset)
for (auto& flex_line : flex_lines) {
for (auto& flex_line : m_flex_lines) {
for (auto& flex_item : flex_line.items) {
if (is_cross_auto(flex_item->box) && flex_container.computed_values().align_items() == CSS::AlignItems::Stretch) {
flex_item->cross_size = flex_line.cross_size;
@ -844,9 +806,9 @@ void FlexFormattingContext::determine_used_cross_size_of_each_flex_item(Box cons
}
// https://www.w3.org/TR/css-flexbox-1/#algo-main-align
void FlexFormattingContext::distribute_any_remaining_free_space(Box const& flex_container, Vector<FlexLine>& flex_lines, float const main_available_size)
void FlexFormattingContext::distribute_any_remaining_free_space(Box const& flex_container, float const main_available_size)
{
for (auto& flex_line : flex_lines) {
for (auto& flex_line : m_flex_lines) {
// 12.1.
float used_main_space = 0;
size_t auto_margins = 0;
@ -907,12 +869,12 @@ void FlexFormattingContext::distribute_any_remaining_free_space(Box const& flex_
}
}
void FlexFormattingContext::align_all_flex_items_along_the_cross_axis(Box const& flex_container, Vector<FlexLine>& flex_lines)
void FlexFormattingContext::align_all_flex_items_along_the_cross_axis(Box const& flex_container)
{
// FIXME: Get the alignment via "align-self" of the item (which accesses "align-items" of the parent if unset)
// FIXME: Take better care of margins
float line_cross_offset = 0;
for (auto& flex_line : flex_lines) {
for (auto& flex_line : m_flex_lines) {
for (auto* flex_item : flex_line.items) {
switch (flex_container.computed_values().align_items()) {
case CSS::AlignItems::Baseline:
@ -938,14 +900,14 @@ void FlexFormattingContext::align_all_flex_items_along_the_cross_axis(Box const&
}
// https://www.w3.org/TR/css-flexbox-1/#algo-cross-container
void FlexFormattingContext::determine_flex_container_used_cross_size(Box& flex_container, Vector<FlexLine> const& flex_lines, float const cross_min_size, float const cross_max_size)
void FlexFormattingContext::determine_flex_container_used_cross_size(Box& flex_container, float const cross_min_size, float const cross_max_size)
{
if (has_definite_cross_size(flex_container)) {
float clamped_cross_size = clamp(specified_cross_size(flex_container), cross_min_size, cross_max_size);
set_cross_size(flex_container, clamped_cross_size);
} else {
float sum_of_flex_lines_cross_sizes = 0;
for (auto& flex_line : flex_lines) {
for (auto& flex_line : m_flex_lines) {
sum_of_flex_lines_cross_sizes += flex_line.cross_size;
}
float clamped_cross_size = clamp(sum_of_flex_lines_cross_sizes, cross_min_size, cross_max_size);
@ -954,11 +916,11 @@ void FlexFormattingContext::determine_flex_container_used_cross_size(Box& flex_c
}
// https://www.w3.org/TR/css-flexbox-1/#algo-line-align
void FlexFormattingContext::align_all_flex_lines(Vector<FlexLine>& flex_lines)
void FlexFormattingContext::align_all_flex_lines()
{
// FIXME: Support align-content
// FIXME: Support reverse
for (auto& flex_line : flex_lines) {
for (auto& flex_line : m_flex_lines) {
for (auto* flex_item : flex_line.items) {
set_main_size(flex_item->box, flex_item->main_size);
set_cross_size(flex_item->box, flex_item->cross_size);