From ed8930fff593e4452c559e682b563a36a2750b5d Mon Sep 17 00:00:00 2001 From: Andreas Kling Date: Sun, 17 Jul 2022 17:59:02 +0200 Subject: [PATCH] LibWeb: Add accessors for UsedValues::computed_{width,height} This is preparation for doing some more work when assigning to these values. --- Userland/Libraries/LibWeb/DOM/Document.cpp | 4 +- .../LibWeb/Layout/BlockFormattingContext.cpp | 64 +++++++++---------- .../LibWeb/Layout/FlexFormattingContext.cpp | 52 +++++++-------- .../LibWeb/Layout/FormattingContext.cpp | 58 ++++++++--------- .../LibWeb/Layout/InlineFormattingContext.cpp | 18 +++--- .../LibWeb/Layout/InlineLevelIterator.cpp | 10 +-- .../Libraries/LibWeb/Layout/LayoutState.cpp | 16 ++++- .../Libraries/LibWeb/Layout/LayoutState.h | 20 ++++-- .../Libraries/LibWeb/Layout/LineBuilder.cpp | 6 +- .../LibWeb/Layout/SVGFormattingContext.cpp | 12 ++-- .../LibWeb/Layout/TableFormattingContext.cpp | 32 +++++----- 11 files changed, 155 insertions(+), 137 deletions(-) diff --git a/Userland/Libraries/LibWeb/DOM/Document.cpp b/Userland/Libraries/LibWeb/DOM/Document.cpp index 5eb3722175..b53c5a7605 100644 --- a/Userland/Libraries/LibWeb/DOM/Document.cpp +++ b/Userland/Libraries/LibWeb/DOM/Document.cpp @@ -620,8 +620,8 @@ void Document::update_layout() auto& icb = static_cast(*m_layout_root); auto& icb_state = layout_state.get_mutable(icb); - icb_state.content_width = viewport_rect.width(); - icb_state.content_height = viewport_rect.height(); + icb_state.set_content_width(viewport_rect.width()); + icb_state.set_content_height(viewport_rect.height()); icb.set_has_definite_width(true); icb.set_has_definite_height(true); diff --git a/Userland/Libraries/LibWeb/Layout/BlockFormattingContext.cpp b/Userland/Libraries/LibWeb/Layout/BlockFormattingContext.cpp index 184e266dce..5145357d09 100644 --- a/Userland/Libraries/LibWeb/Layout/BlockFormattingContext.cpp +++ b/Userland/Libraries/LibWeb/Layout/BlockFormattingContext.cpp @@ -222,7 +222,7 @@ void BlockFormattingContext::compute_width(Box const& box, LayoutMode layout_mod auto& box_state = m_state.get_mutable(box); if (!is(box)) - box_state.content_width = used_width.to_px(box); + box_state.set_content_width(used_width.to_px(box)); box_state.margin_left = margin_left.to_px(box); box_state.margin_right = margin_right.to_px(box); @@ -294,7 +294,7 @@ void BlockFormattingContext::compute_width_for_floating_box(Box const& box, Layo } auto& box_state = m_state.get_mutable(box); - box_state.content_width = width.to_px(box); + box_state.set_content_width(width.to_px(box)); box_state.margin_left = margin_left.to_px(box); box_state.margin_right = margin_right.to_px(box); box_state.border_left = computed_values.border_left().width; @@ -305,7 +305,7 @@ void BlockFormattingContext::compute_width_for_floating_box(Box const& box, Layo void BlockFormattingContext::compute_width_for_block_level_replaced_element_in_normal_flow(ReplacedBox const& box) { - m_state.get_mutable(box).content_width = compute_width_for_replaced_element(m_state, box); + m_state.get_mutable(box).set_content_width(compute_width_for_replaced_element(m_state, box)); } float BlockFormattingContext::compute_theoretical_height(LayoutState const& state, Box const& box) @@ -359,7 +359,7 @@ void BlockFormattingContext::compute_height(Box const& box, LayoutState& state) box_state.padding_top = computed_values.padding().top.resolved(box, width_of_containing_block_as_length).to_px(box); box_state.padding_bottom = computed_values.padding().bottom.resolved(box, width_of_containing_block_as_length).to_px(box); - box_state.content_height = compute_theoretical_height(state, box); + box_state.set_content_height(compute_theoretical_height(state, box)); } void BlockFormattingContext::layout_inline_children(BlockContainer const& block_container, LayoutMode layout_mode) @@ -370,9 +370,9 @@ void BlockFormattingContext::layout_inline_children(BlockContainer const& block_ if (layout_mode == LayoutMode::IntrinsicSizeDetermination) { if (block_container.computed_values().width().is_auto() || block_container_state.width_constraint != SizeConstraint::None) - block_container_state.content_width = containing_block_width_for(block_container); + block_container_state.set_content_width(containing_block_width_for(block_container)); if (block_container.computed_values().height().is_auto() || block_container_state.height_constraint != SizeConstraint::None) - block_container_state.content_height = containing_block_height_for(block_container); + block_container_state.set_content_height(containing_block_height_for(block_container)); } InlineFormattingContext context(m_state, block_container, *this); @@ -388,11 +388,11 @@ void BlockFormattingContext::layout_inline_children(BlockContainer const& block_ if (layout_mode == LayoutMode::IntrinsicSizeDetermination) { if (block_container.computed_values().width().is_auto() || block_container_state.width_constraint != SizeConstraint::None) - block_container_state.content_width = max_line_width; + block_container_state.set_content_width(max_line_width); } // FIXME: This is weird. Figure out a way to make callers responsible for setting the content height. - block_container_state.content_height = content_height; + block_container_state.set_content_height(content_height); } void BlockFormattingContext::layout_block_level_box(Box const& box, BlockContainer const& block_container, LayoutMode layout_mode, float& content_height) @@ -410,7 +410,7 @@ void BlockFormattingContext::layout_block_level_box(Box const& box, BlockContain if (box.is_floating()) { layout_floating_box(box, block_container, layout_mode); - content_height = max(content_height, box_state.offset.y() + box_state.content_height + box_state.margin_box_bottom()); + content_height = max(content_height, box_state.offset.y() + box_state.content_height() + box_state.margin_box_bottom()); return; } @@ -446,7 +446,7 @@ void BlockFormattingContext::layout_block_level_box(Box const& box, BlockContain layout_list_item_marker(static_cast(box)); } - content_height = max(content_height, box_state.offset.y() + box_state.content_height + box_state.margin_box_bottom()); + content_height = max(content_height, box_state.offset.y() + box_state.content_height() + box_state.margin_box_bottom()); if (independent_formatting_context) independent_formatting_context->parent_context_did_dimension_child_root_box(); @@ -457,10 +457,10 @@ void BlockFormattingContext::run_intrinsic_size_determination(Box const& box) auto& box_state = m_state.get_mutable(box); if (box.has_definite_width()) - box_state.content_width = box.computed_values().width().resolved(box, CSS::Length::make_px(containing_block_width_for(box))).to_px(box); + box_state.set_content_width(box.computed_values().width().resolved(box, CSS::Length::make_px(containing_block_width_for(box))).to_px(box)); if (box.has_definite_height()) - box_state.content_height = box.computed_values().height().resolved(box, CSS::Length::make_px(containing_block_height_for(box))).to_px(box); + box_state.set_content_height(box.computed_values().height().resolved(box, CSS::Length::make_px(containing_block_height_for(box))).to_px(box)); run(box, LayoutMode::IntrinsicSizeDetermination); } @@ -474,9 +474,9 @@ void BlockFormattingContext::layout_block_level_children(BlockContainer const& b if (layout_mode == LayoutMode::IntrinsicSizeDetermination) { auto& block_container_state = m_state.get_mutable(block_container); if (block_container.computed_values().width().is_auto() || block_container_state.width_constraint != SizeConstraint::None) - block_container_state.content_width = containing_block_width_for(block_container); + block_container_state.set_content_width(containing_block_width_for(block_container)); if (block_container.computed_values().height().is_auto() || block_container_state.height_constraint != SizeConstraint::None) - block_container_state.content_height = containing_block_height_for(block_container); + block_container_state.set_content_height(containing_block_height_for(block_container)); } block_container.for_each_child_of_type([&](Box& box) { @@ -487,9 +487,9 @@ void BlockFormattingContext::layout_block_level_children(BlockContainer const& b if (layout_mode == LayoutMode::IntrinsicSizeDetermination) { auto& block_container_state = m_state.get_mutable(block_container); if (block_container.computed_values().width().is_auto() || block_container_state.width_constraint != SizeConstraint::None) - block_container_state.content_width = greatest_child_width(block_container); + block_container_state.set_content_width(greatest_child_width(block_container)); if (block_container.computed_values().height().is_auto() || block_container_state.height_constraint != SizeConstraint::None) - block_container_state.content_height = content_height; + block_container_state.set_content_height(content_height); } } @@ -559,7 +559,7 @@ void BlockFormattingContext::place_block_level_element_in_normal_flow_vertically auto const& relevant_sibling_state = m_state.get(*relevant_sibling); y += relevant_sibling_state.offset.y() - + relevant_sibling_state.content_height + + relevant_sibling_state.content_height() + relevant_sibling_state.border_box_bottom() + collapsed_margin; } else { @@ -601,7 +601,7 @@ void BlockFormattingContext::place_block_level_element_in_normal_flow_horizontal } if (containing_block.computed_values().text_align() == CSS::TextAlign::LibwebCenter) { - x += (available_width_within_containing_block / 2) - box_state.content_width / 2; + x += (available_width_within_containing_block / 2) - box_state.content_width() / 2; } else { x += box_state.margin_box_left(); } @@ -682,7 +682,7 @@ void BlockFormattingContext::layout_floating_box(Box const& box, BlockContainer if (side == FloatSide::Left) offset_from_edge = box_state.margin_box_left(); else - offset_from_edge = box_state.content_width + box_state.margin_box_right(); + offset_from_edge = box_state.content_width() + box_state.margin_box_right(); }; auto box_in_root_rect = margin_box_rect_in_ancestor_coordinate_space(box, root(), m_state); @@ -701,9 +701,9 @@ void BlockFormattingContext::layout_floating_box(Box const& box, BlockContainer if (side == FloatSide::Left) { wanted_offset_from_edge = side_data.current_width + box_state.margin_box_left(); - fits_on_line = (wanted_offset_from_edge + box_state.content_width + box_state.margin_box_right()) <= width_of_containing_block; + fits_on_line = (wanted_offset_from_edge + box_state.content_width() + box_state.margin_box_right()) <= width_of_containing_block; } else { - wanted_offset_from_edge = side_data.current_width + box_state.margin_box_right() + box_state.content_width; + wanted_offset_from_edge = side_data.current_width + box_state.margin_box_right() + box_state.content_width(); fits_on_line = (wanted_offset_from_edge - box_state.margin_box_left()) >= 0; } @@ -739,12 +739,12 @@ void BlockFormattingContext::layout_floating_box(Box const& box, BlockContainer .box = box, .offset_from_edge = offset_from_edge, .top_margin_edge = y - box_state.margin_box_top(), - .bottom_margin_edge = y + box_state.content_height + box_state.margin_box_bottom(), + .bottom_margin_edge = y + box_state.content_height() + box_state.margin_box_bottom(), })); side_data.current_boxes.append(*side_data.all_boxes.last()); if (side == FloatSide::Left) { - side_data.current_width = offset_from_edge + box_state.content_width + box_state.margin_box_right(); + side_data.current_width = offset_from_edge + box_state.content_width() + box_state.margin_box_right(); } else { side_data.current_width = offset_from_edge + box_state.margin_box_left(); } @@ -782,21 +782,21 @@ void BlockFormattingContext::layout_list_item_marker(ListItemBox const& list_ite int default_marker_width = max(4, marker.font().glyph_height() - 4); if (marker.text().is_empty()) { - marker_state.content_width = image_width + default_marker_width; + marker_state.set_content_width(image_width + default_marker_width); } else { auto text_width = marker.font().width(marker.text()); - marker_state.content_width = image_width + text_width; + marker_state.set_content_width(image_width + text_width); } - marker_state.content_height = max(image_height, marker.font().glyph_height() + 1); + marker_state.set_content_height(max(image_height, marker.font().glyph_height() + 1)); marker_state.offset = { - -(marker_state.content_width + default_marker_width), - max(0.f, (marker.line_height() - marker_state.content_height) / 2.f) + -(marker_state.content_width() + default_marker_width), + max(0.f, (marker.line_height() - marker_state.content_height()) / 2.f) }; - if (marker_state.content_height > list_item_state.content_height) - list_item_state.content_height = marker_state.content_height; + if (marker_state.content_height() > list_item_state.content_height()) + list_item_state.set_content_height(marker_state.content_height()); } BlockFormattingContext::SpaceUsedByFloats BlockFormattingContext::space_used_by_floats(float y) const @@ -809,7 +809,7 @@ BlockFormattingContext::SpaceUsedByFloats BlockFormattingContext::space_used_by_ auto rect = margin_box_rect_in_ancestor_coordinate_space(floating_box.box, root(), m_state); if (rect.contains_vertically(y)) { space_used_by_floats.left = floating_box.offset_from_edge - + floating_box_state.content_width + + floating_box_state.content_width() + floating_box_state.margin_box_right(); break; } @@ -841,7 +841,7 @@ float BlockFormattingContext::greatest_child_width(Box const& box) for (auto& left_float : m_left_floats.all_boxes) { if (line_box.baseline() >= left_float->top_margin_edge || line_box.baseline() <= left_float->bottom_margin_edge) { auto const& left_float_state = m_state.get(left_float->box); - extra_width_from_left_floats = max(extra_width_from_left_floats, left_float->offset_from_edge + left_float_state.content_width + left_float_state.margin_box_right()); + extra_width_from_left_floats = max(extra_width_from_left_floats, left_float->offset_from_edge + left_float_state.content_width() + left_float_state.margin_box_right()); } } float extra_width_from_right_floats = 0; diff --git a/Userland/Libraries/LibWeb/Layout/FlexFormattingContext.cpp b/Userland/Libraries/LibWeb/Layout/FlexFormattingContext.cpp index 684f6c0663..d0f478eb35 100644 --- a/Userland/Libraries/LibWeb/Layout/FlexFormattingContext.cpp +++ b/Userland/Libraries/LibWeb/Layout/FlexFormattingContext.cpp @@ -31,7 +31,7 @@ static float get_pixel_size(LayoutState const& state, Box const& box, Optionalresolved(box, inner_main_size).to_px(box); } @@ -145,7 +145,7 @@ void FlexFormattingContext::run(Box const& run_box, LayoutMode layout_mode) void FlexFormattingContext::populate_specified_margins(FlexItem& item, CSS::FlexDirection flex_direction) const { - auto width_of_containing_block = m_state.get(*item.box.containing_block()).content_width; + auto width_of_containing_block = m_state.get(*item.box.containing_block()).content_width(); auto width_of_containing_block_as_length = CSS::Length::make_px(width_of_containing_block); // FIXME: This should also take reverse-ness into account if (flex_direction == CSS::FlexDirection::Row || flex_direction == CSS::FlexDirection::RowReverse) { @@ -264,13 +264,13 @@ bool FlexFormattingContext::has_definite_main_size(Box const& box) const float FlexFormattingContext::specified_main_size(Box const& box) const { auto const& box_state = m_state.get(box); - return is_row_layout() ? box_state.content_width : box_state.content_height; + return is_row_layout() ? box_state.content_width() : box_state.content_height(); } float FlexFormattingContext::specified_cross_size(Box const& box) const { auto const& box_state = m_state.get(box); - return is_row_layout() ? box_state.content_height : box_state.content_width; + return is_row_layout() ? box_state.content_height() : box_state.content_width(); } float FlexFormattingContext::resolved_definite_cross_size(Box const& box) const @@ -364,7 +364,7 @@ float FlexFormattingContext::specified_cross_max_size(Box const& box) const float FlexFormattingContext::calculated_main_size(Box const& box) const { auto const& box_state = m_state.get(box); - return is_row_layout() ? box_state.content_width : box_state.content_height; + return is_row_layout() ? box_state.content_width() : box_state.content_height(); } bool FlexFormattingContext::is_cross_auto(Box const& box) const @@ -390,17 +390,17 @@ bool FlexFormattingContext::is_main_axis_margin_second_auto(Box const& box) cons void FlexFormattingContext::set_main_size(Box const& box, float size) { if (is_row_layout()) - m_state.get_mutable(box).content_width = size; + m_state.get_mutable(box).set_content_width(size); else - m_state.get_mutable(box).content_height = size; + m_state.get_mutable(box).set_content_height(size); } void FlexFormattingContext::set_cross_size(Box const& box, float size) { if (is_row_layout()) - m_state.get_mutable(box).content_height = size; + m_state.get_mutable(box).set_content_height(size); else - m_state.get_mutable(box).content_width = size; + m_state.get_mutable(box).set_content_width(size); } void FlexFormattingContext::set_offset(Box const& box, float main_offset, float cross_offset) @@ -534,7 +534,7 @@ float FlexFormattingContext::calculate_indefinite_main_size(FlexItem const& item // NOTE: Flex items should always create an independent formatting context! VERIFY(independent_formatting_context); - box_state.content_width = fit_content_cross_size; + box_state.set_content_width(fit_content_cross_size); independent_formatting_context->run(item.box, LayoutMode::Normal); return BlockFormattingContext::compute_theoretical_height(throwaway_state, item.box); @@ -985,16 +985,16 @@ void FlexFormattingContext::determine_hypothetical_cross_size_of_item(FlexItem& VERIFY(independent_formatting_context); if (is_row_layout()) { - box_state.content_width = resolved_definite_main_size(item.box); + box_state.set_content_width(resolved_definite_main_size(item.box)); } else { - box_state.content_height = resolved_definite_main_size(item.box); + box_state.set_content_height(resolved_definite_main_size(item.box)); } independent_formatting_context->run(item.box, LayoutMode::Normal); if (is_row_layout()) item.hypothetical_cross_size = BlockFormattingContext::compute_theoretical_height(throwaway_state, item.box); else - item.hypothetical_cross_size = box_state.content_width; + item.hypothetical_cross_size = box_state.content_width(); } else { // Item has indefinite main size, layout with "fit-content" item.hypothetical_cross_size = calculate_fit_content_cross_size(item); @@ -1165,7 +1165,7 @@ void FlexFormattingContext::distribute_any_remaining_free_space() void FlexFormattingContext::dump_items() const { - dbgln("\033[34;1mflex-container\033[0m {}, direction: {}, current-size: {}x{}", flex_container().debug_description(), is_row_layout() ? "row" : "column", m_flex_container_state.content_width, m_flex_container_state.content_height); + dbgln("\033[34;1mflex-container\033[0m {}, direction: {}, current-size: {}x{}", flex_container().debug_description(), is_row_layout() ? "row" : "column", m_flex_container_state.content_width(), m_flex_container_state.content_height()); for (size_t i = 0; i < m_flex_lines.size(); ++i) { dbgln("{} flex-line #{}:", flex_container().debug_description(), i); for (size_t j = 0; j < m_flex_lines[i].items.size(); ++j) { @@ -1296,15 +1296,15 @@ void FlexFormattingContext::copy_dimensions_from_flex_items_to_boxes() auto const& box = flex_item.box; auto& box_state = m_state.get_mutable(box); - box_state.padding_left = box.computed_values().padding().left.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width)).to_px(box); - box_state.padding_right = box.computed_values().padding().right.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width)).to_px(box); - box_state.padding_top = box.computed_values().padding().top.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width)).to_px(box); - box_state.padding_bottom = box.computed_values().padding().bottom.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width)).to_px(box); + box_state.padding_left = box.computed_values().padding().left.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width())).to_px(box); + box_state.padding_right = box.computed_values().padding().right.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width())).to_px(box); + box_state.padding_top = box.computed_values().padding().top.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width())).to_px(box); + box_state.padding_bottom = box.computed_values().padding().bottom.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width())).to_px(box); - box_state.margin_left = box.computed_values().margin().left.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width)).to_px(box); - box_state.margin_right = box.computed_values().margin().right.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width)).to_px(box); - box_state.margin_top = box.computed_values().margin().top.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width)).to_px(box); - box_state.margin_bottom = box.computed_values().margin().bottom.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width)).to_px(box); + box_state.margin_left = box.computed_values().margin().left.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width())).to_px(box); + box_state.margin_right = box.computed_values().margin().right.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width())).to_px(box); + box_state.margin_top = box.computed_values().margin().top.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width())).to_px(box); + box_state.margin_bottom = box.computed_values().margin().bottom.resolved(box, CSS::Length::make_px(m_flex_container_state.content_width())).to_px(box); box_state.border_left = box.computed_values().border_left().width; box_state.border_right = box.computed_values().border_right().width; @@ -1325,11 +1325,11 @@ void FlexFormattingContext::determine_intrinsic_size_of_flex_container(LayoutMod float main_size = calculate_intrinsic_main_size_of_flex_container(layout_mode); float cross_size = calculate_intrinsic_cross_size_of_flex_container(layout_mode); if (is_row_layout()) { - m_flex_container_state.content_width = main_size; - m_flex_container_state.content_height = cross_size; + m_flex_container_state.set_content_width(main_size); + m_flex_container_state.set_content_height(cross_size); } else { - m_flex_container_state.content_height = main_size; - m_flex_container_state.content_width = cross_size; + m_flex_container_state.set_content_height(main_size); + m_flex_container_state.set_content_width(cross_size); } } diff --git a/Userland/Libraries/LibWeb/Layout/FormattingContext.cpp b/Userland/Libraries/LibWeb/Layout/FormattingContext.cpp index d207e17557..fa016533dd 100644 --- a/Userland/Libraries/LibWeb/Layout/FormattingContext.cpp +++ b/Userland/Libraries/LibWeb/Layout/FormattingContext.cpp @@ -33,10 +33,10 @@ void FormattingContext::run_intrinsic_size_determination(Box const& box) auto& box_state = m_state.get_mutable(box); if (box.has_definite_width()) - box_state.content_width = box.computed_values().width().resolved(box, CSS::Length::make_px(containing_block_width_for(box))).to_px(box); + box_state.set_content_width(box.computed_values().width().resolved(box, CSS::Length::make_px(containing_block_width_for(box))).to_px(box)); if (box.has_definite_height()) - box_state.content_height = box.computed_values().height().resolved(box, CSS::Length::make_px(containing_block_height_for(box))).to_px(box); + box_state.set_content_height(box.computed_values().height().resolved(box, CSS::Length::make_px(containing_block_height_for(box))).to_px(box)); run(box, LayoutMode::IntrinsicSizeDetermination); } @@ -187,8 +187,8 @@ static Gfx::FloatSize solve_replaced_size_constraint(LayoutState const& state, f auto const& containing_block = *box.containing_block(); auto const& containing_block_state = state.get(containing_block); - 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 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 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_auto() ? w : box.computed_values().max_width().resolved(box, width_of_containing_block).to_px(box); @@ -232,7 +232,7 @@ float FormattingContext::compute_auto_height_for_block_level_element(LayoutState auto display = box.computed_values().display(); if (display.is_flex_inside()) - return box_state.content_height; + return box_state.content_height(); // https://www.w3.org/TR/CSS22/visudet.html#normal-block // 10.6.3 Block-level non-replaced elements in normal flow when 'overflow' computes to 'visible' @@ -263,7 +263,7 @@ float FormattingContext::compute_auto_height_for_block_level_element(LayoutState continue; // FIXME: Handle margin collapsing. - return max(0, child_box_state.offset.y() + child_box_state.content_height + child_box_state.margin_box_bottom()); + return max(0, child_box_state.offset.y() + child_box_state.content_height() + child_box_state.margin_box_bottom()); } } @@ -303,7 +303,7 @@ float FormattingContext::compute_auto_height_for_block_formatting_context_root(L auto const& child_box_state = state.get(child_box); float 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(); + float 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()) top = child_box_top; @@ -323,7 +323,7 @@ float FormattingContext::compute_auto_height_for_block_formatting_context_root(L return IterationDecision::Continue; auto const& child_box_state = state.get(child_box); - float child_box_bottom = child_box_state.offset.y() + child_box_state.content_height + child_box_state.margin_box_bottom(); + float child_box_bottom = child_box_state.offset.y() + child_box_state.content_height() + child_box_state.margin_box_bottom(); if (!bottom.has_value() || child_box_bottom > bottom.value()) bottom = child_box_bottom; @@ -338,7 +338,7 @@ float FormattingContext::compute_auto_height_for_block_formatting_context_root(L float FormattingContext::tentative_width_for_replaced_element(LayoutState const& state, ReplacedBox const& box, CSS::LengthPercentage const& computed_width) { auto const& containing_block = *box.containing_block(); - auto height_of_containing_block = CSS::Length::make_px(state.get(containing_block).content_height); + auto height_of_containing_block = CSS::Length::make_px(state.get(containing_block).content_height()); auto computed_height = box.computed_values().height().resolved(box, height_of_containing_block).resolved(box); float used_width = computed_width.resolved(box, CSS::Length::make_px(containing_block_width_for(box, state))).to_px(box); @@ -618,7 +618,7 @@ void FormattingContext::compute_width_for_absolutely_positioned_non_replaced_ele } auto& box_state = m_state.get_mutable(box); - box_state.content_width = used_width.to_px(box); + box_state.set_content_width(used_width.to_px(box)); box_state.margin_left = margin_left.to_px(box); box_state.margin_right = margin_right.to_px(box); @@ -634,7 +634,7 @@ void FormattingContext::compute_width_for_absolutely_positioned_replaced_element // The used value of 'width' is determined as for inline replaced elements. // FIXME: This const_cast is gross. const_cast(box).prepare_for_replaced_layout(); - m_state.get_mutable(box).content_width = compute_width_for_replaced_element(m_state, box); + m_state.get_mutable(box).set_content_width(compute_width_for_replaced_element(m_state, box)); } // https://www.w3.org/TR/CSS22/visudet.html#abs-non-replaced-height @@ -691,7 +691,7 @@ void FormattingContext::compute_height_for_absolutely_positioned_non_replaced_el used_height = min(used_height, specified_max_height.to_px(box)); if (!specified_min_height.is_auto()) used_height = max(used_height, specified_min_height.to_px(box)); - box_state.content_height = used_height; + box_state.set_content_height(used_height); } } @@ -745,7 +745,7 @@ void FormattingContext::layout_absolutely_positioned_element(Box const& box) float x_offset = 0 - box_state.inset_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); } else { float x_offset = box_state.margin_box_left(); used_offset.set_x(x_offset); @@ -759,7 +759,7 @@ void FormattingContext::layout_absolutely_positioned_element(Box const& box) float y_offset = 0 - box_state.inset_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); } else { float y_offset = box_state.margin_box_top(); used_offset.set_y(y_offset); @@ -775,7 +775,7 @@ void FormattingContext::compute_height_for_absolutely_positioned_replaced_elemen { // 10.6.5 Absolutely positioned, replaced elements // The used value of 'height' is determined as for inline replaced elements. - m_state.get_mutable(box).content_height = compute_height_for_replaced_element(m_state, box); + m_state.get_mutable(box).set_content_height(compute_height_for_replaced_element(m_state, box)); } // https://www.w3.org/TR/css-position-3/#relpos-insets @@ -868,10 +868,10 @@ float FormattingContext::calculate_min_content_width(Layout::Box const& box) con LayoutState throwaway_state(&m_state); auto const& containing_block = *box.containing_block(); auto& containing_block_state = throwaway_state.get_mutable(containing_block); - containing_block_state.content_width = 0; + containing_block_state.set_content_width(0); if (!containing_block.has_definite_height()) - containing_block_state.content_height = INFINITY; + containing_block_state.set_content_height(INFINITY); auto& box_state = throwaway_state.get_mutable(box); box_state.width_constraint = SizeConstraint::MinContent; @@ -880,7 +880,7 @@ float FormattingContext::calculate_min_content_width(Layout::Box const& box) con VERIFY(context); context->run_intrinsic_size_determination(box); if (context->type() == FormattingContext::Type::Flex) { - cache.min_content_width = box_state.content_width; + cache.min_content_width = box_state.content_width(); } else { cache.min_content_width = context->greatest_child_width(box); } @@ -908,10 +908,10 @@ float FormattingContext::calculate_max_content_width(Layout::Box const& box) con LayoutState throwaway_state(&m_state); auto const& containing_block = *box.containing_block(); auto& containing_block_state = throwaway_state.get_mutable(containing_block); - containing_block_state.content_width = INFINITY; + containing_block_state.set_content_width(INFINITY); if (!containing_block.has_definite_height()) - containing_block_state.content_height = INFINITY; + containing_block_state.set_content_height(INFINITY); auto& box_state = throwaway_state.get_mutable(box); box_state.width_constraint = SizeConstraint::MaxContent; @@ -920,7 +920,7 @@ float FormattingContext::calculate_max_content_width(Layout::Box const& box) con VERIFY(context); context->run_intrinsic_size_determination(box); if (context->type() == FormattingContext::Type::Flex) { - cache.max_content_width = box_state.content_width; + cache.max_content_width = box_state.content_width(); } else { cache.max_content_width = context->greatest_child_width(box); } @@ -948,10 +948,10 @@ float FormattingContext::calculate_min_content_height(Layout::Box const& box) co LayoutState throwaway_state(&m_state); auto const& containing_block = *box.containing_block(); auto& containing_block_state = throwaway_state.get_mutable(containing_block); - containing_block_state.content_height = 0; + containing_block_state.set_content_height(0); if (!containing_block.has_definite_width()) - containing_block_state.content_width = INFINITY; + containing_block_state.set_content_width(INFINITY); auto& box_state = throwaway_state.get_mutable(box); box_state.height_constraint = SizeConstraint::MinContent; @@ -960,7 +960,7 @@ float FormattingContext::calculate_min_content_height(Layout::Box const& box) co VERIFY(context); context->run_intrinsic_size_determination(box); if (context->type() == FormattingContext::Type::Flex) { - cache.min_content_height = box_state.content_height; + cache.min_content_height = box_state.content_height(); } else { cache.min_content_height = calculate_auto_height(throwaway_state, box); } @@ -988,10 +988,10 @@ float FormattingContext::calculate_max_content_height(Layout::Box const& box) co LayoutState throwaway_state(&m_state); auto const& containing_block = *box.containing_block(); auto& containing_block_state = throwaway_state.get_mutable(containing_block); - containing_block_state.content_height = INFINITY; + containing_block_state.set_content_height(INFINITY); if (!containing_block.has_definite_width()) - containing_block_state.content_width = INFINITY; + containing_block_state.set_content_width(INFINITY); auto& box_state = throwaway_state.get_mutable(box); box_state.height_constraint = SizeConstraint::MaxContent; @@ -1000,7 +1000,7 @@ float FormattingContext::calculate_max_content_height(Layout::Box const& box) co VERIFY(context); context->run_intrinsic_size_determination(box); if (context->type() == FormattingContext::Type::Flex) { - cache.max_content_height = box_state.content_height; + cache.max_content_height = box_state.content_height(); } else { cache.max_content_height = calculate_auto_height(throwaway_state, box); } @@ -1025,7 +1025,7 @@ float FormattingContext::containing_block_width_for(Box const& box, LayoutState case SizeConstraint::MaxContent: return INFINITY; case SizeConstraint::None: - return containing_block_state.content_width; + return containing_block_state.content_width(); } VERIFY_NOT_REACHED(); } @@ -1041,7 +1041,7 @@ float FormattingContext::containing_block_height_for(Box const& box, LayoutState case SizeConstraint::MaxContent: return INFINITY; case SizeConstraint::None: - return containing_block_state.content_height; + return containing_block_state.content_height(); } VERIFY_NOT_REACHED(); } diff --git a/Userland/Libraries/LibWeb/Layout/InlineFormattingContext.cpp b/Userland/Libraries/LibWeb/Layout/InlineFormattingContext.cpp index 716c1e6c25..6afd3fa672 100644 --- a/Userland/Libraries/LibWeb/Layout/InlineFormattingContext.cpp +++ b/Userland/Libraries/LibWeb/Layout/InlineFormattingContext.cpp @@ -32,7 +32,7 @@ InlineFormattingContext::InlineFormattingContext(LayoutState& state, BlockContai m_effective_containing_block_width = INFINITY; break; default: - m_effective_containing_block_width = m_containing_block_state.content_width; + m_effective_containing_block_width = m_containing_block_state.content_width(); break; } } @@ -74,7 +74,7 @@ float InlineFormattingContext::available_space_for_line(float y) const auto const& root_block_state = m_state.get(parent().root()); space.left = max(space.left, m_containing_block_state.offset.x()) - m_containing_block_state.offset.x(); - space.right = min(root_block_state.content_width - space.right, m_containing_block_state.offset.x() + m_effective_containing_block_width); + space.right = min(root_block_state.content_width() - space.right, m_containing_block_state.offset.x() + m_effective_containing_block_width); return space.right - space.left; } @@ -113,8 +113,8 @@ void InlineFormattingContext::dimension_box_on_line(Box const& box, LayoutMode l if (is(box)) (void)layout_inside(replaced, layout_mode); - box_state.content_width = compute_width_for_replaced_element(m_state, replaced); - box_state.content_height = compute_height_for_replaced_element(m_state, replaced); + box_state.set_content_width(compute_width_for_replaced_element(m_state, replaced)); + box_state.set_content_height(compute_height_for_replaced_element(m_state, replaced)); return; } @@ -125,7 +125,7 @@ void InlineFormattingContext::dimension_box_on_line(Box const& box, LayoutMode l if (width_value.is_auto()) { auto result = calculate_shrink_to_fit_widths(inline_block); - auto available_width = m_containing_block_state.content_width + auto available_width = m_containing_block_state.content_width() - box_state.margin_left - box_state.border_left - box_state.padding_left @@ -134,10 +134,10 @@ void InlineFormattingContext::dimension_box_on_line(Box const& box, LayoutMode l - box_state.margin_right; auto width = min(max(result.preferred_minimum_width, available_width), result.preferred_width); - box_state.content_width = width; + box_state.set_content_width(width); } else { auto container_width = CSS::Length::make_px(m_effective_containing_block_width); - box_state.content_width = width_value.resolved(box, container_width).to_px(inline_block); + box_state.set_content_width(width_value.resolved(box, container_width).to_px(inline_block)); } auto independent_formatting_context = layout_inside(inline_block, layout_mode); @@ -146,8 +146,8 @@ void InlineFormattingContext::dimension_box_on_line(Box const& box, LayoutMode l // FIXME: (10.6.6) If 'height' is 'auto', the height depends on the element's descendants per 10.6.7. BlockFormattingContext::compute_height(inline_block, m_state); } else { - auto container_height = CSS::Length::make_px(m_containing_block_state.content_height); - box_state.content_height = height_value.resolved(box, container_height).to_px(inline_block); + auto container_height = CSS::Length::make_px(m_containing_block_state.content_height()); + box_state.set_content_height(height_value.resolved(box, container_height).to_px(inline_block)); } independent_formatting_context->parent_context_did_dimension_child_root_box(); diff --git a/Userland/Libraries/LibWeb/Layout/InlineLevelIterator.cpp b/Userland/Libraries/LibWeb/Layout/InlineLevelIterator.cpp index 0637e9fc26..892998722a 100644 --- a/Userland/Libraries/LibWeb/Layout/InlineLevelIterator.cpp +++ b/Userland/Libraries/LibWeb/Layout/InlineLevelIterator.cpp @@ -34,9 +34,9 @@ void InlineLevelIterator::enter_node_with_box_model_metrics(Layout::NodeWithStyl auto& used_values = m_layout_state.get_mutable(node); auto const& computed_values = node.computed_values(); - used_values.margin_left = computed_values.margin().left.resolved(node, CSS::Length::make_px(m_container_state.content_width)).to_px(node); + used_values.margin_left = computed_values.margin().left.resolved(node, CSS::Length::make_px(m_container_state.content_width())).to_px(node); used_values.border_left = computed_values.border_left().width; - used_values.padding_left = computed_values.padding().left.resolved(node, CSS::Length::make_px(m_container_state.content_width)).to_px(node); + used_values.padding_left = computed_values.padding().left.resolved(node, CSS::Length::make_px(m_container_state.content_width())).to_px(node); m_extra_leading_metrics->margin += used_values.margin_left; m_extra_leading_metrics->border += used_values.border_left; @@ -54,9 +54,9 @@ void InlineLevelIterator::exit_node_with_box_model_metrics() auto& used_values = m_layout_state.get_mutable(node); auto const& computed_values = node.computed_values(); - used_values.margin_right = computed_values.margin().right.resolved(node, CSS::Length::make_px(m_container_state.content_width)).to_px(node); + used_values.margin_right = computed_values.margin().right.resolved(node, CSS::Length::make_px(m_container_state.content_width())).to_px(node); used_values.border_right = computed_values.border_right().width; - used_values.padding_right = computed_values.padding().right.resolved(node, CSS::Length::make_px(m_container_state.content_width)).to_px(node); + used_values.padding_right = computed_values.padding().right.resolved(node, CSS::Length::make_px(m_container_state.content_width())).to_px(node); m_extra_trailing_metrics->margin += used_values.margin_right; m_extra_trailing_metrics->border += used_values.border_right; @@ -209,7 +209,7 @@ Optional InlineLevelIterator::next(float available_wi .node = &box, .offset_in_node = 0, .length_in_node = 0, - .width = box_state.content_width, + .width = box_state.content_width(), .padding_start = box_state.padding_left, .padding_end = box_state.padding_right, .border_start = box_state.border_left, diff --git a/Userland/Libraries/LibWeb/Layout/LayoutState.cpp b/Userland/Libraries/LibWeb/Layout/LayoutState.cpp index ab4ad96653..7d67780a02 100644 --- a/Userland/Libraries/LibWeb/Layout/LayoutState.cpp +++ b/Userland/Libraries/LibWeb/Layout/LayoutState.cpp @@ -71,7 +71,7 @@ void LayoutState::commit() auto& box = static_cast(node); auto& paint_box = const_cast(*box.paint_box()); paint_box.set_offset(used_values.offset); - paint_box.set_content_size(used_values.content_width, used_values.content_height); + paint_box.set_content_size(used_values.content_width(), used_values.content_height()); paint_box.set_overflow_data(move(used_values.overflow_data)); paint_box.set_containing_line_box_fragment(used_values.containing_line_box_fragment); @@ -94,7 +94,7 @@ void LayoutState::commit() Gfx::FloatRect margin_box_rect(Box const& box, LayoutState const& state) { auto const& box_state = state.get(box); - auto rect = Gfx::FloatRect { box_state.offset, { box_state.content_width, box_state.content_height } }; + auto rect = Gfx::FloatRect { box_state.offset, { box_state.content_width(), box_state.content_height() } }; rect.set_x(rect.x() - box_state.margin_box_left()); rect.set_width(rect.width() + box_state.margin_box_left() + box_state.margin_box_right()); rect.set_y(rect.y() - box_state.margin_box_top()); @@ -119,10 +119,20 @@ Gfx::FloatRect margin_box_rect_in_ancestor_coordinate_space(Box const& box, Box Gfx::FloatRect absolute_content_rect(Box const& box, LayoutState const& state) { auto const& box_state = state.get(box); - Gfx::FloatRect rect { box_state.offset, { box_state.content_width, box_state.content_height } }; + Gfx::FloatRect rect { box_state.offset, { box_state.content_width(), box_state.content_height() } }; for (auto* block = box.containing_block(); block; block = block->containing_block()) rect.translate_by(state.get(*block).offset); return rect; } +void LayoutState::UsedValues::set_content_width(float width) +{ + m_content_width = width; +} + +void LayoutState::UsedValues::set_content_height(float height) +{ + m_content_height = height; +} + } diff --git a/Userland/Libraries/LibWeb/Layout/LayoutState.h b/Userland/Libraries/LibWeb/Layout/LayoutState.h index 875856a043..837845554e 100644 --- a/Userland/Libraries/LibWeb/Layout/LayoutState.h +++ b/Userland/Libraries/LibWeb/Layout/LayoutState.h @@ -44,8 +44,12 @@ struct LayoutState { struct UsedValues { Layout::NodeWithStyleAndBoxModelMetrics* node { nullptr }; - float content_width { 0 }; - float content_height { 0 }; + float content_width() const { return m_content_width; } + float content_height() const { return m_content_height; } + + void set_content_width(float); + void set_content_height(float); + Gfx::FloatPoint offset; SizeConstraint width_constraint { SizeConstraint::None }; @@ -78,16 +82,16 @@ struct LayoutState { float margin_box_top() const { return margin_top + border_top + padding_top; } float margin_box_bottom() const { return margin_bottom + border_bottom + padding_bottom; } - float margin_box_width() const { return margin_box_left() + content_width + margin_box_right(); } - float margin_box_height() const { return margin_box_top() + content_height + margin_box_bottom(); } + float margin_box_width() const { return margin_box_left() + content_width() + margin_box_right(); } + float margin_box_height() const { return margin_box_top() + content_height() + margin_box_bottom(); } float border_box_left() const { return border_left + padding_left; } float border_box_right() const { return border_right + padding_right; } float border_box_top() const { return border_top + padding_top; } float border_box_bottom() const { return border_bottom + padding_bottom; } - float border_box_width() const { return border_box_left() + content_width + border_box_right(); } - float border_box_height() const { return border_box_top() + content_height + border_box_bottom(); } + float border_box_width() const { return border_box_left() + content_width() + border_box_right(); } + float border_box_height() const { return border_box_top() + content_height() + border_box_bottom(); } Optional overflow_data; @@ -99,6 +103,10 @@ struct LayoutState { } Optional containing_line_box_fragment; + + private: + float m_content_width { 0 }; + float m_content_height { 0 }; }; void commit(); diff --git a/Userland/Libraries/LibWeb/Layout/LineBuilder.cpp b/Userland/Libraries/LibWeb/Layout/LineBuilder.cpp index be03f1222d..86ea897186 100644 --- a/Userland/Libraries/LibWeb/Layout/LineBuilder.cpp +++ b/Userland/Libraries/LibWeb/Layout/LineBuilder.cpp @@ -52,7 +52,7 @@ void LineBuilder::append_box(Box const& box, float leading_size, float trailing_ { auto& box_state = m_layout_state.get_mutable(box); auto& line_box = ensure_last_line_box(); - line_box.add_fragment(box, 0, 0, leading_size, trailing_size, leading_margin, trailing_margin, box_state.content_width, box_state.content_height, box_state.border_box_top(), box_state.border_box_bottom()); + line_box.add_fragment(box, 0, 0, leading_size, trailing_size, leading_margin, trailing_margin, box_state.content_width(), box_state.content_height(), box_state.border_box_top(), box_state.border_box_bottom()); m_max_height_on_current_line = max(m_max_height_on_current_line, box_state.border_box_height()); box_state.containing_line_box_fragment = LineBoxFragmentCoordinate { @@ -86,7 +86,7 @@ static float box_baseline(LayoutState const& state, Box const& box) case CSS::VerticalAlign::Top: return box_state.border_box_top(); case CSS::VerticalAlign::Bottom: - return box_state.content_height + box_state.border_box_bottom(); + return box_state.content_height() + box_state.border_box_bottom(); default: break; } @@ -215,7 +215,7 @@ void LineBuilder::update_last_line() if (fragment.layout_node().is_replaced_box() || fragment.layout_node().is_inline_block()) { auto const& fragment_box_state = m_layout_state.get(static_cast(fragment.layout_node())); top_of_inline_box = fragment.offset().y() - fragment_box_state.margin_box_top(); - bottom_of_inline_box = fragment.offset().y() + fragment_box_state.content_height + fragment_box_state.margin_box_bottom(); + bottom_of_inline_box = fragment.offset().y() + fragment_box_state.content_height() + fragment_box_state.margin_box_bottom(); } else { auto font_metrics = fragment.layout_node().font().pixel_metrics(); auto typographic_height = font_metrics.ascent + font_metrics.descent; diff --git a/Userland/Libraries/LibWeb/Layout/SVGFormattingContext.cpp b/Userland/Libraries/LibWeb/Layout/SVGFormattingContext.cpp index a951ba1bbc..d9ce91c9c8 100644 --- a/Userland/Libraries/LibWeb/Layout/SVGFormattingContext.cpp +++ b/Userland/Libraries/LibWeb/Layout/SVGFormattingContext.cpp @@ -37,8 +37,8 @@ void SVGFormattingContext::run(Box const& box, LayoutMode) auto& layout_node = *svg_svg_element.layout_node(); // FIXME: Allow for relative lengths here - geometry_box_state.content_width = layout_node.computed_values().width().resolved(layout_node, { 0, CSS::Length::Type::Px }).to_px(layout_node); - geometry_box_state.content_height = layout_node.computed_values().height().resolved(layout_node, { 0, CSS::Length::Type::Px }).to_px(layout_node); + geometry_box_state.set_content_width(layout_node.computed_values().width().resolved(layout_node, { 0, CSS::Length::Type::Px }).to_px(layout_node)); + geometry_box_state.set_content_height(layout_node.computed_values().height().resolved(layout_node, { 0, CSS::Length::Type::Px }).to_px(layout_node)); return IterationDecision::Continue; } @@ -64,15 +64,15 @@ void SVGFormattingContext::run(Box const& box, LayoutMode) Gfx::FloatPoint viewbox_offset = { view_box.min_x, view_box.min_y }; geometry_box_state.offset = path_bounding_box.top_left() + viewbox_offset; - geometry_box_state.content_width = view_box.width; - geometry_box_state.content_height = view_box.height; + geometry_box_state.set_content_width(view_box.width); + geometry_box_state.set_content_height(view_box.height); return IterationDecision::Continue; } geometry_box_state.offset = path_bounding_box.top_left(); - geometry_box_state.content_width = path_bounding_box.width(); - geometry_box_state.content_height = path_bounding_box.height(); + geometry_box_state.set_content_width(path_bounding_box.width()); + geometry_box_state.set_content_height(path_bounding_box.height()); } return IterationDecision::Continue; diff --git a/Userland/Libraries/LibWeb/Layout/TableFormattingContext.cpp b/Userland/Libraries/LibWeb/Layout/TableFormattingContext.cpp index e87fa03cae..1fa59a03f1 100644 --- a/Userland/Libraries/LibWeb/Layout/TableFormattingContext.cpp +++ b/Userland/Libraries/LibWeb/Layout/TableFormattingContext.cpp @@ -28,7 +28,7 @@ void TableFormattingContext::run(Box const& box, LayoutMode) auto& box_state = m_state.get_mutable(box); compute_width(box); - auto table_width = CSS::Length::make_px(box_state.content_width); + auto table_width = CSS::Length::make_px(box_state.content_width()); auto table_width_is_auto = box.computed_values().width().is_auto(); float total_content_width = 0; @@ -47,8 +47,8 @@ void TableFormattingContext::run(Box const& box, LayoutMode) box.for_each_child_of_type([&](auto& row_group_box) { auto& row_group_box_state = m_state.get_mutable(row_group_box); - float remaining_for_max = box_state.content_width; - float remaining_for_min = box_state.content_width; + float remaining_for_max = box_state.content_width(); + float remaining_for_min = box_state.content_width(); for (auto& column_width : column_widths) { remaining_for_max -= column_width.max; remaining_for_min -= column_width.min; @@ -90,24 +90,24 @@ void TableFormattingContext::run(Box const& box, LayoutMode) auto& row_state = m_state.get_mutable(row); row_state.offset = { 0, content_height }; layout_row(row, column_widths); - content_width = max(content_width, row_state.content_width); - content_height += row_state.content_height; + content_width = max(content_width, row_state.content_width()); + content_height += row_state.content_height(); }); if (row_group_box.computed_values().width().is_auto()) - row_group_box_state.content_width = content_width; - row_group_box_state.content_height = content_height; + row_group_box_state.set_content_width(content_width); + row_group_box_state.set_content_height(content_height); row_group_box_state.offset = { 0, total_content_height }; total_content_height += content_height; - total_content_width = max(total_content_width, row_group_box_state.content_width); + total_content_width = max(total_content_width, row_group_box_state.content_width()); }); if (table_width_is_auto) - box_state.content_width = total_content_width; + box_state.set_content_width(total_content_width); // FIXME: This is a total hack, we should respect the 'height' property. - box_state.content_height = total_content_height; + box_state.set_content_height(total_content_height); } void TableFormattingContext::calculate_column_widths(Box const& row, CSS::Length const& table_width, Vector& column_widths) @@ -121,7 +121,7 @@ void TableFormattingContext::calculate_column_widths(Box const& row, CSS::Length if (specified_width.is_auto()) { auto width = calculate_max_content_width(cell); - cell_state.content_width = width; + cell_state.set_content_width(width); } else { compute_width(cell, LayoutMode::Normal); } @@ -182,7 +182,7 @@ void TableFormattingContext::layout_row(Box const& row, Vector& col float span_width = 0; for (size_t i = 0; i < cell.colspan(); ++i) span_width += column_widths[column_index++].used; - cell_state.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()); BlockFormattingContext::compute_height(cell, m_state); cell_state.offset = row_state.offset.translated(cell_state.border_box_left() + content_width, cell_state.border_box_top()); @@ -194,18 +194,18 @@ void TableFormattingContext::layout_row(Box const& row, Vector& col tallest_cell_height = max(tallest_cell_height, cell_state.border_box_height()); }); - row_state.content_height = tallest_cell_height; + row_state.set_content_height(tallest_cell_height); row.for_each_child_of_type([&](auto& cell) { auto& cell_state = m_state.get_mutable(cell); - cell_state.content_height = tallest_cell_height - cell_state.border_box_top() - cell_state.border_box_bottom(); + cell_state.set_content_height(tallest_cell_height - cell_state.border_box_top() - cell_state.border_box_bottom()); }); if (use_auto_layout) { - row_state.content_width = content_width; + row_state.set_content_width(content_width); } else { auto& table_state = m_state.get_mutable(*table); - row_state.content_width = table_state.content_width; + row_state.set_content_width(table_state.content_width()); } }