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

LibWeb: Convert FormattingContext to new pixel units

Browse source 
Just FormattingContext and AvailableSpace, and the minor adjustments to
make everything else work.
This commit is contained in:
Sam Atkins 2022-11-23 17:46:10 +00:00 • committed by Linus Groh
parent 4754204f01
commit f5f25562d1
16 changed files with 174 additions and 175 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Userland/Libraries/LibWeb/Layout/AvailableSpace.cpp
View file

@ -9,7 +9,7 @@
namespace Web::Layout { namespace Web::Layout {
AvailableSize AvailableSize::make_definite(float value) AvailableSize AvailableSize::make_definite(CSSPixels value)
{ {
return AvailableSize { Type::Definite, value }; return AvailableSize { Type::Definite, value };
} }
@ -49,7 +49,7 @@ DeprecatedString AvailableSpace::to_deprecated_string() const
return DeprecatedString::formatted("{} x {}", width, height); return DeprecatedString::formatted("{} x {}", width, height);
} }
AvailableSize::AvailableSize(Type type, float value) AvailableSize::AvailableSize(Type type, CSSPixels value)
: m_type(type) : m_type(type)
, m_value(value) , m_value(value)
{ {

11
Userland/Libraries/LibWeb/Layout/AvailableSpace.h
View file

@ -9,6 +9,7 @@
#include <AK/DeprecatedString.h> #include <AK/DeprecatedString.h>
#include <AK/Format.h> #include <AK/Format.h>
#include <LibWeb/Forward.h> #include <LibWeb/Forward.h>
#include <LibWeb/PixelUnits.h>
namespace Web::Layout { namespace Web::Layout {
@ -21,7 +22,7 @@ public:
MaxContent, MaxContent,
}; };
static AvailableSize make_definite(float); static AvailableSize make_definite(CSSPixels);
static AvailableSize make_indefinite(); static AvailableSize make_indefinite();
static AvailableSize make_min_content(); static AvailableSize make_min_content();
static AvailableSize make_max_content(); static AvailableSize make_max_content();
@ -32,12 +33,12 @@ public:
bool is_max_content() const { return m_type == Type::MaxContent; } bool is_max_content() const { return m_type == Type::MaxContent; }
bool is_intrinsic_sizing_constraint() const { return is_min_content() || is_max_content(); } bool is_intrinsic_sizing_constraint() const { return is_min_content() || is_max_content(); }
float to_px() const CSSPixels to_px() const
{ {
return m_value; return m_value;
} }
float to_px_or_zero() const CSSPixels to_px_or_zero() const
{ {
if (!is_definite()) if (!is_definite())
return 0.0f; return 0.0f;
@ -47,10 +48,10 @@ public:
DeprecatedString to_deprecated_string() const; DeprecatedString to_deprecated_string() const;
private: private:
AvailableSize(Type type, float); AvailableSize(Type type, CSSPixels);
Type m_type {}; Type m_type {};
float m_value {}; CSSPixels m_value {};
}; };
class AvailableSpace { class AvailableSpace {

34
Userland/Libraries/LibWeb/Layout/BlockFormattingContext.cpp
View file

@ -40,7 +40,7 @@ bool BlockFormattingContext::is_initial() const
return is<InitialContainingBlock>(root()); return is<InitialContainingBlock>(root());
} }
float BlockFormattingContext::automatic_content_height() const CSSPixels BlockFormattingContext::automatic_content_height() const
{ {
return compute_auto_height_for_block_formatting_context_root(root()); return compute_auto_height_for_block_formatting_context_root(root());
} }
@ -80,7 +80,7 @@ void BlockFormattingContext::parent_context_did_dimension_child_root_box()
// Right-side floats: offset_from_edge is from right edge (float_containing_block_width) to the left content edge of floating_box. // Right-side floats: offset_from_edge is from right edge (float_containing_block_width) to the left content edge of floating_box.
for (auto& floating_box : m_right_floats.all_boxes) { for (auto& floating_box : m_right_floats.all_boxes) {
auto float_containing_block_width = containing_block_width_for(floating_box->box); auto float_containing_block_width = containing_block_width_for(floating_box->box).value();
auto& box_state = m_state.get_mutable(floating_box->box); auto& box_state = m_state.get_mutable(floating_box->box);
box_state.set_content_x(float_containing_block_width - floating_box->offset_from_edge); box_state.set_content_x(float_containing_block_width - floating_box->offset_from_edge);
} }
@ -117,7 +117,7 @@ void BlockFormattingContext::compute_width(Box const& box, AvailableSpace const&
auto const& computed_values = box.computed_values(); auto const& computed_values = box.computed_values();
float width_of_containing_block = available_space.width.to_px(); float width_of_containing_block = available_space.width.to_px().value();
auto width_of_containing_block_as_length_for_resolve = available_space.width.is_definite() ? CSS::Length::make_px(width_of_containing_block) : CSS::Length::make_px(0); auto width_of_containing_block_as_length_for_resolve = available_space.width.is_definite() ? CSS::Length::make_px(width_of_containing_block) : CSS::Length::make_px(0);
auto zero_value = CSS::Length::make_px(0); auto zero_value = CSS::Length::make_px(0);
@ -234,7 +234,7 @@ void BlockFormattingContext::compute_width_for_floating_box(Box const& box, Avai
auto& computed_values = box.computed_values(); auto& computed_values = box.computed_values();
auto zero_value = CSS::Length::make_px(0); auto zero_value = CSS::Length::make_px(0);
float width_of_containing_block = available_space.width.to_px(); float width_of_containing_block = available_space.width.to_px().value();
auto width_of_containing_block_as_length_for_resolve = CSS::Length::make_px(width_of_containing_block); auto width_of_containing_block_as_length_for_resolve = CSS::Length::make_px(width_of_containing_block);
if (!available_space.width.is_definite()) if (!available_space.width.is_definite())
width_of_containing_block_as_length_for_resolve = CSS::Length::make_px(0); width_of_containing_block_as_length_for_resolve = CSS::Length::make_px(0);
@ -309,7 +309,7 @@ void BlockFormattingContext::compute_width_for_floating_box(Box const& box, Avai
void BlockFormattingContext::compute_width_for_block_level_replaced_element_in_normal_flow(ReplacedBox const& box, AvailableSpace const& available_space) void BlockFormattingContext::compute_width_for_block_level_replaced_element_in_normal_flow(ReplacedBox const& box, AvailableSpace const& available_space)
{ {
m_state.get_mutable(box).set_content_width(compute_width_for_replaced_element(m_state, box, available_space)); m_state.get_mutable(box).set_content_width(compute_width_for_replaced_element(m_state, box, available_space).value());
} }
void BlockFormattingContext::compute_height(Box const& box, AvailableSpace const& available_space) void BlockFormattingContext::compute_height(Box const& box, AvailableSpace const& available_space)
@ -320,7 +320,7 @@ void BlockFormattingContext::compute_height(Box const& box, AvailableSpace const
// Then work out what the height is, based on box type and CSS properties. // Then work out what the height is, based on box type and CSS properties.
float height = 0; float height = 0;
if (is<ReplacedBox>(box)) { if (is<ReplacedBox>(box)) {
height = compute_height_for_replaced_element(m_state, verify_cast<ReplacedBox>(box), available_space); height = compute_height_for_replaced_element(m_state, verify_cast<ReplacedBox>(box), available_space).value();
} else { } else {
if (should_treat_height_as_auto(box, available_space)) { if (should_treat_height_as_auto(box, available_space)) {
height = compute_auto_height_for_block_level_element(box, available_space); height = compute_auto_height_for_block_level_element(box, available_space);
@ -354,9 +354,9 @@ void BlockFormattingContext::layout_inline_children(BlockContainer const& block_
available_space); available_space);
if (!block_container_state.has_definite_width()) if (!block_container_state.has_definite_width())
block_container_state.set_content_width(context.automatic_content_width()); block_container_state.set_content_width(context.automatic_content_width().value());
if (!block_container_state.has_definite_height()) if (!block_container_state.has_definite_height())
block_container_state.set_content_height(context.automatic_content_height()); block_container_state.set_content_height(context.automatic_content_height().value());
} }
static bool margins_collapse_through(Box const& box, LayoutState& state) static bool margins_collapse_through(Box const& box, LayoutState& state)
@ -371,7 +371,7 @@ static bool margins_collapse_through(Box const& box, LayoutState& state)
float BlockFormattingContext::compute_auto_height_for_block_level_element(Box const& box, AvailableSpace const& available_space) float BlockFormattingContext::compute_auto_height_for_block_level_element(Box const& box, AvailableSpace const& available_space)
{ {
if (creates_block_formatting_context(box)) { if (creates_block_formatting_context(box)) {
return compute_auto_height_for_block_formatting_context_root(verify_cast<BlockContainer>(box)); return compute_auto_height_for_block_formatting_context_root(verify_cast<BlockContainer>(box)).value();
} }
auto const& box_state = m_state.get(box); auto const& box_state = m_state.get(box);
@ -380,13 +380,13 @@ float BlockFormattingContext::compute_auto_height_for_block_level_element(Box co
if (display.is_flex_inside()) { if (display.is_flex_inside()) {
// https://drafts.csswg.org/css-flexbox-1/#algo-main-container // https://drafts.csswg.org/css-flexbox-1/#algo-main-container
// NOTE: The automatic block size of a block-level flex container is its max-content size. // NOTE: The automatic block size of a block-level flex container is its max-content size.
return calculate_max_content_height(box, available_space.width); return calculate_max_content_height(box, available_space.width).value();
} }
if (display.is_grid_inside()) { if (display.is_grid_inside()) {
// https://www.w3.org/TR/css-grid-2/#intrinsic-sizes // https://www.w3.org/TR/css-grid-2/#intrinsic-sizes
// In both inline and block formatting contexts, the grid container’s auto block size is its // In both inline and block formatting contexts, the grid container’s auto block size is its
// max-content size. // max-content size.
return calculate_max_content_height(box, available_space.width); return calculate_max_content_height(box, available_space.width).value();
} }
// https://www.w3.org/TR/CSS22/visudet.html#normal-block // https://www.w3.org/TR/CSS22/visudet.html#normal-block
@ -546,7 +546,7 @@ void BlockFormattingContext::layout_block_level_children(BlockContainer const& b
if (layout_mode == LayoutMode::IntrinsicSizing) { if (layout_mode == LayoutMode::IntrinsicSizing) {
auto& block_container_state = m_state.get_mutable(block_container); auto& block_container_state = m_state.get_mutable(block_container);
if (!block_container_state.has_definite_width()) if (!block_container_state.has_definite_width())
block_container_state.set_content_width(greatest_child_width(block_container)); block_container_state.set_content_width(greatest_child_width(block_container).value());
if (!block_container_state.has_definite_height()) if (!block_container_state.has_definite_height())
block_container_state.set_content_height(bottom_of_lowest_margin_box); block_container_state.set_content_height(bottom_of_lowest_margin_box);
} }
@ -637,14 +637,14 @@ void BlockFormattingContext::place_block_level_element_in_normal_flow_horizontal
auto& box_state = m_state.get_mutable(child_box); auto& box_state = m_state.get_mutable(child_box);
float x = 0; float x = 0;
float available_width_within_containing_block = available_space.width.to_px(); float available_width_within_containing_block = available_space.width.to_px().value();
if ((!m_left_floats.current_boxes.is_empty() || !m_right_floats.current_boxes.is_empty()) if ((!m_left_floats.current_boxes.is_empty() || !m_right_floats.current_boxes.is_empty())
&& creates_block_formatting_context(child_box)) { && creates_block_formatting_context(child_box)) {
auto box_in_root_rect = content_box_rect_in_ancestor_coordinate_space(child_box, root(), m_state); auto box_in_root_rect = content_box_rect_in_ancestor_coordinate_space(child_box, root(), m_state);
auto space = space_used_by_floats(box_in_root_rect.y()); auto space = space_used_by_floats(box_in_root_rect.y());
available_width_within_containing_block -= space.left + space.right; available_width_within_containing_block -= space.left.value() + space.right.value();
x += space.left; x += space.left.value();
} }
if (child_box.containing_block()->computed_values().text_align() == CSS::TextAlign::LibwebCenter) { if (child_box.containing_block()->computed_values().text_align() == CSS::TextAlign::LibwebCenter) {
@ -704,7 +704,7 @@ void BlockFormattingContext::layout_floating_box(Box const& box, BlockContainer
VERIFY(box.is_floating()); VERIFY(box.is_floating());
auto& box_state = m_state.get_mutable(box); auto& box_state = m_state.get_mutable(box);
float width_of_containing_block = available_space.width.to_px(); float width_of_containing_block = available_space.width.to_px().value();
compute_width(box, available_space, layout_mode); compute_width(box, available_space, layout_mode);
auto independent_formatting_context = layout_inside(box, layout_mode, box_state.available_inner_space_or_constraints_from(available_space)); auto independent_formatting_context = layout_inside(box, layout_mode, box_state.available_inner_space_or_constraints_from(available_space));
@ -895,7 +895,7 @@ BlockFormattingContext::SpaceUsedByFloats BlockFormattingContext::space_used_by_
return space_used_by_floats; return space_used_by_floats;
} }
float BlockFormattingContext::greatest_child_width(Box const& box) CSSPixels BlockFormattingContext::greatest_child_width(Box const& box)
{ {
// Similar to FormattingContext::greatest_child_width() // Similar to FormattingContext::greatest_child_width()
// but this one takes floats into account! // but this one takes floats into account!

4
Userland/Libraries/LibWeb/Layout/BlockFormattingContext.h
View file

@ -22,7 +22,7 @@ public:
~BlockFormattingContext(); ~BlockFormattingContext();
virtual void run(Box const&, LayoutMode, AvailableSpace const&) override; virtual void run(Box const&, LayoutMode, AvailableSpace const&) override;
virtual float automatic_content_height() const override; virtual CSSPixels automatic_content_height() const override;
bool is_initial() const; bool is_initial() const;
@ -42,7 +42,7 @@ public:
SpaceUsedByFloats space_used_by_floats(float y) const; SpaceUsedByFloats space_used_by_floats(float y) const;
virtual float greatest_child_width(Box const&) override; virtual CSSPixels greatest_child_width(Box const&) override;
void layout_floating_box(Box const& child, BlockContainer const& containing_block, LayoutMode, AvailableSpace const&, float y, LineBuilder* = nullptr); void layout_floating_box(Box const& child, BlockContainer const& containing_block, LayoutMode, AvailableSpace const&, float y, LineBuilder* = nullptr);

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

@ -78,7 +78,7 @@ FlexFormattingContext::FlexFormattingContext(LayoutState& state, Box const& flex
FlexFormattingContext::~FlexFormattingContext() = default; FlexFormattingContext::~FlexFormattingContext() = default;
float FlexFormattingContext::automatic_content_height() const CSSPixels FlexFormattingContext::automatic_content_height() const
{ {
return m_state.get(flex_container()).content_height(); return m_state.get(flex_container()).content_height();
} }
@ -584,7 +584,7 @@ float FlexFormattingContext::calculate_indefinite_main_size(FlexItem const& item
box_state.set_content_width(fit_content_cross_size); box_state.set_content_width(fit_content_cross_size);
independent_formatting_context->run(item.box, LayoutMode::Normal, m_available_space_for_items->space); independent_formatting_context->run(item.box, LayoutMode::Normal, m_available_space_for_items->space);
return independent_formatting_context->automatic_content_height(); return independent_formatting_context->automatic_content_height().value();
} }
return calculate_fit_content_main_size(item); return calculate_fit_content_main_size(item);
@ -825,13 +825,13 @@ void FlexFormattingContext::determine_main_size_of_flex_container()
if (is_row_layout()) { if (is_row_layout()) {
if (!flex_container().is_out_of_flow(*parent()) && m_state.get(*flex_container().containing_block()).has_definite_width()) { if (!flex_container().is_out_of_flow(*parent()) && m_state.get(*flex_container().containing_block()).has_definite_width()) {
set_main_size(flex_container(), calculate_stretch_fit_width(flex_container(), m_available_space_for_flex_container->space.width)); set_main_size(flex_container(), calculate_stretch_fit_width(flex_container(), m_available_space_for_flex_container->space.width).value());
} else { } else {
set_main_size(flex_container(), calculate_max_content_width(flex_container())); set_main_size(flex_container(), calculate_max_content_width(flex_container()).value());
} }
} else { } else {
if (!has_definite_main_size(flex_container())) if (!has_definite_main_size(flex_container()))
set_main_size(flex_container(), calculate_max_content_height(flex_container(), m_available_space_for_flex_container->space.width)); set_main_size(flex_container(), calculate_max_content_height(flex_container(), m_available_space_for_flex_container->space.width).value());
} }
} }
@ -1108,7 +1108,7 @@ void FlexFormattingContext::determine_hypothetical_cross_size_of_item(FlexItem&
auto automatic_cross_size = is_row_layout() ? independent_formatting_context->automatic_content_height() auto automatic_cross_size = is_row_layout() ? independent_formatting_context->automatic_content_height()
: box_state.content_width(); : box_state.content_width();
item.hypothetical_cross_size = css_clamp(automatic_cross_size, clamp_min, clamp_max); item.hypothetical_cross_size = css_clamp(automatic_cross_size.value(), clamp_min, clamp_max);
} }
// https://www.w3.org/TR/css-flexbox-1/#algo-cross-line // https://www.w3.org/TR/css-flexbox-1/#algo-cross-line
@ -1831,34 +1831,34 @@ float FlexFormattingContext::calculate_cross_max_content_contribution(FlexItem c
float FlexFormattingContext::calculate_min_content_main_size(FlexItem const& item) const float FlexFormattingContext::calculate_min_content_main_size(FlexItem const& item) const
{ {
return is_row_layout() ? calculate_min_content_width(item.box) : calculate_min_content_height(item.box, m_available_space_for_items->space.width); return is_row_layout() ? calculate_min_content_width(item.box).value() : calculate_min_content_height(item.box, m_available_space_for_items->space.width).value();
} }
float FlexFormattingContext::calculate_fit_content_main_size(FlexItem const& item) const float FlexFormattingContext::calculate_fit_content_main_size(FlexItem const& item) const
{ {
return is_row_layout() ? calculate_fit_content_width(item.box, m_available_space_for_items->space) return is_row_layout() ? calculate_fit_content_width(item.box, m_available_space_for_items->space).value()
: calculate_fit_content_height(item.box, m_available_space_for_items->space); : calculate_fit_content_height(item.box, m_available_space_for_items->space).value();
} }
float FlexFormattingContext::calculate_fit_content_cross_size(FlexItem const& item) const float FlexFormattingContext::calculate_fit_content_cross_size(FlexItem const& item) const
{ {
return !is_row_layout() ? calculate_fit_content_width(item.box, m_available_space_for_items->space) return !is_row_layout() ? calculate_fit_content_width(item.box, m_available_space_for_items->space).value()
: calculate_fit_content_height(item.box, m_available_space_for_items->space); : calculate_fit_content_height(item.box, m_available_space_for_items->space).value();
} }
float FlexFormattingContext::calculate_max_content_main_size(FlexItem const& item) const float FlexFormattingContext::calculate_max_content_main_size(FlexItem const& item) const
{ {
return is_row_layout() ? calculate_max_content_width(item.box) : calculate_max_content_height(item.box, m_available_space_for_items->space.width); return is_row_layout() ? calculate_max_content_width(item.box).value() : calculate_max_content_height(item.box, m_available_space_for_items->space.width).value();
} }
float FlexFormattingContext::calculate_min_content_cross_size(FlexItem const& item) const float FlexFormattingContext::calculate_min_content_cross_size(FlexItem const& item) const
{ {
return is_row_layout() ? calculate_min_content_height(item.box, m_available_space_for_items->space.width) : calculate_min_content_width(item.box); return is_row_layout() ? calculate_min_content_height(item.box, m_available_space_for_items->space.width).value() : calculate_min_content_width(item.box).value();
} }
float FlexFormattingContext::calculate_max_content_cross_size(FlexItem const& item) const float FlexFormattingContext::calculate_max_content_cross_size(FlexItem const& item) const
{ {
return is_row_layout() ? calculate_max_content_height(item.box, m_available_space_for_items->space.width) : calculate_max_content_width(item.box); return is_row_layout() ? calculate_max_content_height(item.box, m_available_space_for_items->space.width).value() : calculate_max_content_width(item.box).value();
} }
// https://drafts.csswg.org/css-flexbox-1/#stretched // https://drafts.csswg.org/css-flexbox-1/#stretched
@ -1961,7 +1961,7 @@ void FlexFormattingContext::handle_align_content_stretch()
} }
// https://drafts.csswg.org/css-flexbox-1/#abspos-items // https://drafts.csswg.org/css-flexbox-1/#abspos-items
Gfx::FloatPoint FlexFormattingContext::calculate_static_position(Box const& box) const CSSPixelPoint FlexFormattingContext::calculate_static_position(Box const& box) const
{ {
// The cross-axis edges of the static-position rectangle of an absolutely-positioned child // The cross-axis edges of the static-position rectangle of an absolutely-positioned child
// of a flex container are the content edges of the flex container. // of a flex container are the content edges of the flex container.
@ -2060,7 +2060,7 @@ Gfx::FloatPoint FlexFormattingContext::calculate_static_position(Box const& box)
auto absolute_position_of_abspos_containing_block = absolute_content_rect(*box.containing_block(), m_state).location(); auto absolute_position_of_abspos_containing_block = absolute_content_rect(*box.containing_block(), m_state).location();
auto diff = absolute_position_of_flex_container - absolute_position_of_abspos_containing_block; auto diff = absolute_position_of_flex_container - absolute_position_of_abspos_containing_block;
return static_position_offset + diff; return (static_position_offset + diff).to_type<CSSPixels>();
} }
} }

4
Userland/Libraries/LibWeb/Layout/FlexFormattingContext.h
View file

@ -19,7 +19,7 @@ public:
virtual bool inhibits_floating() const override { return true; } virtual bool inhibits_floating() const override { return true; }
virtual void run(Box const&, LayoutMode, AvailableSpace const&) override; virtual void run(Box const&, LayoutMode, AvailableSpace const&) override;
virtual float automatic_content_height() const override; virtual CSSPixels automatic_content_height() const override;
Box const& flex_container() const { return context_box(); } Box const& flex_container() const { return context_box(); }
@ -27,7 +27,7 @@ public:
virtual void determine_width_of_child(Box const&, AvailableSpace const&) override; virtual void determine_width_of_child(Box const&, AvailableSpace const&) override;
virtual void determine_height_of_child(Box const&, AvailableSpace const&) override; virtual void determine_height_of_child(Box const&, AvailableSpace const&) override;
virtual Gfx::FloatPoint calculate_static_position(Box const&) const override; virtual CSSPixelPoint calculate_static_position(Box const&) const override;
private: private:
[[nodiscard]] bool should_treat_main_size_as_auto(Box const&) const; [[nodiscard]] bool should_treat_main_size_as_auto(Box const&) const;

148
Userland/Libraries/LibWeb/Layout/FormattingContext.cpp
View file

@ -127,7 +127,7 @@ OwnPtr<FormattingContext> FormattingContext::create_independent_formatting_conte
: FormattingContext(Type::Block, state, box) : FormattingContext(Type::Block, state, box)
{ {
} }
virtual float automatic_content_height() const override { return 0; }; virtual CSSPixels automatic_content_height() const override { return 0; };
virtual void run(Box const&, LayoutMode, AvailableSpace const&) override { } virtual void run(Box const&, LayoutMode, AvailableSpace const&) override { }
}; };
return make<ReplacedFormattingContext>(state, child_box); return make<ReplacedFormattingContext>(state, child_box);
@ -170,7 +170,7 @@ OwnPtr<FormattingContext> FormattingContext::create_independent_formatting_conte
: FormattingContext(Type::Block, state, box) : FormattingContext(Type::Block, state, box)
{ {
} }
virtual float automatic_content_height() const override { return 0; }; virtual CSSPixels automatic_content_height() const override { return 0; };
virtual void run(Box const&, LayoutMode, AvailableSpace const&) override { } virtual void run(Box const&, LayoutMode, AvailableSpace const&) override { }
}; };
return make<DummyFormattingContext>(state, child_box); return make<DummyFormattingContext>(state, child_box);
@ -208,9 +208,9 @@ OwnPtr<FormattingContext> FormattingContext::layout_inside(Box const& child_box,
return independent_formatting_context; return independent_formatting_context;
} }
float FormattingContext::greatest_child_width(Box const& box) CSSPixels FormattingContext::greatest_child_width(Box const& box)
{ {
float max_width = 0; CSSPixels max_width = 0;
if (box.children_are_inline()) { if (box.children_are_inline()) {
for (auto& line_box : m_state.get(box).line_boxes) { for (auto& line_box : m_state.get(box).line_boxes) {
max_width = max(max_width, line_box.width()); max_width = max(max_width, line_box.width());
@ -232,7 +232,7 @@ FormattingContext::ShrinkToFitResult FormattingContext::calculate_shrink_to_fit_
}; };
} }
static Gfx::FloatSize solve_replaced_size_constraint(LayoutState const& state, float w, float h, ReplacedBox const& box) static CSSPixelSize solve_replaced_size_constraint(LayoutState const& state, CSSPixels w, CSSPixels h, ReplacedBox const& box)
{ {
// 10.4 Minimum and maximum widths: 'min-width' and 'max-width' // 10.4 Minimum and maximum widths: 'min-width' and 'max-width'
@ -241,10 +241,10 @@ static Gfx::FloatSize solve_replaced_size_constraint(LayoutState const& state, f
auto width_of_containing_block = CSS::Length::make_px(containing_block_state.content_width()); auto width_of_containing_block = CSS::Length::make_px(containing_block_state.content_width());
auto height_of_containing_block = CSS::Length::make_px(containing_block_state.content_height()); auto height_of_containing_block = CSS::Length::make_px(containing_block_state.content_height());
auto specified_min_width = box.computed_values().min_width().is_auto() ? 0 : box.computed_values().min_width().resolved(box, width_of_containing_block).to_px(box); CSSPixels specified_min_width = box.computed_values().min_width().is_auto() ? 0 : box.computed_values().min_width().resolved(box, width_of_containing_block).to_px(box);
auto specified_max_width = box.computed_values().max_width().is_none() ? w : box.computed_values().max_width().resolved(box, width_of_containing_block).to_px(box); CSSPixels specified_max_width = box.computed_values().max_width().is_none() ? w : box.computed_values().max_width().resolved(box, width_of_containing_block).to_px(box);
auto specified_min_height = box.computed_values().min_height().is_auto() ? 0 : box.computed_values().min_height().resolved(box, height_of_containing_block).to_px(box); CSSPixels specified_min_height = box.computed_values().min_height().is_auto() ? 0 : box.computed_values().min_height().resolved(box, height_of_containing_block).to_px(box);
auto specified_max_height = box.computed_values().max_height().is_none() ? h : box.computed_values().max_height().resolved(box, height_of_containing_block).to_px(box); CSSPixels specified_max_height = box.computed_values().max_height().is_none() ? h : box.computed_values().max_height().resolved(box, height_of_containing_block).to_px(box);
auto min_width = min(specified_min_width, specified_max_width); auto min_width = min(specified_min_width, specified_max_width);
auto max_width = max(specified_min_width, specified_max_width); auto max_width = max(specified_min_width, specified_max_width);
@ -252,21 +252,21 @@ static Gfx::FloatSize solve_replaced_size_constraint(LayoutState const& state, f
auto max_height = max(specified_min_height, specified_max_height); auto max_height = max(specified_min_height, specified_max_height);
if (w > max_width) if (w > max_width)
return { w, max(max_width * h / w, min_height) }; return { w, max(max_width * (h / w), min_height) };
if (w < min_width) if (w < min_width)
return { max_width, min(min_width * h / w, max_height) }; return { max_width, min(min_width * (h / w), max_height) };
if (h > max_height) if (h > max_height)
return { max(max_height * w / h, min_width), max_height }; return { max(max_height * (w / h), min_width), max_height };
if (h < min_height) if (h < min_height)
return { min(min_height * w / h, max_width), min_height }; return { min(min_height * (w / h), max_width), min_height };
if ((w > max_width && h > max_height) && (max_width / w < max_height / h)) if ((w > max_width && h > max_height) && (max_width / w < max_height / h))
return { max_width, max(min_height, max_width * h / w) }; return { max_width, max(min_height, max_width * (h / w)) };
if ((w > max_width && h > max_height) && (max_width / w > max_height / h)) if ((w > max_width && h > max_height) && (max_width / w > max_height / h))
return { max(min_width, max_height * w / h), max_height }; return { max(min_width, max_height * (w / h)), max_height };
if ((w < min_width && h < min_height) && (min_width / w < min_height / h)) if ((w < min_width && h < min_height) && (min_width / w < min_height / h))
return { min(max_width, min_height * w / h), min_height }; return { min(max_width, min_height * (w / h)), min_height };
if ((w < min_width && h < min_height) && (min_width / w > min_height / h)) if ((w < min_width && h < min_height) && (min_width / w > min_height / h))
return { min_width, min(max_height, min_width * h / w) }; return { min_width, min(max_height, min_width * (h / w)) };
if (w < min_width && h > max_height) if (w < min_width && h > max_height)
return { min_width, max_height }; return { min_width, max_height };
if (w > max_width && h < min_height) if (w > max_width && h < min_height)
@ -275,11 +275,11 @@ static Gfx::FloatSize solve_replaced_size_constraint(LayoutState const& state, f
} }
// https://www.w3.org/TR/CSS22/visudet.html#root-height // https://www.w3.org/TR/CSS22/visudet.html#root-height
float FormattingContext::compute_auto_height_for_block_formatting_context_root(BlockContainer const& root) const CSSPixels FormattingContext::compute_auto_height_for_block_formatting_context_root(BlockContainer const& root) const
{ {
// 10.6.7 'Auto' heights for block formatting context roots // 10.6.7 'Auto' heights for block formatting context roots
Optional<float> top; Optional<CSSPixels> top;
Optional<float> bottom; Optional<CSSPixels> bottom;
if (root.children_are_inline()) { if (root.children_are_inline()) {
// If it only has inline-level children, the height is the distance between // If it only has inline-level children, the height is the distance between
@ -305,8 +305,8 @@ float FormattingContext::compute_auto_height_for_block_formatting_context_root(B
auto const& child_box_state = m_state.get(child_box); auto const& child_box_state = m_state.get(child_box);
float child_box_top = child_box_state.offset.y() - child_box_state.margin_box_top(); CSSPixels child_box_top = child_box_state.offset.y() - child_box_state.margin_box_top();
float child_box_bottom = child_box_state.offset.y() + child_box_state.content_height() + child_box_state.margin_box_bottom(); CSSPixels child_box_bottom = child_box_state.offset.y() + child_box_state.content_height() + child_box_state.margin_box_bottom();
if (!top.has_value() || child_box_top < top.value()) if (!top.has_value() || child_box_top < top.value())
top = child_box_top; top = child_box_top;
@ -325,16 +325,16 @@ float FormattingContext::compute_auto_height_for_block_formatting_context_root(B
// NOTE: Floating box coordinates are relative to their own containing block, // NOTE: Floating box coordinates are relative to their own containing block,
// which may or may not be the BFC root. // which may or may not be the BFC root.
auto margin_box = margin_box_rect_in_ancestor_coordinate_space(*floating_box, root, m_state); auto margin_box = margin_box_rect_in_ancestor_coordinate_space(*floating_box, root, m_state);
float floating_box_bottom_margin_edge = margin_box.bottom() + 1; CSSPixels floating_box_bottom_margin_edge = margin_box.bottom() + 1;
if (!bottom.has_value() || floating_box_bottom_margin_edge > bottom.value()) if (!bottom.has_value() || floating_box_bottom_margin_edge > bottom.value())
bottom = floating_box_bottom_margin_edge; bottom = floating_box_bottom_margin_edge;
} }
return max(0.0f, bottom.value_or(0) - top.value_or(0)); return max(CSSPixels(0.0f), bottom.value_or(0) - top.value_or(0));
} }
// 10.3.2 Inline, replaced elements, https://www.w3.org/TR/CSS22/visudet.html#inline-replaced-width // 10.3.2 Inline, replaced elements, https://www.w3.org/TR/CSS22/visudet.html#inline-replaced-width
float FormattingContext::tentative_width_for_replaced_element(LayoutState const& state, ReplacedBox const& box, CSS::Size const& computed_width, AvailableSpace const& available_space) CSSPixels FormattingContext::tentative_width_for_replaced_element(LayoutState const& state, ReplacedBox const& box, CSS::Size const& computed_width, AvailableSpace const& available_space)
{ {
// Treat percentages of indefinite containing block widths as 0 (the initial width). // Treat percentages of indefinite containing block widths as 0 (the initial width).
if (computed_width.is_percentage() && !state.get(*box.containing_block()).has_definite_width()) if (computed_width.is_percentage() && !state.get(*box.containing_block()).has_definite_width())
@ -343,7 +343,7 @@ float FormattingContext::tentative_width_for_replaced_element(LayoutState const&
auto height_of_containing_block = CSS::Length::make_px(containing_block_height_for(box, state)); auto height_of_containing_block = CSS::Length::make_px(containing_block_height_for(box, state));
auto computed_height = should_treat_height_as_auto(box, available_space) ? CSS::Size::make_auto() : box.computed_values().height(); auto computed_height = should_treat_height_as_auto(box, available_space) ? CSS::Size::make_auto() : box.computed_values().height();
float used_width = computed_width.resolved(box, CSS::Length::make_px(available_space.width.to_px())).to_px(box); CSSPixels used_width = computed_width.resolved(box, CSS::Length::make_px(available_space.width.to_px())).to_px(box);
// If 'height' and 'width' both have computed values of 'auto' and the element also has an intrinsic width, // If 'height' and 'width' both have computed values of 'auto' and the element also has an intrinsic width,
// then that intrinsic width is the used value of 'width'. // then that intrinsic width is the used value of 'width'.
@ -394,7 +394,7 @@ void FormattingContext::compute_height_for_absolutely_positioned_element(Box con
compute_height_for_absolutely_positioned_non_replaced_element(box, available_space); compute_height_for_absolutely_positioned_non_replaced_element(box, available_space);
} }
float FormattingContext::compute_width_for_replaced_element(LayoutState const& state, ReplacedBox const& box, AvailableSpace const& available_space) CSSPixels FormattingContext::compute_width_for_replaced_element(LayoutState const& state, ReplacedBox const& box, AvailableSpace const& available_space)
{ {
// 10.3.4 Block-level, replaced elements in normal flow... // 10.3.4 Block-level, replaced elements in normal flow...
// 10.3.2 Inline, replaced elements // 10.3.2 Inline, replaced elements
@ -439,7 +439,7 @@ float FormattingContext::compute_width_for_replaced_element(LayoutState const& s
// 10.6.2 Inline replaced elements, block-level replaced elements in normal flow, 'inline-block' replaced elements in normal flow and floating replaced elements // 10.6.2 Inline replaced elements, block-level replaced elements in normal flow, 'inline-block' replaced elements in normal flow and floating replaced elements
// https://www.w3.org/TR/CSS22/visudet.html#inline-replaced-height // https://www.w3.org/TR/CSS22/visudet.html#inline-replaced-height
float FormattingContext::tentative_height_for_replaced_element(LayoutState const& state, ReplacedBox const& box, CSS::Size const& computed_height, AvailableSpace const& available_space) CSSPixels FormattingContext::tentative_height_for_replaced_element(LayoutState const& state, ReplacedBox const& box, CSS::Size const& computed_height, AvailableSpace const& available_space)
{ {
// If 'height' and 'width' both have computed values of 'auto' and the element also has // If 'height' and 'width' both have computed values of 'auto' and the element also has
// an intrinsic height, then that intrinsic height is the used value of 'height'. // an intrinsic height, then that intrinsic height is the used value of 'height'.
@ -465,7 +465,7 @@ float FormattingContext::tentative_height_for_replaced_element(LayoutState const
return computed_height.resolved(box, CSS::Length::make_px(available_space.height.to_px())).to_px(box); return computed_height.resolved(box, CSS::Length::make_px(available_space.height.to_px())).to_px(box);
} }
float FormattingContext::compute_height_for_replaced_element(LayoutState const& state, ReplacedBox const& box, AvailableSpace const& available_space) CSSPixels FormattingContext::compute_height_for_replaced_element(LayoutState const& state, ReplacedBox const& box, AvailableSpace const& available_space)
{ {
// 10.6.2 Inline replaced elements, block-level replaced elements in normal flow, // 10.6.2 Inline replaced elements, block-level replaced elements in normal flow,
// 'inline-block' replaced elements in normal flow and floating replaced elements // 'inline-block' replaced elements in normal flow and floating replaced elements
@ -475,11 +475,11 @@ float FormattingContext::compute_height_for_replaced_element(LayoutState const&
auto computed_width = should_treat_width_as_auto(box, available_space) ? CSS::Size::make_auto() : box.computed_values().width(); auto computed_width = should_treat_width_as_auto(box, available_space) ? CSS::Size::make_auto() : box.computed_values().width();
auto computed_height = should_treat_height_as_auto(box, available_space) ? CSS::Size::make_auto() : box.computed_values().height(); auto computed_height = should_treat_height_as_auto(box, available_space) ? CSS::Size::make_auto() : box.computed_values().height();
float used_height = tentative_height_for_replaced_element(state, box, computed_height, available_space); CSSPixels used_height = tentative_height_for_replaced_element(state, box, computed_height, available_space);
if (computed_width.is_auto() && computed_height.is_auto() && box.has_intrinsic_aspect_ratio()) { if (computed_width.is_auto() && computed_height.is_auto() && box.has_intrinsic_aspect_ratio()) {
float w = tentative_width_for_replaced_element(state, box, computed_width, available_space); CSSPixels w = tentative_width_for_replaced_element(state, box, computed_width, available_space);
float h = used_height; CSSPixels h = used_height;
used_height = solve_replaced_size_constraint(state, w, h, box).height(); used_height = solve_replaced_size_constraint(state, w, h, box).height();
} }
@ -509,15 +509,15 @@ void FormattingContext::compute_width_for_absolutely_positioned_non_replaced_ele
auto width = a_width; auto width = a_width;
auto solve_for_left = [&] { auto solve_for_left = [&] {
return CSS::Length(width_of_containing_block - margin_left.to_px(box) - border_left - padding_left - width.to_px(box) - padding_right - border_right - margin_right.to_px(box) - right.to_px(box), CSS::Length::Type::Px); return CSS::Length::make_px(width_of_containing_block - margin_left.to_px(box) - border_left - padding_left - width.to_px(box) - padding_right - border_right - margin_right.to_px(box) - right.to_px(box));
}; };
auto solve_for_width = [&] { auto solve_for_width = [&] {
return CSS::Length(width_of_containing_block - left.to_px(box) - margin_left.to_px(box) - border_left - padding_left - padding_right - border_right - margin_right.to_px(box) - right.to_px(box), CSS::Length::Type::Px); return CSS::Length::make_px(width_of_containing_block - left.to_px(box) - margin_left.to_px(box) - border_left - padding_left - padding_right - border_right - margin_right.to_px(box) - right.to_px(box));
}; };
auto solve_for_right = [&] { auto solve_for_right = [&] {
return CSS::Length(width_of_containing_block - left.to_px(box) - margin_left.to_px(box) - border_left - padding_left - width.to_px(box) - padding_right - border_right - margin_right.to_px(box), CSS::Length::Type::Px); return CSS::Length::make_px(width_of_containing_block - left.to_px(box) - margin_left.to_px(box) - border_left - padding_left - width.to_px(box) - padding_right - border_right - margin_right.to_px(box));
}; };
// If all three of 'left', 'width', and 'right' are 'auto': // If all three of 'left', 'width', and 'right' are 'auto':
@ -550,7 +550,7 @@ void FormattingContext::compute_width_for_absolutely_positioned_non_replaced_ele
if (left.is_auto() && width.is_auto() && !right.is_auto()) { if (left.is_auto() && width.is_auto() && !right.is_auto()) {
auto result = calculate_shrink_to_fit_widths(box); auto result = calculate_shrink_to_fit_widths(box);
auto available_width = solve_for_width(); auto available_width = solve_for_width();
width = CSS::Length(min(max(result.preferred_minimum_width, available_width.to_px(box)), result.preferred_width), CSS::Length::Type::Px); width = CSS::Length::make_px(min(max(result.preferred_minimum_width, available_width.to_px(box)), result.preferred_width));
left = solve_for_left(); left = solve_for_left();
} }
@ -572,7 +572,7 @@ void FormattingContext::compute_width_for_absolutely_positioned_non_replaced_ele
Rule3: Rule3:
auto result = calculate_shrink_to_fit_widths(box); auto result = calculate_shrink_to_fit_widths(box);
auto available_width = solve_for_width(); auto available_width = solve_for_width();
width = CSS::Length(min(max(result.preferred_minimum_width, available_width.to_px(box)), result.preferred_width), CSS::Length::Type::Px); width = CSS::Length::make_px(min(max(result.preferred_minimum_width, available_width.to_px(box)), result.preferred_width));
right = solve_for_right(); right = solve_for_right();
} }
@ -632,7 +632,7 @@ void FormattingContext::compute_width_for_absolutely_positioned_replaced_element
// The used value of 'width' is determined as for inline replaced elements. // The used value of 'width' is determined as for inline replaced elements.
// FIXME: This const_cast is gross. // FIXME: This const_cast is gross.
const_cast<ReplacedBox&>(box).prepare_for_replaced_layout(); const_cast<ReplacedBox&>(box).prepare_for_replaced_layout();
m_state.get_mutable(box).set_content_width(compute_width_for_replaced_element(m_state, box, available_space)); m_state.get_mutable(box).set_content_width(compute_width_for_replaced_element(m_state, box, available_space).value());
} }
// https://drafts.csswg.org/css-position-3/#abs-non-replaced-height // https://drafts.csswg.org/css-position-3/#abs-non-replaced-height
@ -817,30 +817,30 @@ void FormattingContext::compute_height_for_absolutely_positioned_non_replaced_el
} }
// NOTE: This is different from content_box_rect_in_ancestor_coordinate_space() as this does *not* follow the containing block chain up, but rather the parent() chain. // NOTE: This is different from content_box_rect_in_ancestor_coordinate_space() as this does *not* follow the containing block chain up, but rather the parent() chain.
static Gfx::FloatRect content_box_rect_in_static_position_ancestor_coordinate_space(Box const& box, Box const& ancestor_box, LayoutState const& state) static CSSPixelRect content_box_rect_in_static_position_ancestor_coordinate_space(Box const& box, Box const& ancestor_box, LayoutState const& state)
{ {
auto rect = content_box_rect(box, state); auto rect = content_box_rect(box, state).to_type<CSSPixels>();
if (&box == &ancestor_box) if (&box == &ancestor_box)
return rect; return rect;
for (auto const* current = box.parent(); current; current = current->parent()) { for (auto const* current = box.parent(); current; current = current->parent()) {
if (current == &ancestor_box) if (current == &ancestor_box)
return rect; return rect;
auto const& current_state = state.get(static_cast<Box const&>(*current)); auto const& current_state = state.get(static_cast<Box const&>(*current));
rect.translate_by(current_state.offset); rect.translate_by(current_state.offset.to_type<CSSPixels>());
} }
// If we get here, ancestor_box was not an ancestor of `box`! // If we get here, ancestor_box was not an ancestor of `box`!
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
} }
// https://www.w3.org/TR/css-position-3/#staticpos-rect // https://www.w3.org/TR/css-position-3/#staticpos-rect
Gfx::FloatPoint FormattingContext::calculate_static_position(Box const& box) const CSSPixelPoint FormattingContext::calculate_static_position(Box const& box) const
{ {
// NOTE: This is very ad-hoc. // NOTE: This is very ad-hoc.
// The purpose of this function is to calculate the approximate position that `box` // The purpose of this function is to calculate the approximate position that `box`
// would have had if it were position:static. // would have had if it were position:static.
float x = 0.0f; CSSPixels x = 0.0f;
float y = 0.0f; CSSPixels y = 0.0f;
VERIFY(box.parent()); VERIFY(box.parent());
if (box.parent()->children_are_inline()) { if (box.parent()->children_are_inline()) {
@ -927,14 +927,14 @@ void FormattingContext::layout_absolutely_positioned_element(Box const& box, Ava
auto static_position = calculate_static_position(box); auto static_position = calculate_static_position(box);
Gfx::FloatPoint used_offset; CSSPixelPoint used_offset;
if (!computed_left.is_auto()) { if (!computed_left.is_auto()) {
float x_offset = box_state.inset_left CSSPixels x_offset = box_state.inset_left
+ box_state.border_box_left(); + box_state.border_box_left();
used_offset.set_x(x_offset + box_state.margin_left); used_offset.set_x(x_offset + box_state.margin_left);
} else if (!computed_right.is_auto()) { } else if (!computed_right.is_auto()) {
float x_offset = 0 CSSPixels x_offset = 0
- box_state.inset_right - box_state.inset_right
- box_state.border_box_right(); - box_state.border_box_right();
used_offset.set_x(width_of_containing_block + x_offset - box_state.content_width() - box_state.margin_right); used_offset.set_x(width_of_containing_block + x_offset - box_state.content_width() - box_state.margin_right);
@ -944,11 +944,11 @@ void FormattingContext::layout_absolutely_positioned_element(Box const& box, Ava
} }
if (!computed_top.is_auto()) { if (!computed_top.is_auto()) {
float y_offset = box_state.inset_top CSSPixels y_offset = box_state.inset_top
+ box_state.border_box_top(); + box_state.border_box_top();
used_offset.set_y(y_offset + box_state.margin_top); used_offset.set_y(y_offset + box_state.margin_top);
} else if (!computed_bottom.is_auto()) { } else if (!computed_bottom.is_auto()) {
float y_offset = 0 CSSPixels y_offset = 0
- box_state.inset_bottom - box_state.inset_bottom
- box_state.border_box_bottom(); - box_state.border_box_bottom();
used_offset.set_y(height_of_containing_block + y_offset - box_state.content_height() - box_state.margin_bottom); used_offset.set_y(height_of_containing_block + y_offset - box_state.content_height() - box_state.margin_bottom);
@ -960,7 +960,7 @@ void FormattingContext::layout_absolutely_positioned_element(Box const& box, Ava
// NOTE: Absolutely positioned boxes are relative to the *padding edge* of the containing block. // NOTE: Absolutely positioned boxes are relative to the *padding edge* of the containing block.
used_offset.translate_by(-containing_block_state.padding_left, -containing_block_state.padding_top); used_offset.translate_by(-containing_block_state.padding_left, -containing_block_state.padding_top);
box_state.set_content_offset(used_offset); box_state.set_content_offset(used_offset.to_type<float>());
if (independent_formatting_context) if (independent_formatting_context)
independent_formatting_context->parent_context_did_dimension_child_root_box(); independent_formatting_context->parent_context_did_dimension_child_root_box();
@ -970,7 +970,7 @@ void FormattingContext::compute_height_for_absolutely_positioned_replaced_elemen
{ {
// 10.6.5 Absolutely positioned, replaced elements // 10.6.5 Absolutely positioned, replaced elements
// The used value of 'height' is determined as for inline replaced elements. // The used value of 'height' is determined as for inline replaced elements.
m_state.get_mutable(box).set_content_height(compute_height_for_replaced_element(m_state, box, available_space)); m_state.get_mutable(box).set_content_height(compute_height_for_replaced_element(m_state, box, available_space).value());
} }
// https://www.w3.org/TR/css-position-3/#relpos-insets // https://www.w3.org/TR/css-position-3/#relpos-insets
@ -979,7 +979,7 @@ void FormattingContext::compute_inset(Box const& box)
if (box.computed_values().position() != CSS::Position::Relative) if (box.computed_values().position() != CSS::Position::Relative)
return; return;
auto resolve_two_opposing_insets = [&](CSS::LengthPercentage const& computed_start, CSS::LengthPercentage const& computed_end, float& used_start, float& used_end, float reference_for_percentage) { auto resolve_two_opposing_insets = [&](CSS::LengthPercentage const& computed_start, CSS::LengthPercentage const& computed_end, float& used_start, float& used_end, CSSPixels reference_for_percentage) {
auto resolved_first = computed_start.resolved(box, CSS::Length::make_px(reference_for_percentage)).resolved(box); auto resolved_first = computed_start.resolved(box, CSS::Length::make_px(reference_for_percentage)).resolved(box);
auto resolved_second = computed_end.resolved(box, CSS::Length::make_px(reference_for_percentage)).resolved(box); auto resolved_second = computed_end.resolved(box, CSS::Length::make_px(reference_for_percentage)).resolved(box);
@ -1014,7 +1014,7 @@ void FormattingContext::compute_inset(Box const& box)
} }
// https://drafts.csswg.org/css-sizing-3/#fit-content-size // https://drafts.csswg.org/css-sizing-3/#fit-content-size
float FormattingContext::calculate_fit_content_width(Layout::Box const& box, AvailableSpace const& available_space) const CSSPixels FormattingContext::calculate_fit_content_width(Layout::Box const& box, AvailableSpace const& available_space) const
{ {
// If the available space in a given axis is definite, // If the available space in a given axis is definite,
// equal to clamp(min-content size, stretch-fit size, max-content size) // equal to clamp(min-content size, stretch-fit size, max-content size)
@ -1034,7 +1034,7 @@ float FormattingContext::calculate_fit_content_width(Layout::Box const& box, Ava
} }
// https://drafts.csswg.org/css-sizing-3/#fit-content-size // https://drafts.csswg.org/css-sizing-3/#fit-content-size
float FormattingContext::calculate_fit_content_height(Layout::Box const& box, AvailableSpace const& available_space) const CSSPixels FormattingContext::calculate_fit_content_height(Layout::Box const& box, AvailableSpace const& available_space) const
{ {
// If the available space in a given axis is definite, // If the available space in a given axis is definite,
// equal to clamp(min-content size, stretch-fit size, max-content size) // equal to clamp(min-content size, stretch-fit size, max-content size)
@ -1053,7 +1053,7 @@ float FormattingContext::calculate_fit_content_height(Layout::Box const& box, Av
return calculate_max_content_height(box, available_space.width); return calculate_max_content_height(box, available_space.width);
} }
float FormattingContext::calculate_min_content_width(Layout::Box const& box) const CSSPixels FormattingContext::calculate_min_content_width(Layout::Box const& box) const
{ {
if (box.has_intrinsic_width()) if (box.has_intrinsic_width())
return *box.intrinsic_width(); return *box.intrinsic_width();
@ -1079,7 +1079,7 @@ float FormattingContext::calculate_min_content_width(Layout::Box const& box) con
if (context->type() == FormattingContext::Type::Flex) { if (context->type() == FormattingContext::Type::Flex) {
cache.min_content_width = box_state.content_width(); cache.min_content_width = box_state.content_width();
} else { } else {
cache.min_content_width = context->greatest_child_width(box); cache.min_content_width = context->greatest_child_width(box).value();
} }
if (!isfinite(*cache.min_content_width)) { if (!isfinite(*cache.min_content_width)) {
@ -1091,7 +1091,7 @@ float FormattingContext::calculate_min_content_width(Layout::Box const& box) con
return *cache.min_content_width; return *cache.min_content_width;
} }
float FormattingContext::calculate_max_content_width(Layout::Box const& box) const CSSPixels FormattingContext::calculate_max_content_width(Layout::Box const& box) const
{ {
if (box.has_intrinsic_width()) if (box.has_intrinsic_width())
return *box.intrinsic_width(); return *box.intrinsic_width();
@ -1117,7 +1117,7 @@ float FormattingContext::calculate_max_content_width(Layout::Box const& box) con
if (context->type() == FormattingContext::Type::Flex) { if (context->type() == FormattingContext::Type::Flex) {
cache.max_content_width = box_state.content_width(); cache.max_content_width = box_state.content_width();
} else { } else {
cache.max_content_width = context->greatest_child_width(box); cache.max_content_width = context->greatest_child_width(box).value();
} }
if (!isfinite(*cache.max_content_width)) { if (!isfinite(*cache.max_content_width)) {
@ -1129,7 +1129,7 @@ float FormattingContext::calculate_max_content_width(Layout::Box const& box) con
return *cache.max_content_width; return *cache.max_content_width;
} }
float FormattingContext::calculate_min_content_height(Layout::Box const& box, AvailableSize const& available_width) const CSSPixels FormattingContext::calculate_min_content_height(Layout::Box const& box, AvailableSize const& available_width) const
{ {
if (box.has_intrinsic_height()) if (box.has_intrinsic_height())
return *box.intrinsic_height(); return *box.intrinsic_height();
@ -1140,7 +1140,7 @@ float FormattingContext::calculate_min_content_height(Layout::Box const& box, Av
auto& root_state = m_state.m_root; auto& root_state = m_state.m_root;
auto& cache = *root_state.intrinsic_sizes.ensure(&box, [] { return adopt_own(*new LayoutState::IntrinsicSizes); }); auto& cache = *root_state.intrinsic_sizes.ensure(&box, [] { return adopt_own(*new LayoutState::IntrinsicSizes); });
if (available_width.is_definite()) { if (available_width.is_definite()) {
cache_slot = &cache.min_content_height_with_definite_available_width.ensure(available_width.to_px()); cache_slot = &cache.min_content_height_with_definite_available_width.ensure(available_width.to_px().value());
} else if (available_width.is_min_content()) { } else if (available_width.is_min_content()) {
cache_slot = &cache.min_content_height_with_min_content_available_width; cache_slot = &cache.min_content_height_with_min_content_available_width;
} else if (available_width.is_max_content()) { } else if (available_width.is_max_content()) {
@ -1162,19 +1162,19 @@ float FormattingContext::calculate_min_content_height(Layout::Box const& box, Av
context->run(box, LayoutMode::IntrinsicSizing, AvailableSpace(available_width, AvailableSize::make_min_content())); context->run(box, LayoutMode::IntrinsicSizing, AvailableSpace(available_width, AvailableSize::make_min_content()));
auto min_content_height = context->automatic_content_height(); auto min_content_height = context->automatic_content_height();
if (!isfinite(min_content_height)) { if (!isfinite(min_content_height.value())) {
// HACK: If layout calculates a non-finite result, something went wrong. Force it to zero and log a little whine. // HACK: If layout calculates a non-finite result, something went wrong. Force it to zero and log a little whine.
dbgln("FIXME: Calculated non-finite min-content height for {}", box.debug_description()); dbgln("FIXME: Calculated non-finite min-content height for {}", box.debug_description());
min_content_height = 0; min_content_height = 0;
} }
if (cache_slot) { if (cache_slot) {
*cache_slot = min_content_height; *cache_slot = min_content_height.value();
} }
return min_content_height; return min_content_height;
} }
float FormattingContext::calculate_max_content_height(Layout::Box const& box, AvailableSize const& available_width) const CSSPixels FormattingContext::calculate_max_content_height(Layout::Box const& box, AvailableSize const& available_width) const
{ {
if (box.has_intrinsic_height()) if (box.has_intrinsic_height())
return *box.intrinsic_height(); return *box.intrinsic_height();
@ -1185,7 +1185,7 @@ float FormattingContext::calculate_max_content_height(Layout::Box const& box, Av
auto& root_state = m_state.m_root; auto& root_state = m_state.m_root;
auto& cache = *root_state.intrinsic_sizes.ensure(&box, [] { return adopt_own(*new LayoutState::IntrinsicSizes); }); auto& cache = *root_state.intrinsic_sizes.ensure(&box, [] { return adopt_own(*new LayoutState::IntrinsicSizes); });
if (available_width.is_definite()) { if (available_width.is_definite()) {
cache_slot = &cache.max_content_height_with_definite_available_width.ensure(available_width.to_px()); cache_slot = &cache.max_content_height_with_definite_available_width.ensure(available_width.to_px().value());
} else if (available_width.is_min_content()) { } else if (available_width.is_min_content()) {
cache_slot = &cache.max_content_height_with_min_content_available_width; cache_slot = &cache.max_content_height_with_min_content_available_width;
} else if (available_width.is_max_content()) { } else if (available_width.is_max_content()) {
@ -1208,14 +1208,14 @@ float FormattingContext::calculate_max_content_height(Layout::Box const& box, Av
auto max_content_height = context->automatic_content_height(); auto max_content_height = context->automatic_content_height();
if (!isfinite(max_content_height)) { if (!isfinite(max_content_height.value())) {
// HACK: If layout calculates a non-finite result, something went wrong. Force it to zero and log a little whine. // HACK: If layout calculates a non-finite result, something went wrong. Force it to zero and log a little whine.
dbgln("FIXME: Calculated non-finite max-content height for {}", box.debug_description()); dbgln("FIXME: Calculated non-finite max-content height for {}", box.debug_description());
max_content_height = 0; max_content_height = 0;
} }
if (cache_slot) { if (cache_slot) {
*cache_slot = max_content_height; *cache_slot = max_content_height.value();
} }
return max_content_height; return max_content_height;
@ -1223,7 +1223,7 @@ float FormattingContext::calculate_max_content_height(Layout::Box const& box, Av
CSS::Length FormattingContext::calculate_inner_width(Layout::Box const& box, AvailableSize const& available_width, CSS::Size const& width) const CSS::Length FormattingContext::calculate_inner_width(Layout::Box const& box, AvailableSize const& available_width, CSS::Size const& width) const
{ {
float width_of_containing_block = available_width.to_px(); auto width_of_containing_block = available_width.to_px();
auto width_of_containing_block_as_length_for_resolve = CSS::Length::make_px(width_of_containing_block); auto width_of_containing_block_as_length_for_resolve = CSS::Length::make_px(width_of_containing_block);
if (width.is_auto()) { if (width.is_auto()) {
return width.resolved(box, width_of_containing_block_as_length_for_resolve).resolved(box); return width.resolved(box, width_of_containing_block_as_length_for_resolve).resolved(box);
@ -1237,7 +1237,7 @@ CSS::Length FormattingContext::calculate_inner_width(Layout::Box const& box, Ava
auto const padding_left = computed_values.padding().left().resolved(box, width_of_containing_block_as_length_for_resolve).resolved(box); auto const padding_left = computed_values.padding().left().resolved(box, width_of_containing_block_as_length_for_resolve).resolved(box);
auto const padding_right = computed_values.padding().right().resolved(box, width_of_containing_block_as_length_for_resolve).resolved(box); auto const padding_right = computed_values.padding().right().resolved(box, width_of_containing_block_as_length_for_resolve).resolved(box);
float inner_width = width.resolved(box, width_of_containing_block_as_length_for_resolve).resolved(box).to_px(box) auto inner_width = width.resolved(box, width_of_containing_block_as_length_for_resolve).resolved(box).to_px(box)
- computed_values.border_left().width - computed_values.border_left().width
- padding_left.to_px(box) - padding_left.to_px(box)
- computed_values.border_right().width - computed_values.border_right().width
@ -1250,7 +1250,7 @@ CSS::Length FormattingContext::calculate_inner_width(Layout::Box const& box, Ava
CSS::Length FormattingContext::calculate_inner_height(Layout::Box const& box, AvailableSize const& available_height, CSS::Size const& height) const CSS::Length FormattingContext::calculate_inner_height(Layout::Box const& box, AvailableSize const& available_height, CSS::Size const& height) const
{ {
float height_of_containing_block = available_height.to_px(); auto height_of_containing_block = available_height.to_px();
auto height_of_containing_block_as_length_for_resolve = CSS::Length::make_px(height_of_containing_block); auto height_of_containing_block_as_length_for_resolve = CSS::Length::make_px(height_of_containing_block);
if (height.is_auto()) { if (height.is_auto()) {
return height.resolved(box, height_of_containing_block_as_length_for_resolve).resolved(box); return height.resolved(box, height_of_containing_block_as_length_for_resolve).resolved(box);
@ -1264,7 +1264,7 @@ CSS::Length FormattingContext::calculate_inner_height(Layout::Box const& box, Av
auto const padding_top = computed_values.padding().top().resolved(box, height_of_containing_block_as_length_for_resolve).resolved(box); auto const padding_top = computed_values.padding().top().resolved(box, height_of_containing_block_as_length_for_resolve).resolved(box);
auto const padding_bottom = computed_values.padding().bottom().resolved(box, height_of_containing_block_as_length_for_resolve).resolved(box); auto const padding_bottom = computed_values.padding().bottom().resolved(box, height_of_containing_block_as_length_for_resolve).resolved(box);
float inner_height = height.resolved(box, height_of_containing_block_as_length_for_resolve).resolved(box).to_px(box) auto inner_height = height.resolved(box, height_of_containing_block_as_length_for_resolve).resolved(box).to_px(box)
- computed_values.border_top().width - computed_values.border_top().width
- padding_top.to_px(box) - padding_top.to_px(box)
- computed_values.border_bottom().width - computed_values.border_bottom().width
@ -1275,7 +1275,7 @@ CSS::Length FormattingContext::calculate_inner_height(Layout::Box const& box, Av
return height.resolved(box, height_of_containing_block_as_length_for_resolve).resolved(box); return height.resolved(box, height_of_containing_block_as_length_for_resolve).resolved(box);
} }
float FormattingContext::containing_block_width_for(Box const& box, LayoutState const& state) CSSPixels FormattingContext::containing_block_width_for(Box const& box, LayoutState const& state)
{ {
auto& containing_block_state = state.get(*box.containing_block()); auto& containing_block_state = state.get(*box.containing_block());
auto& box_state = state.get(box); auto& box_state = state.get(box);
@ -1291,7 +1291,7 @@ float FormattingContext::containing_block_width_for(Box const& box, LayoutState
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
} }
float FormattingContext::containing_block_height_for(Box const& box, LayoutState const& state) CSSPixels FormattingContext::containing_block_height_for(Box const& box, LayoutState const& state)
{ {
auto& containing_block_state = state.get(*box.containing_block()); auto& containing_block_state = state.get(*box.containing_block());
auto& box_state = state.get(box); auto& box_state = state.get(box);
@ -1308,7 +1308,7 @@ float FormattingContext::containing_block_height_for(Box const& box, LayoutState
} }
// https://drafts.csswg.org/css-sizing-3/#stretch-fit-size // https://drafts.csswg.org/css-sizing-3/#stretch-fit-size
float FormattingContext::calculate_stretch_fit_width(Box const& box, AvailableSize const& available_width) const CSSPixels FormattingContext::calculate_stretch_fit_width(Box const& box, AvailableSize const& available_width) const
{ {
// The size a box would take if its outer size filled the available space in the given axis; // The size a box would take if its outer size filled the available space in the given axis;
// in other words, the stretch fit into the available space, if that is definite. // in other words, the stretch fit into the available space, if that is definite.
@ -1324,7 +1324,7 @@ float FormattingContext::calculate_stretch_fit_width(Box const& box, AvailableSi
} }
// https://drafts.csswg.org/css-sizing-3/#stretch-fit-size // https://drafts.csswg.org/css-sizing-3/#stretch-fit-size
float FormattingContext::calculate_stretch_fit_height(Box const& box, AvailableSize const& available_height) const CSSPixels FormattingContext::calculate_stretch_fit_height(Box const& box, AvailableSize const& available_height) const
{ {
// The size a box would take if its outer size filled the available space in the given axis; // The size a box would take if its outer size filled the available space in the given axis;
// in other words, the stretch fit into the available space, if that is definite. // in other words, the stretch fit into the available space, if that is definite.

52
Userland/Libraries/LibWeb/Layout/FormattingContext.h
View file

@ -28,10 +28,10 @@ public:
virtual void run(Box const&, LayoutMode, AvailableSpace const&) = 0; virtual void run(Box const&, LayoutMode, AvailableSpace const&) = 0;
// This function returns the automatic content height of the context's root box. // This function returns the automatic content height of the context's root box.
virtual float automatic_content_width() const { return 0; } virtual CSSPixels automatic_content_width() const { return 0; }
// This function returns the automatic content height of the context's root box. // This function returns the automatic content height of the context's root box.
virtual float automatic_content_height() const = 0; virtual CSSPixels automatic_content_height() const = 0;
Box const& context_box() const { return m_context_box; } Box const& context_box() const { return m_context_box; }
@ -45,40 +45,40 @@ public:
static bool creates_block_formatting_context(Box const&); static bool creates_block_formatting_context(Box const&);
static float compute_width_for_replaced_element(LayoutState const&, ReplacedBox const&, AvailableSpace const&); static CSSPixels compute_width_for_replaced_element(LayoutState const&, ReplacedBox const&, AvailableSpace const&);
static float compute_height_for_replaced_element(LayoutState const&, ReplacedBox const&, AvailableSpace const&); static CSSPixels compute_height_for_replaced_element(LayoutState const&, ReplacedBox const&, AvailableSpace const&);
OwnPtr<FormattingContext> create_independent_formatting_context_if_needed(LayoutState&, Box const& child_box); OwnPtr<FormattingContext> create_independent_formatting_context_if_needed(LayoutState&, Box const& child_box);
virtual void parent_context_did_dimension_child_root_box() { } virtual void parent_context_did_dimension_child_root_box() { }
float calculate_min_content_width(Layout::Box const&) const; CSSPixels calculate_min_content_width(Layout::Box const&) const;
float calculate_max_content_width(Layout::Box const&) const; CSSPixels calculate_max_content_width(Layout::Box const&) const;
float calculate_min_content_height(Layout::Box const&, AvailableSize const& available_width) const; CSSPixels calculate_min_content_height(Layout::Box const&, AvailableSize const& available_width) const;
float calculate_max_content_height(Layout::Box const&, AvailableSize const& available_width) const; CSSPixels calculate_max_content_height(Layout::Box const&, AvailableSize const& available_width) const;
float calculate_fit_content_height(Layout::Box const&, AvailableSpace const&) const; CSSPixels calculate_fit_content_height(Layout::Box const&, AvailableSpace const&) const;
float calculate_fit_content_width(Layout::Box const&, AvailableSpace const&) const; CSSPixels calculate_fit_content_width(Layout::Box const&, AvailableSpace const&) const;
CSS::Length calculate_inner_width(Layout::Box const&, AvailableSize const&, CSS::Size const& width) const; CSS::Length calculate_inner_width(Layout::Box const&, AvailableSize const&, CSS::Size const& width) const;
CSS::Length calculate_inner_height(Layout::Box const&, AvailableSize const&, CSS::Size const& height) const; CSS::Length calculate_inner_height(Layout::Box const&, AvailableSize const&, CSS::Size const& height) const;
virtual float greatest_child_width(Box const&); virtual CSSPixels greatest_child_width(Box const&);
float containing_block_width_for(Box const& box) const { return containing_block_width_for(box, m_state); } CSSPixels containing_block_width_for(Box const& box) const { return containing_block_width_for(box, m_state); }
float containing_block_height_for(Box const& box) const { return containing_block_height_for(box, m_state); } CSSPixels containing_block_height_for(Box const& box) const { return containing_block_height_for(box, m_state); }
static float containing_block_width_for(Box const&, LayoutState const&); static CSSPixels containing_block_width_for(Box const&, LayoutState const&);
static float containing_block_height_for(Box const&, LayoutState const&); static CSSPixels containing_block_height_for(Box const&, LayoutState const&);
[[nodiscard]] float calculate_stretch_fit_width(Box const&, AvailableSize const&) const; [[nodiscard]] CSSPixels calculate_stretch_fit_width(Box const&, AvailableSize const&) const;
[[nodiscard]] float calculate_stretch_fit_height(Box const&, AvailableSize const&) const; [[nodiscard]] CSSPixels calculate_stretch_fit_height(Box const&, AvailableSize const&) const;
virtual bool can_determine_size_of_child() const { return false; } virtual bool can_determine_size_of_child() const { return false; }
virtual void determine_width_of_child(Box const&, AvailableSpace const&) { } virtual void determine_width_of_child(Box const&, AvailableSpace const&) { }
virtual void determine_height_of_child(Box const&, AvailableSpace const&) { } virtual void determine_height_of_child(Box const&, AvailableSpace const&) { }
virtual Gfx::FloatPoint calculate_static_position(Box const&) const; virtual CSSPixelPoint calculate_static_position(Box const&) const;
bool can_skip_is_anonymous_text_run(Box&); bool can_skip_is_anonymous_text_run(Box&);
protected: protected:
@ -87,24 +87,22 @@ protected:
static bool should_treat_width_as_auto(Box const&, AvailableSpace const&); static bool should_treat_width_as_auto(Box const&, AvailableSpace const&);
static bool should_treat_height_as_auto(Box const&, AvailableSpace const&); static bool should_treat_height_as_auto(Box const&, AvailableSpace const&);
float calculate_fit_content_size(float min_content_size, float max_content_size, AvailableSize const&) const;
OwnPtr<FormattingContext> layout_inside(Box const&, LayoutMode, AvailableSpace const&); OwnPtr<FormattingContext> layout_inside(Box const&, LayoutMode, AvailableSpace const&);
void compute_inset(Box const& box); void compute_inset(Box const& box);
struct SpaceUsedByFloats { struct SpaceUsedByFloats {
float left { 0 }; CSSPixels left { 0 };
float right { 0 }; CSSPixels right { 0 };
}; };
struct ShrinkToFitResult { struct ShrinkToFitResult {
float preferred_width { 0 }; CSSPixels preferred_width { 0 };
float preferred_minimum_width { 0 }; CSSPixels preferred_minimum_width { 0 };
}; };
static float tentative_width_for_replaced_element(LayoutState const&, ReplacedBox const&, CSS::Size const& computed_width, AvailableSpace const&); static CSSPixels tentative_width_for_replaced_element(LayoutState const&, ReplacedBox const&, CSS::Size const& computed_width, AvailableSpace const&);
static float tentative_height_for_replaced_element(LayoutState const&, ReplacedBox const&, CSS::Size const& computed_height, AvailableSpace const&); static CSSPixels tentative_height_for_replaced_element(LayoutState const&, ReplacedBox const&, CSS::Size const& computed_height, AvailableSpace const&);
float compute_auto_height_for_block_formatting_context_root(BlockContainer const&) const; CSSPixels compute_auto_height_for_block_formatting_context_root(BlockContainer const&) const;
ShrinkToFitResult calculate_shrink_to_fit_widths(Box const&); ShrinkToFitResult calculate_shrink_to_fit_widths(Box const&);

22
Userland/Libraries/LibWeb/Layout/GridFormattingContext.cpp
View file

@ -27,7 +27,7 @@ float GridFormattingContext::resolve_definite_track_size(CSS::GridSize const& gr
return grid_size.length().to_px(box); return grid_size.length().to_px(box);
case CSS::GridSize::Type::Percentage: case CSS::GridSize::Type::Percentage:
if (available_space.width.is_definite()) if (available_space.width.is_definite())
return grid_size.percentage().as_fraction() * available_space.width.to_px(); return grid_size.percentage().as_fraction() * available_space.width.to_px().value();
break; break;
default: default:
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
@ -72,7 +72,7 @@ float GridFormattingContext::resolve_size(CSS::Size const& size, AvailableSize c
if (size.is_percentage()) { if (size.is_percentage()) {
if (!available_size.is_definite()) if (!available_size.is_definite())
return 0; return 0;
return available_size.to_px() * size.percentage().as_fraction(); return available_size.to_px().value() * size.percentage().as_fraction();
} }
return 0; return 0;
} }
@ -680,7 +680,7 @@ void GridFormattingContext::calculate_sizes_of_columns(Box const& box, Available
break; break;
case CSS::GridSize::Type::Percentage: case CSS::GridSize::Type::Percentage:
if (available_space.width.is_definite()) if (available_space.width.is_definite())
grid_column.base_size = grid_column.min_track_sizing_function.percentage().as_fraction() * available_space.width.to_px(); grid_column.base_size = grid_column.min_track_sizing_function.percentage().as_fraction() * available_space.width.to_px().value();
break; break;
// - An intrinsic sizing function // - An intrinsic sizing function
// Use an initial base size of zero. // Use an initial base size of zero.
@ -704,7 +704,7 @@ void GridFormattingContext::calculate_sizes_of_columns(Box const& box, Available
break; break;
case CSS::GridSize::Type::Percentage: case CSS::GridSize::Type::Percentage:
if (available_space.width.is_definite()) if (available_space.width.is_definite())
grid_column.growth_limit = grid_column.max_track_sizing_function.percentage().as_fraction() * available_space.width.to_px(); grid_column.growth_limit = grid_column.max_track_sizing_function.percentage().as_fraction() * available_space.width.to_px().value();
break; break;
// - A flexible sizing function // - A flexible sizing function
// Use an initial growth limit of infinity. // Use an initial growth limit of infinity.
@ -783,7 +783,7 @@ void GridFormattingContext::calculate_sizes_of_columns(Box const& box, Available
// the size of the item’s content, it is considered a type of intrinsic size contribution. // the size of the item’s content, it is considered a type of intrinsic size contribution.
float grid_column_width = 0; float grid_column_width = 0;
for (auto& box_of_column : boxes_of_column) for (auto& box_of_column : boxes_of_column)
grid_column_width = max(grid_column_width, calculate_min_content_width(box_of_column)); grid_column_width = max(grid_column_width, calculate_min_content_width(box_of_column).value());
grid_column.base_size = grid_column_width; grid_column.base_size = grid_column_width;
// - For min-content maximums: // - For min-content maximums:
@ -912,7 +912,7 @@ void GridFormattingContext::calculate_sizes_of_columns(Box const& box, Available
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(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() - sum_of_track_sizes : 0; auto remaining_free_space = available_space.width.is_definite() ? available_space.width.to_px().value() - sum_of_track_sizes : 0;
// 2.2. Distribute space up to limits: Find the item-incurred increase for each spanned track with an // 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 // 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 // item-incurred increase as its affected size + item-incurred increase reaches its limit (and
@ -1030,7 +1030,7 @@ void GridFormattingContext::calculate_sizes_of_columns(Box const& box, Available
sized_column_widths += grid_column.base_size; 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. // 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() - sized_column_widths : 0; double free_horizontal_space = available_space.width.is_definite() ? available_space.width.to_px().value() - sized_column_widths : 0;
// If the free space is zero or if sizing the grid container under a min-content constraint: // If the free space is zero or if sizing the grid container under a min-content constraint:
// The used flex fraction is zero. // The used flex fraction is zero.
@ -1103,7 +1103,7 @@ void GridFormattingContext::calculate_sizes_of_columns(Box const& box, Available
used_horizontal_space += grid_column.base_size; used_horizontal_space += grid_column.base_size;
} }
float remaining_horizontal_space = available_space.width.is_definite() ? available_space.width.to_px() - used_horizontal_space : 0; float remaining_horizontal_space = available_space.width.is_definite() ? available_space.width.to_px().value() - used_horizontal_space : 0;
auto count_of_auto_max_column_tracks = 0; auto count_of_auto_max_column_tracks = 0;
for (auto& grid_column : m_grid_columns) { 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()) if (grid_column.max_track_sizing_function.is_length() && grid_column.max_track_sizing_function.length().is_auto())
@ -1241,7 +1241,7 @@ void GridFormattingContext::calculate_sizes_of_rows(Box const& box)
// the size of the item’s content, it is considered a type of intrinsic size contribution. // the size of the item’s content, it is considered a type of intrinsic size contribution.
float grid_row_height = 0; float grid_row_height = 0;
for (auto& positioned_box : positioned_boxes_of_row) 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))); 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.base_size = grid_row_height; grid_row.base_size = grid_row_height;
// - For min-content maximums: // - For min-content maximums:
@ -1770,7 +1770,7 @@ void GridFormattingContext::run(Box const& box, LayoutMode, AvailableSpace const
m_automatic_content_height = total_y; m_automatic_content_height = total_y;
} }
float GridFormattingContext::automatic_content_height() const CSSPixels GridFormattingContext::automatic_content_height() const
{ {
return m_automatic_content_height; return m_automatic_content_height;
} }
@ -1802,7 +1802,7 @@ float GridFormattingContext::get_free_space_x(AvailableSpace const& available_sp
auto sum_base_sizes = 0; auto sum_base_sizes = 0;
for (auto& grid_column : m_grid_columns) for (auto& grid_column : m_grid_columns)
sum_base_sizes += grid_column.base_size; sum_base_sizes += grid_column.base_size;
return max(0, available_space.width.to_px() - sum_base_sizes); return max(0, available_space.width.to_px().value() - sum_base_sizes);
} }
float GridFormattingContext::get_free_space_y(Box const& box) float GridFormattingContext::get_free_space_y(Box const& box)

2
Userland/Libraries/LibWeb/Layout/GridFormattingContext.h
View file

@ -37,7 +37,7 @@ public:
~GridFormattingContext(); ~GridFormattingContext();
virtual void run(Box const&, LayoutMode, AvailableSpace const& available_space) override; virtual void run(Box const&, LayoutMode, AvailableSpace const& available_space) override;
virtual float automatic_content_height() const override; virtual CSSPixels automatic_content_height() const override;
private: private:
float m_automatic_content_height { 0 }; float m_automatic_content_height { 0 };

18
Userland/Libraries/LibWeb/Layout/InlineFormattingContext.cpp
View file

@ -44,7 +44,7 @@ float InlineFormattingContext::leftmost_x_offset_at(float y) const
auto box_in_root_rect = content_box_rect_in_ancestor_coordinate_space(containing_block(), parent().root(), m_state); auto box_in_root_rect = content_box_rect_in_ancestor_coordinate_space(containing_block(), parent().root(), m_state);
float y_in_root = box_in_root_rect.y() + y; float y_in_root = box_in_root_rect.y() + y;
auto space = parent().space_used_by_floats(y_in_root); auto space = parent().space_used_by_floats(y_in_root);
return space.left; return space.left.value();
} }
float InlineFormattingContext::available_space_for_line(float y) const float InlineFormattingContext::available_space_for_line(float y) const
@ -58,15 +58,15 @@ float InlineFormattingContext::available_space_for_line(float y) const
space.left = space.left; space.left = space.left;
space.right = min(m_available_space->width.to_px() - space.right, m_available_space->width.to_px()); space.right = min(m_available_space->width.to_px() - space.right, m_available_space->width.to_px());
return space.right - space.left; return (space.right - space.left).value();
} }
float InlineFormattingContext::automatic_content_width() const CSSPixels InlineFormattingContext::automatic_content_width() const
{ {
return m_automatic_content_width; return m_automatic_content_width;
} }
float InlineFormattingContext::automatic_content_height() const CSSPixels InlineFormattingContext::automatic_content_height() const
{ {
return m_automatic_content_height; return m_automatic_content_height;
} }
@ -117,8 +117,8 @@ void InlineFormattingContext::dimension_box_on_line(Box const& box, LayoutMode l
if (is<SVGSVGBox>(box)) if (is<SVGSVGBox>(box))
(void)layout_inside(replaced, layout_mode, *m_available_space); (void)layout_inside(replaced, layout_mode, *m_available_space);
box_state.set_content_width(compute_width_for_replaced_element(m_state, replaced, *m_available_space)); box_state.set_content_width(compute_width_for_replaced_element(m_state, replaced, *m_available_space).value());
box_state.set_content_height(compute_height_for_replaced_element(m_state, replaced, *m_available_space)); box_state.set_content_height(compute_height_for_replaced_element(m_state, replaced, *m_available_space).value());
return; return;
} }
@ -138,7 +138,7 @@ void InlineFormattingContext::dimension_box_on_line(Box const& box, LayoutMode l
- box_state.border_right - box_state.border_right
- box_state.margin_right; - box_state.margin_right;
unconstrained_width = min(max(result.preferred_minimum_width, available_width), result.preferred_width); unconstrained_width = min(max(result.preferred_minimum_width, available_width), result.preferred_width).value();
} else { } else {
if (width_value.contains_percentage() && !m_available_space->width.is_definite()) { if (width_value.contains_percentage() && !m_available_space->width.is_definite()) {
// NOTE: We can't resolve percentages yet. We'll have to wait until after inner layout. // NOTE: We can't resolve percentages yet. We'll have to wait until after inner layout.
@ -190,11 +190,11 @@ void InlineFormattingContext::apply_justification_to_fragments(CSS::TextJustify
break; break;
} }
float excess_horizontal_space = m_available_space->width.to_px() - line_box.width(); float excess_horizontal_space = m_available_space->width.to_px().value() - line_box.width();
// Only justify the text if the excess horizontal space is less than or // Only justify the text if the excess horizontal space is less than or
// equal to 10%, or if we are not looking at the last line box. // equal to 10%, or if we are not looking at the last line box.
if (is_last_line && excess_horizontal_space / m_available_space->width.to_px() > text_justification_threshold) if (is_last_line && excess_horizontal_space / m_available_space->width.to_px().value() > text_justification_threshold)
return; return;
float excess_horizontal_space_including_whitespace = excess_horizontal_space; float excess_horizontal_space_including_whitespace = excess_horizontal_space;

4
Userland/Libraries/LibWeb/Layout/InlineFormattingContext.h
View file

@ -24,8 +24,8 @@ public:
BlockContainer const& containing_block() const { return static_cast<BlockContainer const&>(context_box()); } BlockContainer const& containing_block() const { return static_cast<BlockContainer const&>(context_box()); }
virtual void run(Box const&, LayoutMode, AvailableSpace const&) override; virtual void run(Box const&, LayoutMode, AvailableSpace const&) override;
virtual float automatic_content_height() const override; virtual CSSPixels automatic_content_height() const override;
virtual float automatic_content_width() const override; virtual CSSPixels automatic_content_width() const override;
void dimension_box_on_line(Box const&, LayoutMode); void dimension_box_on_line(Box const&, LayoutMode);

2
Userland/Libraries/LibWeb/Layout/SVGFormattingContext.cpp
View file

@ -21,7 +21,7 @@ SVGFormattingContext::SVGFormattingContext(LayoutState& state, Box const& box, F
SVGFormattingContext::~SVGFormattingContext() = default; SVGFormattingContext::~SVGFormattingContext() = default;
float SVGFormattingContext::automatic_content_height() const CSSPixels SVGFormattingContext::automatic_content_height() const
{ {
return 0; return 0;
} }

2
Userland/Libraries/LibWeb/Layout/SVGFormattingContext.h
View file

@ -17,7 +17,7 @@ public:
~SVGFormattingContext(); ~SVGFormattingContext();
virtual void run(Box const&, LayoutMode, AvailableSpace const&) override; virtual void run(Box const&, LayoutMode, AvailableSpace const&) override;
virtual float automatic_content_height() const override; virtual CSSPixels automatic_content_height() const override;
}; };
} }

8
Userland/Libraries/LibWeb/Layout/TableFormattingContext.cpp
View file

@ -121,11 +121,11 @@ void TableFormattingContext::compute_table_measures()
auto min_content_width = calculate_min_content_width(cell.box); auto min_content_width = calculate_min_content_width(cell.box);
auto max_content_width = calculate_max_content_width(cell.box); auto max_content_width = calculate_max_content_width(cell.box);
float min_width = min_content_width; float min_width = min_content_width.value();
if (!computed_values.min_width().is_auto()) if (!computed_values.min_width().is_auto())
min_width = max(min_width, computed_values.min_width().resolved(cell.box, width_of_containing_block_as_length).to_px(cell.box)); min_width = max(min_width, computed_values.min_width().resolved(cell.box, width_of_containing_block_as_length).to_px(cell.box));
float max_width = computed_values.width().is_auto() ? max_content_width : width; float max_width = computed_values.width().is_auto() ? max_content_width.value() : width;
if (!computed_values.max_width().is_none()) if (!computed_values.max_width().is_none())
max_width = min(max_width, computed_values.max_width().resolved(cell.box, width_of_containing_block_as_length).to_px(cell.box)); max_width = min(max_width, computed_values.max_width().resolved(cell.box, width_of_containing_block_as_length).to_px(cell.box));
@ -281,7 +281,7 @@ void TableFormattingContext::run(Box const& box, LayoutMode, AvailableSpace cons
cell_state.set_content_width(span_width - cell_state.border_box_left() - cell_state.border_box_right()); cell_state.set_content_width(span_width - cell_state.border_box_left() - cell_state.border_box_right());
auto independent_formatting_context = layout_inside(cell.box, LayoutMode::Normal, cell_state.available_inner_space_or_constraints_from(available_space)); auto independent_formatting_context = layout_inside(cell.box, LayoutMode::Normal, cell_state.available_inner_space_or_constraints_from(available_space));
VERIFY(independent_formatting_context); VERIFY(independent_formatting_context);
cell_state.set_content_height(independent_formatting_context->automatic_content_height()); cell_state.set_content_height(independent_formatting_context->automatic_content_height().value());
independent_formatting_context->parent_context_did_dimension_child_root_box(); independent_formatting_context->parent_context_did_dimension_child_root_box();
cell.baseline = box_baseline(m_state, cell.box); cell.baseline = box_baseline(m_state, cell.box);
@ -364,7 +364,7 @@ void TableFormattingContext::run(Box const& box, LayoutMode, AvailableSpace cons
m_automatic_content_height = total_content_height; m_automatic_content_height = total_content_height;
} }
float TableFormattingContext::automatic_content_height() const CSSPixels TableFormattingContext::automatic_content_height() const
{ {
return m_automatic_content_height; return m_automatic_content_height;
} }

2
Userland/Libraries/LibWeb/Layout/TableFormattingContext.h
View file

@ -17,7 +17,7 @@ public:
~TableFormattingContext(); ~TableFormattingContext();
virtual void run(Box const&, LayoutMode, AvailableSpace const&) override; virtual void run(Box const&, LayoutMode, AvailableSpace const&) override;
virtual float automatic_content_height() const override; virtual CSSPixels automatic_content_height() const override;
private: private:
void calculate_row_column_grid(Box const&); void calculate_row_column_grid(Box const&);