diff --git a/Userland/Libraries/LibWeb/DOM/Document.cpp b/Userland/Libraries/LibWeb/DOM/Document.cpp index 519f01d38f..da9e71952b 100644 --- a/Userland/Libraries/LibWeb/DOM/Document.cpp +++ b/Userland/Libraries/LibWeb/DOM/Document.cpp @@ -833,7 +833,7 @@ void Document::update_layout() if (!browsing_context()) return; - auto viewport_rect = browsing_context()->viewport_rect().to_type(); + auto viewport_rect = browsing_context()->viewport_rect(); if (!m_layout_root) { m_next_layout_node_serial_id = 0; diff --git a/Userland/Libraries/LibWeb/Layout/BlockFormattingContext.cpp b/Userland/Libraries/LibWeb/Layout/BlockFormattingContext.cpp index f04289ee49..54e7446da7 100644 --- a/Userland/Libraries/LibWeb/Layout/BlockFormattingContext.cpp +++ b/Userland/Libraries/LibWeb/Layout/BlockFormattingContext.cpp @@ -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) { - m_state.get_mutable(box).set_content_width(compute_width_for_replaced_element(m_state, box, available_space).value()); + m_state.get_mutable(box).set_content_width(compute_width_for_replaced_element(m_state, box, available_space)); } void BlockFormattingContext::compute_height(Box const& box, AvailableSpace const& available_space) @@ -338,7 +338,7 @@ void BlockFormattingContext::compute_height(Box const& box, AvailableSpace const height = max(height, calculate_inner_height(box, available_space.height, computed_values.min_height()).to_px(box)); } - m_state.get_mutable(box).set_content_height(height.value()); + m_state.get_mutable(box).set_content_height(height); } void BlockFormattingContext::layout_inline_children(BlockContainer const& block_container, LayoutMode layout_mode, AvailableSpace const& available_space) @@ -354,9 +354,9 @@ void BlockFormattingContext::layout_inline_children(BlockContainer const& block_ available_space); if (!block_container_state.has_definite_width()) - block_container_state.set_content_width(context.automatic_content_width().value()); + block_container_state.set_content_width(context.automatic_content_width()); if (!block_container_state.has_definite_height()) - block_container_state.set_content_height(context.automatic_content_height().value()); + block_container_state.set_content_height(context.automatic_content_height()); } static bool margins_collapse_through(Box const& box, LayoutState& state) @@ -396,7 +396,7 @@ CSSPixels BlockFormattingContext::compute_auto_height_for_block_level_element(Bo // 1. the bottom edge of the last line box, if the box establishes a inline formatting context with one or more lines if (box.children_are_inline() && !box_state.line_boxes.is_empty()) - return box_state.line_boxes.last().bottom(); + return box_state.line_boxes.last().bottom().value(); // 2. the bottom edge of the bottom (possibly collapsed) margin of its last in-flow child, if the child's bottom margin does not collapse with the element's bottom margin // 3. the bottom border edge of the last in-flow child whose top margin doesn't collapse with the element's bottom margin @@ -427,7 +427,7 @@ CSSPixels BlockFormattingContext::compute_auto_height_for_block_level_element(Bo margin_bottom = 0; } - return max(0.0f, child_box_state.offset.y() + child_box_state.content_height() + child_box_state.border_box_bottom() + margin_bottom.value()); + return max(0.0f, (child_box_state.offset.y() + child_box_state.content_height() + child_box_state.border_box_bottom() + margin_bottom).value()); } } @@ -546,9 +546,9 @@ void BlockFormattingContext::layout_block_level_children(BlockContainer const& b if (layout_mode == LayoutMode::IntrinsicSizing) { auto& block_container_state = m_state.get_mutable(block_container); if (!block_container_state.has_definite_width()) - block_container_state.set_content_width(greatest_child_width(block_container).value()); + block_container_state.set_content_width(greatest_child_width(block_container)); if (!block_container_state.has_definite_height()) - block_container_state.set_content_height(bottom_of_lowest_margin_box.value()); + block_container_state.set_content_height(bottom_of_lowest_margin_box); } } @@ -629,7 +629,7 @@ void BlockFormattingContext::place_block_level_element_in_normal_flow_vertically if ((computed_values.clear() == CSS::Clear::Right || computed_values.clear() == CSS::Clear::Both) && !child_box.is_flex_item()) clear_floating_boxes(m_right_floats); - box_state.set_content_offset(Gfx::FloatPoint { box_state.offset.x(), y.value() }); + box_state.set_content_offset(CSSPixelPoint { box_state.offset.x(), y.value() }); } void BlockFormattingContext::place_block_level_element_in_normal_flow_horizontally(Box const& child_box, AvailableSpace const& available_space) @@ -713,7 +713,7 @@ void BlockFormattingContext::layout_floating_box(Box const& box, BlockContainer // First we place the box normally (to get the right y coordinate.) // If we have a LineBuilder, we're in the middle of inline layout, otherwise this is block layout. if (line_builder) { - auto y = line_builder->y_for_float_to_be_inserted_here(box).value(); + auto y = line_builder->y_for_float_to_be_inserted_here(box); box_state.set_content_y(y + box_state.margin_box_top()); } else { place_block_level_element_in_normal_flow_vertically(box, y + box_state.margin_box_top()); @@ -753,7 +753,7 @@ void BlockFormattingContext::layout_floating_box(Box const& box, BlockContainer } if (fits_on_line) { - auto const previous_rect = margin_box_rect_in_ancestor_coordinate_space(previous_box.box, root(), m_state).to_type(); + auto const previous_rect = margin_box_rect_in_ancestor_coordinate_space(previous_box.box, root(), m_state); if (previous_rect.contains_vertically(y_in_root + side_data.y_offset)) { // This box touches another already floating box. Stack after others. offset_from_edge = wanted_offset_from_edge; @@ -856,8 +856,8 @@ void BlockFormattingContext::layout_list_item_marker(ListItemBox const& list_ite marker_state.set_content_height(max(image_height, marker.font().glyph_height() + 1).value()); - marker_state.set_content_offset({ -(marker_state.content_width() + default_marker_width.value()), - max(0.f, (marker.line_height() - marker_state.content_height()) / 2.f) }); + marker_state.set_content_offset({ -(marker_state.content_width() + default_marker_width), + max(CSSPixels(0.f), (CSSPixels(marker.line_height()) - marker_state.content_height()) / 2.f) }); if (marker_state.content_height() > list_item_state.content_height()) list_item_state.set_content_height(marker_state.content_height()); diff --git a/Userland/Libraries/LibWeb/Layout/FlexFormattingContext.cpp b/Userland/Libraries/LibWeb/Layout/FlexFormattingContext.cpp index 4d0051610f..69acc2fd30 100644 --- a/Userland/Libraries/LibWeb/Layout/FlexFormattingContext.cpp +++ b/Userland/Libraries/LibWeb/Layout/FlexFormattingContext.cpp @@ -442,43 +442,43 @@ bool FlexFormattingContext::is_cross_auto(Box const& box) const void FlexFormattingContext::set_main_size(Box const& box, CSSPixels size) { if (is_row_layout()) - m_state.get_mutable(box).set_content_width(size.value()); + m_state.get_mutable(box).set_content_width(size); else - m_state.get_mutable(box).set_content_height(size.value()); + m_state.get_mutable(box).set_content_height(size); } void FlexFormattingContext::set_cross_size(Box const& box, CSSPixels size) { if (is_row_layout()) - m_state.get_mutable(box).set_content_height(size.value()); + m_state.get_mutable(box).set_content_height(size); else - m_state.get_mutable(box).set_content_width(size.value()); + m_state.get_mutable(box).set_content_width(size); } void FlexFormattingContext::set_offset(Box const& box, CSSPixels main_offset, CSSPixels cross_offset) { if (is_row_layout()) - m_state.get_mutable(box).offset = Gfx::FloatPoint { main_offset, cross_offset }; + m_state.get_mutable(box).offset = CSSPixelPoint { main_offset, cross_offset }; else - m_state.get_mutable(box).offset = Gfx::FloatPoint { cross_offset, main_offset }; + m_state.get_mutable(box).offset = CSSPixelPoint { cross_offset, main_offset }; } void FlexFormattingContext::set_main_axis_first_margin(FlexItem& item, CSSPixels margin) { item.margins.main_before = margin; if (is_row_layout()) - m_state.get_mutable(item.box).margin_left = margin.value(); + m_state.get_mutable(item.box).margin_left = margin; else - m_state.get_mutable(item.box).margin_top = margin.value(); + m_state.get_mutable(item.box).margin_top = margin; } void FlexFormattingContext::set_main_axis_second_margin(FlexItem& item, CSSPixels margin) { item.margins.main_after = margin; if (is_row_layout()) - m_state.get_mutable(item.box).margin_right = margin.value(); + m_state.get_mutable(item.box).margin_right = margin; else - m_state.get_mutable(item.box).margin_bottom = margin.value(); + m_state.get_mutable(item.box).margin_bottom = margin; } // https://drafts.csswg.org/css-flexbox-1/#algo-available @@ -581,10 +581,10 @@ CSSPixels FlexFormattingContext::calculate_indefinite_main_size(FlexItem const& // NOTE: Flex items should always create an independent formatting context! VERIFY(independent_formatting_context); - box_state.set_content_width(fit_content_cross_size.value()); + box_state.set_content_width(fit_content_cross_size); independent_formatting_context->run(item.box, LayoutMode::Normal, m_available_space_for_items->space); - return independent_formatting_context->automatic_content_height().value(); + return independent_formatting_context->automatic_content_height(); } return calculate_fit_content_main_size(item); @@ -708,9 +708,9 @@ void FlexFormattingContext::determine_flex_base_size_and_hypothetical_main_size( // The spec just barely hand-waves about this, but it seems to *roughly* match what other engines do. // See "Note" section here: https://drafts.csswg.org/css-flexbox-1/#definite-sizes if (is_row_layout()) - m_state.get_mutable(flex_item.box).set_temporary_content_width(flex_item.hypothetical_main_size.value()); + m_state.get_mutable(flex_item.box).set_temporary_content_width(flex_item.hypothetical_main_size); else - m_state.get_mutable(flex_item.box).set_temporary_content_height(flex_item.hypothetical_main_size.value()); + m_state.get_mutable(flex_item.box).set_temporary_content_height(flex_item.hypothetical_main_size); } // https://drafts.csswg.org/css-flexbox-1/#min-size-auto @@ -825,13 +825,13 @@ void FlexFormattingContext::determine_main_size_of_flex_container() if (is_row_layout()) { 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).value()); + set_main_size(flex_container(), calculate_stretch_fit_width(flex_container(), m_available_space_for_flex_container->space.width)); } else { - set_main_size(flex_container(), calculate_max_content_width(flex_container()).value()); + set_main_size(flex_container(), calculate_max_content_width(flex_container())); } } else { 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).value()); + set_main_size(flex_container(), calculate_max_content_height(flex_container(), m_available_space_for_flex_container->space.width)); } } @@ -1091,9 +1091,9 @@ void FlexFormattingContext::determine_hypothetical_cross_size_of_item(FlexItem& auto& containing_block_state = throwaway_state.get_mutable(flex_container()); if (is_row_layout()) { - containing_block_state.set_content_width(item.main_size.value()); + containing_block_state.set_content_width(item.main_size); } else { - containing_block_state.set_content_height(item.main_size.value()); + containing_block_state.set_content_height(item.main_size); } auto& box_state = throwaway_state.get_mutable(item.box); @@ -2054,13 +2054,13 @@ CSSPixelPoint FlexFormattingContext::calculate_static_position(Box const& box) c if (!pack_from_end) main_offset += specified_main_size(flex_container()) - specified_main_size(box); - auto static_position_offset = is_row_layout() ? Gfx::FloatPoint { main_offset, cross_offset } : Gfx::FloatPoint { cross_offset, main_offset }; + auto static_position_offset = is_row_layout() ? CSSPixelPoint { main_offset, cross_offset } : CSSPixelPoint { cross_offset, main_offset }; auto absolute_position_of_flex_container = absolute_content_rect(flex_container(), 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; - return (static_position_offset + diff).to_type(); + return static_position_offset + diff; } } diff --git a/Userland/Libraries/LibWeb/Layout/FormattingContext.cpp b/Userland/Libraries/LibWeb/Layout/FormattingContext.cpp index d088f46d30..61b8a0fcf0 100644 --- a/Userland/Libraries/LibWeb/Layout/FormattingContext.cpp +++ b/Userland/Libraries/LibWeb/Layout/FormattingContext.cpp @@ -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. // FIXME: This const_cast is gross. const_cast(box).prepare_for_replaced_layout(); - m_state.get_mutable(box).set_content_width(compute_width_for_replaced_element(m_state, box, available_space).value()); + m_state.get_mutable(box).set_content_width(compute_width_for_replaced_element(m_state, box, available_space)); } // https://drafts.csswg.org/css-position-3/#abs-non-replaced-height @@ -819,14 +819,14 @@ 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. 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).to_type(); + auto rect = content_box_rect(box, state); if (&box == &ancestor_box) return rect; for (auto const* current = box.parent(); current; current = current->parent()) { if (current == &ancestor_box) return rect; auto const& current_state = state.get(static_cast(*current)); - rect.translate_by(current_state.offset.to_type()); + rect.translate_by(current_state.offset); } // If we get here, ancestor_box was not an ancestor of `box`! VERIFY_NOT_REACHED(); @@ -934,7 +934,7 @@ void FormattingContext::layout_absolutely_positioned_element(Box const& box, Ava + box_state.border_box_left(); used_offset.set_x(x_offset + box_state.margin_left); } else if (!computed_right.is_auto()) { - CSSPixels x_offset = 0 + CSSPixels x_offset = CSSPixels(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); @@ -948,7 +948,7 @@ void FormattingContext::layout_absolutely_positioned_element(Box const& box, Ava + box_state.border_box_top(); used_offset.set_y(y_offset + box_state.margin_top); } else if (!computed_bottom.is_auto()) { - CSSPixels y_offset = 0 + CSSPixels y_offset = CSSPixels(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); @@ -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. used_offset.translate_by(-containing_block_state.padding_left, -containing_block_state.padding_top); - box_state.set_content_offset(used_offset.to_type()); + box_state.set_content_offset(used_offset); if (independent_formatting_context) 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 // 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).value()); + m_state.get_mutable(box).set_content_height(compute_height_for_replaced_element(m_state, box, available_space)); } // 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) return; - 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 resolve_two_opposing_insets = [&](CSS::LengthPercentage const& computed_start, CSS::LengthPercentage const& computed_end, CSSPixels& used_start, CSSPixels& used_end, CSSPixels reference_for_percentage) { 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); @@ -992,16 +992,16 @@ void FormattingContext::compute_inset(Box const& box) // If only one is auto, its used value becomes the negation of the other, and the box is shifted by the specified amount. if (resolved_first.is_auto()) { used_end = resolved_second.to_px(box); - used_start = 0 - used_end; + used_start = -used_end; } else { used_start = resolved_first.to_px(box); - used_end = 0 - used_start; + used_end = -used_start; } } else { // If neither is auto, the position is over-constrained; (with respect to the writing mode of its containing block) // the computed end side value is ignored, and its used value becomes the negation of the start side. used_start = resolved_first.to_px(box); - used_end = 0 - used_start; + used_end = -used_start; } }; @@ -1082,7 +1082,7 @@ CSSPixels FormattingContext::calculate_min_content_width(Layout::Box const& box) cache.min_content_width = context->greatest_child_width(box).value(); } - if (!isfinite(*cache.min_content_width)) { + if (!isfinite(cache.min_content_width->value())) { // 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 width for {}", box.debug_description()); cache.min_content_width = 0; @@ -1120,7 +1120,7 @@ CSSPixels FormattingContext::calculate_max_content_width(Layout::Box const& box) cache.max_content_width = context->greatest_child_width(box).value(); } - if (!isfinite(*cache.max_content_width)) { + if (!isfinite(cache.max_content_width->value())) { // 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 width for {}", box.debug_description()); cache.max_content_width = 0; @@ -1135,12 +1135,12 @@ CSSPixels FormattingContext::calculate_min_content_height(Layout::Box const& box return *box.intrinsic_height(); bool is_cacheable = available_width.is_definite() || available_width.is_intrinsic_sizing_constraint(); - Optional* cache_slot = nullptr; + Optional* cache_slot = nullptr; if (is_cacheable) { auto& root_state = m_state.m_root; auto& cache = *root_state.intrinsic_sizes.ensure(&box, [] { return adopt_own(*new LayoutState::IntrinsicSizes); }); if (available_width.is_definite()) { - cache_slot = &cache.min_content_height_with_definite_available_width.ensure(available_width.to_px().value()); + cache_slot = &cache.min_content_height_with_definite_available_width.ensure(available_width.to_px()); } else if (available_width.is_min_content()) { cache_slot = &cache.min_content_height_with_min_content_available_width; } else if (available_width.is_max_content()) { @@ -1169,7 +1169,7 @@ CSSPixels FormattingContext::calculate_min_content_height(Layout::Box const& box } if (cache_slot) { - *cache_slot = min_content_height.value(); + *cache_slot = min_content_height; } return min_content_height; } @@ -1180,12 +1180,12 @@ CSSPixels FormattingContext::calculate_max_content_height(Layout::Box const& box return *box.intrinsic_height(); bool is_cacheable = available_width.is_definite() || available_width.is_intrinsic_sizing_constraint(); - Optional* cache_slot = nullptr; + Optional* cache_slot = nullptr; if (is_cacheable) { auto& root_state = m_state.m_root; auto& cache = *root_state.intrinsic_sizes.ensure(&box, [] { return adopt_own(*new LayoutState::IntrinsicSizes); }); if (available_width.is_definite()) { - cache_slot = &cache.max_content_height_with_definite_available_width.ensure(available_width.to_px().value()); + cache_slot = &cache.max_content_height_with_definite_available_width.ensure(available_width.to_px()); } else if (available_width.is_min_content()) { cache_slot = &cache.max_content_height_with_min_content_available_width; } else if (available_width.is_max_content()) { @@ -1215,7 +1215,7 @@ CSSPixels FormattingContext::calculate_max_content_height(Layout::Box const& box } if (cache_slot) { - *cache_slot = max_content_height.value(); + *cache_slot = max_content_height; } return max_content_height; diff --git a/Userland/Libraries/LibWeb/Layout/GridFormattingContext.cpp b/Userland/Libraries/LibWeb/Layout/GridFormattingContext.cpp index 42479eeeaf..2d777c435b 100644 --- a/Userland/Libraries/LibWeb/Layout/GridFormattingContext.cpp +++ b/Userland/Libraries/LibWeb/Layout/GridFormattingContext.cpp @@ -1732,8 +1732,8 @@ void GridFormattingContext::run(Box const& box, LayoutMode, AvailableSpace const y_start += m_grid_rows[i].base_size; for (int i = 0; i < row_end; i++) y_end += m_grid_rows[i].base_size; - child_box_state.set_content_width((x_end - x_start).value()); - child_box_state.set_content_height((y_end - y_start).value()); + child_box_state.set_content_width((x_end - x_start)); + child_box_state.set_content_height((y_end - y_start)); child_box_state.offset = { x_start, y_start }; auto available_space_for_children = AvailableSpace(AvailableSize::make_definite(child_box_state.content_width()), AvailableSize::make_definite(child_box_state.content_height())); diff --git a/Userland/Libraries/LibWeb/Layout/InlineFormattingContext.cpp b/Userland/Libraries/LibWeb/Layout/InlineFormattingContext.cpp index 570c9b932a..86de634b11 100644 --- a/Userland/Libraries/LibWeb/Layout/InlineFormattingContext.cpp +++ b/Userland/Libraries/LibWeb/Layout/InlineFormattingContext.cpp @@ -41,7 +41,7 @@ BlockFormattingContext const& InlineFormattingContext::parent() const CSSPixels InlineFormattingContext::leftmost_x_offset_at(CSSPixels y) const { // NOTE: Floats are relative to the BFC root box, not necessarily the containing block of this IFC. - auto box_in_root_rect = content_box_rect_in_ancestor_coordinate_space(containing_block(), parent().root(), m_state).to_type(); + auto box_in_root_rect = content_box_rect_in_ancestor_coordinate_space(containing_block(), parent().root(), m_state); CSSPixels y_in_root = box_in_root_rect.y() + y; auto space = parent().space_used_by_floats(y_in_root); return space.left; @@ -51,7 +51,7 @@ CSSPixels InlineFormattingContext::available_space_for_line(CSSPixels y) const { // NOTE: Floats are relative to the BFC root box, not necessarily the containing block of this IFC. auto& root_block = parent().root(); - auto box_in_root_rect = content_box_rect_in_ancestor_coordinate_space(containing_block(), root_block, m_state).to_type(); + auto box_in_root_rect = content_box_rect_in_ancestor_coordinate_space(containing_block(), root_block, m_state); CSSPixels y_in_root = box_in_root_rect.y() + y; auto space = parent().space_used_by_floats(y_in_root); @@ -117,8 +117,8 @@ void InlineFormattingContext::dimension_box_on_line(Box const& box, LayoutMode l if (is(box)) (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).value()); - box_state.set_content_height(compute_height_for_replaced_element(m_state, replaced, *m_available_space).value()); + box_state.set_content_width(compute_width_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)); return; } @@ -161,7 +161,7 @@ void InlineFormattingContext::dimension_box_on_line(Box const& box, LayoutMode l width = max(width, min_width); } - box_state.set_content_width(width.value()); + box_state.set_content_width(width); auto independent_formatting_context = layout_inside(box, layout_mode, box_state.available_inner_space_or_constraints_from(*m_available_space)); @@ -317,7 +317,7 @@ void InlineFormattingContext::generate_line_boxes(LayoutMode layout_mode) bool InlineFormattingContext::any_floats_intrude_at_y(CSSPixels y) const { - auto box_in_root_rect = content_box_rect_in_ancestor_coordinate_space(containing_block(), parent().root(), m_state).to_type(); + auto box_in_root_rect = content_box_rect_in_ancestor_coordinate_space(containing_block(), parent().root(), m_state); CSSPixels y_in_root = box_in_root_rect.y() + y; auto space = parent().space_used_by_floats(y_in_root); return space.left > 0 || space.right > 0; @@ -325,7 +325,7 @@ bool InlineFormattingContext::any_floats_intrude_at_y(CSSPixels y) const bool InlineFormattingContext::can_fit_new_line_at_y(CSSPixels y) const { - auto box_in_root_rect = content_box_rect_in_ancestor_coordinate_space(containing_block(), parent().root(), m_state).to_type(); + auto box_in_root_rect = content_box_rect_in_ancestor_coordinate_space(containing_block(), parent().root(), m_state); CSSPixels y_in_root = box_in_root_rect.y() + y; auto space_top = parent().space_used_by_floats(y_in_root); auto space_bottom = parent().space_used_by_floats(y_in_root + containing_block().line_height() - 1); diff --git a/Userland/Libraries/LibWeb/Layout/LayoutState.cpp b/Userland/Libraries/LibWeb/Layout/LayoutState.cpp index 7eeac066ab..93c75eef04 100644 --- a/Userland/Libraries/LibWeb/Layout/LayoutState.cpp +++ b/Userland/Libraries/LibWeb/Layout/LayoutState.cpp @@ -65,10 +65,10 @@ void LayoutState::commit() auto& node = const_cast(used_values.node()); // Transfer box model metrics. - node.box_model().inset = { used_values.inset_top, used_values.inset_right, used_values.inset_bottom, used_values.inset_left }; - node.box_model().padding = { used_values.padding_top, used_values.padding_right, used_values.padding_bottom, used_values.padding_left }; - node.box_model().border = { used_values.border_top, used_values.border_right, used_values.border_bottom, used_values.border_left }; - node.box_model().margin = { used_values.margin_top, used_values.margin_right, used_values.margin_bottom, used_values.margin_left }; + node.box_model().inset = { used_values.inset_top.value(), used_values.inset_right.value(), used_values.inset_bottom.value(), used_values.inset_left.value() }; + node.box_model().padding = { used_values.padding_top.value(), used_values.padding_right.value(), used_values.padding_bottom.value(), used_values.padding_left.value() }; + node.box_model().border = { used_values.border_top.value(), used_values.border_right.value(), used_values.border_bottom.value(), used_values.border_left.value() }; + node.box_model().margin = { used_values.margin_top.value(), used_values.margin_right.value(), used_values.margin_bottom.value(), used_values.margin_left.value() }; node.set_paintable(node.create_paintable()); @@ -76,7 +76,7 @@ void LayoutState::commit() if (is(node)) { auto& box = static_cast(node); auto& paint_box = const_cast(*box.paint_box()); - paint_box.set_offset(used_values.offset.to_type()); + paint_box.set_offset(used_values.offset); 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); @@ -97,7 +97,7 @@ void LayoutState::commit() text_node->set_paintable(text_node->create_paintable()); } -float box_baseline(LayoutState const& state, Box const& box) +CSSPixels box_baseline(LayoutState const& state, Box const& box) { auto const& box_state = state.get(box); @@ -123,7 +123,7 @@ float box_baseline(LayoutState const& state, Box const& box) } if (!box_state.line_boxes.is_empty()) - return box_state.border_box_top() + box_state.offset.y() + box_state.line_boxes.last().baseline().value(); + return box_state.border_box_top() + box_state.offset.y() + box_state.line_boxes.last().baseline(); if (box.has_children() && !box.children_are_inline()) { auto const* child_box = box.last_child_of_type(); VERIFY(child_box); @@ -132,10 +132,10 @@ float box_baseline(LayoutState const& state, Box const& box) return box_state.border_box_height(); } -Gfx::FloatRect margin_box_rect(Box const& box, LayoutState const& state) +CSSPixelRect 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 = CSSPixelRect { 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()); @@ -143,10 +143,10 @@ Gfx::FloatRect margin_box_rect(Box const& box, LayoutState const& state) return rect; } -Gfx::FloatRect border_box_rect(Box const& box, LayoutState const& state) +CSSPixelRect border_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 = CSSPixelRect { box_state.offset, { box_state.content_width(), box_state.content_height() } }; rect.set_x(rect.x() - box_state.border_box_left()); rect.set_width(rect.width() + box_state.border_box_left() + box_state.border_box_right()); rect.set_y(rect.y() - box_state.border_box_top()); @@ -154,7 +154,7 @@ Gfx::FloatRect border_box_rect(Box const& box, LayoutState const& state) return rect; } -Gfx::FloatRect border_box_rect_in_ancestor_coordinate_space(Box const& box, Box const& ancestor_box, LayoutState const& state) +CSSPixelRect border_box_rect_in_ancestor_coordinate_space(Box const& box, Box const& ancestor_box, LayoutState const& state) { auto rect = border_box_rect(box, state); if (&box == &ancestor_box) @@ -169,13 +169,13 @@ Gfx::FloatRect border_box_rect_in_ancestor_coordinate_space(Box const& box, Box VERIFY_NOT_REACHED(); } -Gfx::FloatRect content_box_rect(Box const& box, LayoutState const& state) +CSSPixelRect content_box_rect(Box const& box, LayoutState const& state) { auto const& box_state = state.get(box); - return Gfx::FloatRect { box_state.offset, { box_state.content_width(), box_state.content_height() } }; + return CSSPixelRect { box_state.offset, { box_state.content_width(), box_state.content_height() } }; } -Gfx::FloatRect content_box_rect_in_ancestor_coordinate_space(Box const& box, Box const& ancestor_box, LayoutState const& state) +CSSPixelRect content_box_rect_in_ancestor_coordinate_space(Box const& box, Box const& ancestor_box, LayoutState const& state) { auto rect = content_box_rect(box, state); if (&box == &ancestor_box) @@ -190,7 +190,7 @@ Gfx::FloatRect content_box_rect_in_ancestor_coordinate_space(Box const& box, Box VERIFY_NOT_REACHED(); } -Gfx::FloatRect margin_box_rect_in_ancestor_coordinate_space(Box const& box, Box const& ancestor_box, LayoutState const& state) +CSSPixelRect margin_box_rect_in_ancestor_coordinate_space(Box const& box, Box const& ancestor_box, LayoutState const& state) { auto rect = margin_box_rect(box, state); if (&box == &ancestor_box) @@ -205,10 +205,10 @@ Gfx::FloatRect margin_box_rect_in_ancestor_coordinate_space(Box const& box, Box VERIFY_NOT_REACHED(); } -Gfx::FloatRect absolute_content_rect(Box const& box, LayoutState const& state) +CSSPixelRect 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() } }; + CSSPixelRect 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; @@ -229,7 +229,7 @@ void LayoutState::UsedValues::set_node(NodeWithStyleAndBoxModelMetrics& node, Us auto const& computed_values = node.computed_values(); - auto is_definite_size = [&](CSS::Size const& size, float& resolved_definite_size, bool width) { + auto is_definite_size = [&](CSS::Size const& size, CSSPixels& resolved_definite_size, bool width) { // A size that can be determined without performing layout; that is, // a , // a measure of text (without consideration of line-wrapping), @@ -248,7 +248,7 @@ void LayoutState::UsedValues::set_node(NodeWithStyleAndBoxModelMetrics& node, Us && (node.parent()->display().is_flow_root_inside() || node.parent()->display().is_flow_inside())) { if (containing_block_has_definite_size) { - float available_width = containing_block_used_values->content_width(); + CSSPixels available_width = containing_block_used_values->content_width(); resolved_definite_size = available_width - margin_left - margin_right @@ -296,14 +296,14 @@ void LayoutState::UsedValues::set_node(NodeWithStyleAndBoxModelMetrics& node, Us return false; }; - float min_width = 0; + CSSPixels min_width = 0; bool has_definite_min_width = is_definite_size(computed_values.min_width(), min_width, true); - float max_width = 0; + CSSPixels max_width = 0; bool has_definite_max_width = is_definite_size(computed_values.max_width(), max_width, true); - float min_height = 0; + CSSPixels min_height = 0; bool has_definite_min_height = is_definite_size(computed_values.min_height(), min_height, false); - float max_height = 0; + CSSPixels max_height = 0; bool has_definite_max_height = is_definite_size(computed_values.max_height(), max_height, false); m_has_definite_width = is_definite_size(computed_values.width(), m_content_width, true); @@ -324,34 +324,34 @@ void LayoutState::UsedValues::set_node(NodeWithStyleAndBoxModelMetrics& node, Us } } -void LayoutState::UsedValues::set_content_width(float width) +void LayoutState::UsedValues::set_content_width(CSSPixels width) { m_content_width = width; m_has_definite_width = true; } -void LayoutState::UsedValues::set_content_height(float height) +void LayoutState::UsedValues::set_content_height(CSSPixels height) { m_content_height = height; m_has_definite_height = true; } -void LayoutState::UsedValues::set_temporary_content_width(float width) +void LayoutState::UsedValues::set_temporary_content_width(CSSPixels width) { m_content_width = width; } -void LayoutState::UsedValues::set_temporary_content_height(float height) +void LayoutState::UsedValues::set_temporary_content_height(CSSPixels height) { m_content_height = height; } -float LayoutState::resolved_definite_width(Box const& box) const +CSSPixels LayoutState::resolved_definite_width(Box const& box) const { return get(box).content_width(); } -float LayoutState::resolved_definite_height(Box const& box) const +CSSPixels LayoutState::resolved_definite_height(Box const& box) const { return get(box).content_height(); } @@ -390,18 +390,18 @@ AvailableSpace LayoutState::UsedValues::available_inner_space_or_constraints_fro return AvailableSpace(inner_width, inner_height); } -void LayoutState::UsedValues::set_content_offset(Gfx::FloatPoint offset) +void LayoutState::UsedValues::set_content_offset(CSSPixelPoint new_offset) { - set_content_x(offset.x()); - set_content_y(offset.y()); + set_content_x(new_offset.x()); + set_content_y(new_offset.y()); } -void LayoutState::UsedValues::set_content_x(float x) +void LayoutState::UsedValues::set_content_x(CSSPixels x) { offset.set_x(x); } -void LayoutState::UsedValues::set_content_y(float y) +void LayoutState::UsedValues::set_content_y(CSSPixels y) { offset.set_y(y); } diff --git a/Userland/Libraries/LibWeb/Layout/LayoutState.h b/Userland/Libraries/LibWeb/Layout/LayoutState.h index e7c7515d09..9cd7e55319 100644 --- a/Userland/Libraries/LibWeb/Layout/LayoutState.h +++ b/Userland/Libraries/LibWeb/Layout/LayoutState.h @@ -48,15 +48,15 @@ struct LayoutState { NodeWithStyleAndBoxModelMetrics const& node() const { return *m_node; } void set_node(NodeWithStyleAndBoxModelMetrics&, UsedValues const* containing_block_used_values); - 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); + CSSPixels content_width() const { return m_content_width; } + CSSPixels content_height() const { return m_content_height; } + void set_content_width(CSSPixels); + void set_content_height(CSSPixels); // NOTE: These are used by FlexFormattingContext to assign a temporary main size to items // early on, so that descendants have something to resolve percentages against. - void set_temporary_content_width(float); - void set_temporary_content_height(float); + void set_temporary_content_width(CSSPixels); + void set_temporary_content_height(CSSPixels); bool has_definite_width() const { return m_has_definite_width && width_constraint == SizeConstraint::None; } bool has_definite_height() const { return m_has_definite_height && height_constraint == SizeConstraint::None; } @@ -66,52 +66,52 @@ struct LayoutState { // the constraint is used in that axis instead. AvailableSpace available_inner_space_or_constraints_from(AvailableSpace const& outer_space) const; - void set_content_offset(Gfx::FloatPoint); - void set_content_x(float); - void set_content_y(float); + void set_content_offset(CSSPixelPoint); + void set_content_x(CSSPixels); + void set_content_y(CSSPixels); - Gfx::FloatPoint offset; + CSSPixelPoint offset; SizeConstraint width_constraint { SizeConstraint::None }; SizeConstraint height_constraint { SizeConstraint::None }; - float margin_left { 0 }; - float margin_right { 0 }; - float margin_top { 0 }; - float margin_bottom { 0 }; + CSSPixels margin_left { 0 }; + CSSPixels margin_right { 0 }; + CSSPixels margin_top { 0 }; + CSSPixels margin_bottom { 0 }; - float border_left { 0 }; - float border_right { 0 }; - float border_top { 0 }; - float border_bottom { 0 }; + CSSPixels border_left { 0 }; + CSSPixels border_right { 0 }; + CSSPixels border_top { 0 }; + CSSPixels border_bottom { 0 }; - float padding_left { 0 }; - float padding_right { 0 }; - float padding_top { 0 }; - float padding_bottom { 0 }; + CSSPixels padding_left { 0 }; + CSSPixels padding_right { 0 }; + CSSPixels padding_top { 0 }; + CSSPixels padding_bottom { 0 }; - float inset_left { 0 }; - float inset_right { 0 }; - float inset_top { 0 }; - float inset_bottom { 0 }; + CSSPixels inset_left { 0 }; + CSSPixels inset_right { 0 }; + CSSPixels inset_top { 0 }; + CSSPixels inset_bottom { 0 }; Vector line_boxes; - float margin_box_left() const { return margin_left + border_left + padding_left; } - float margin_box_right() const { return margin_right + border_right + padding_right; } - float margin_box_top() const { return margin_top + border_top + padding_top; } - float margin_box_bottom() const { return margin_bottom + border_bottom + padding_bottom; } + CSSPixels margin_box_left() const { return margin_left + border_left + padding_left; } + CSSPixels margin_box_right() const { return margin_right + border_right + padding_right; } + CSSPixels margin_box_top() const { return margin_top + border_top + padding_top; } + CSSPixels 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(); } + CSSPixels margin_box_width() const { return margin_box_left() + content_width() + margin_box_right(); } + CSSPixels 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; } + CSSPixels border_box_left() const { return border_left + padding_left; } + CSSPixels border_box_right() const { return border_right + padding_right; } + CSSPixels border_box_top() const { return border_top + padding_top; } + CSSPixels 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(); } + CSSPixels border_box_width() const { return border_box_left() + content_width() + border_box_right(); } + CSSPixels border_box_height() const { return border_box_top() + content_height() + border_box_bottom(); } Optional overflow_data; @@ -133,8 +133,8 @@ struct LayoutState { Layout::NodeWithStyleAndBoxModelMetrics* m_node { nullptr }; - float m_content_width { 0 }; - float m_content_height { 0 }; + CSSPixels m_content_width { 0 }; + CSSPixels m_content_height { 0 }; bool m_has_definite_width { false }; bool m_has_definite_height { false }; @@ -142,8 +142,8 @@ struct LayoutState { HashTable m_floating_descendants; }; - float resolved_definite_width(Box const&) const; - float resolved_definite_height(Box const&) const; + CSSPixels resolved_definite_width(Box const&) const; + CSSPixels resolved_definite_height(Box const&) const; void commit(); @@ -158,17 +158,17 @@ struct LayoutState { // We cache intrinsic sizes once determined, as they will not change over the course of a full layout. // This avoids computing them several times while performing flex layout. struct IntrinsicSizes { - Optional min_content_width; - Optional max_content_width; + Optional min_content_width; + Optional max_content_width; // NOTE: Since intrinsic heights depend on the amount of available width, we have to cache // three separate kinds of results, depending on the available width at the time of calculation. - HashMap> min_content_height_with_definite_available_width; - HashMap> max_content_height_with_definite_available_width; - Optional min_content_height_with_min_content_available_width; - Optional max_content_height_with_min_content_available_width; - Optional min_content_height_with_max_content_available_width; - Optional max_content_height_with_max_content_available_width; + HashMap> min_content_height_with_definite_available_width; + HashMap> max_content_height_with_definite_available_width; + Optional min_content_height_with_min_content_available_width; + Optional max_content_height_with_min_content_available_width; + Optional min_content_height_with_max_content_available_width; + Optional max_content_height_with_max_content_available_width; }; HashMap> mutable intrinsic_sizes; @@ -177,13 +177,13 @@ struct LayoutState { LayoutState const& m_root; }; -Gfx::FloatRect absolute_content_rect(Box const&, LayoutState const&); -Gfx::FloatRect margin_box_rect(Box const&, LayoutState const&); -Gfx::FloatRect margin_box_rect_in_ancestor_coordinate_space(Box const& box, Box const& ancestor_box, LayoutState const&); -Gfx::FloatRect border_box_rect(Box const&, LayoutState const&); -Gfx::FloatRect border_box_rect_in_ancestor_coordinate_space(Box const& box, Box const& ancestor_box, LayoutState const&); -Gfx::FloatRect content_box_rect(Box const&, LayoutState const&); -Gfx::FloatRect content_box_rect_in_ancestor_coordinate_space(Box const& box, Box const& ancestor_box, LayoutState const&); -float box_baseline(LayoutState const& state, Box const& box); +CSSPixelRect absolute_content_rect(Box const&, LayoutState const&); +CSSPixelRect margin_box_rect(Box const&, LayoutState const&); +CSSPixelRect margin_box_rect_in_ancestor_coordinate_space(Box const& box, Box const& ancestor_box, LayoutState const&); +CSSPixelRect border_box_rect(Box const&, LayoutState const&); +CSSPixelRect border_box_rect_in_ancestor_coordinate_space(Box const& box, Box const& ancestor_box, LayoutState const&); +CSSPixelRect content_box_rect(Box const&, LayoutState const&); +CSSPixelRect content_box_rect_in_ancestor_coordinate_space(Box const& box, Box const& ancestor_box, LayoutState const&); +CSSPixels box_baseline(LayoutState const& state, Box const& box); } diff --git a/Userland/Libraries/LibWeb/Layout/SVGFormattingContext.cpp b/Userland/Libraries/LibWeb/Layout/SVGFormattingContext.cpp index 9d52d247dd..95a3276bd7 100644 --- a/Userland/Libraries/LibWeb/Layout/SVGFormattingContext.cpp +++ b/Userland/Libraries/LibWeb/Layout/SVGFormattingContext.cpp @@ -81,7 +81,7 @@ void SVGFormattingContext::run(Box const& box, LayoutMode, [[maybe_unused]] Avai if (maybe_view_box.has_value()) { auto view_box = maybe_view_box.value(); CSSPixelPoint viewbox_offset = { view_box.min_x, view_box.min_y }; - geometry_box_state.set_content_offset((path_bounding_box.top_left() + viewbox_offset).to_type()); + geometry_box_state.set_content_offset(path_bounding_box.top_left() + viewbox_offset); geometry_box_state.set_content_width(view_box.width); geometry_box_state.set_content_height(view_box.height); @@ -89,9 +89,9 @@ void SVGFormattingContext::run(Box const& box, LayoutMode, [[maybe_unused]] Avai return IterationDecision::Continue; } - geometry_box_state.set_content_offset(path_bounding_box.top_left().to_type()); - geometry_box_state.set_content_width(path_bounding_box.width().value()); - geometry_box_state.set_content_height(path_bounding_box.height().value()); + geometry_box_state.set_content_offset(path_bounding_box.top_left()); + 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 f052e33991..79c9fbbb0d 100644 --- a/Userland/Libraries/LibWeb/Layout/TableFormattingContext.cpp +++ b/Userland/Libraries/LibWeb/Layout/TableFormattingContext.cpp @@ -174,14 +174,14 @@ void TableFormattingContext::compute_table_width(CSSPixels& extra_width) // If the table-root has 'width: auto', the used width is the greater of // min(GRIDMAX, the table’s containing block width), the used min-width of the table. used_width = max(min(grid_max, width_of_table_containing_block), used_min_width); - table_box_state.set_content_width(used_width.value()); + table_box_state.set_content_width(used_width); } else { // If the table-root’s width property has a computed value (resolving to // resolved-table-width) other than auto, the used width is the greater // of resolved-table-width, and the used min-width of the table. CSSPixels resolved_table_width = computed_values.width().resolved(table_box, CSS::Length::make_px(width_of_table_containing_block)).to_px(table_box); used_width = max(resolved_table_width, used_min_width); - table_box_state.set_content_width(used_width.value()); + table_box_state.set_content_width(used_width); } if (used_width > grid_min) { @@ -212,7 +212,7 @@ void TableFormattingContext::determine_intrisic_size_of_table_container(Availabl CSSPixels grid_min = 0.0f; for (auto& column : m_columns) grid_min += column.min_width; - table_box_state.set_content_width(grid_min.value()); + table_box_state.set_content_width(grid_min); } if (available_space.width.is_max_content()) { @@ -220,7 +220,7 @@ void TableFormattingContext::determine_intrisic_size_of_table_container(Availabl CSSPixels grid_max = 0.0f; for (auto& column : m_columns) grid_max += column.max_width; - table_box_state.set_content_width(grid_max.value()); + table_box_state.set_content_width(grid_max); } } @@ -278,10 +278,10 @@ void TableFormattingContext::run(Box const& box, LayoutMode, AvailableSpace cons cell_state.border_left = (should_hide_borders && is_left_most_cell) ? 0 : cell.box.computed_values().border_left().width; cell_state.border_right = (should_hide_borders && is_right_most_cell) ? 0 : cell.box.computed_values().border_right().width; - cell_state.set_content_width((span_width - cell_state.border_box_left() - cell_state.border_box_right()).value()); + 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)); VERIFY(independent_formatting_context); - cell_state.set_content_height(independent_formatting_context->automatic_content_height().value()); + cell_state.set_content_height(independent_formatting_context->automatic_content_height()); independent_formatting_context->parent_context_did_dimension_child_root_box(); cell.baseline = box_baseline(m_state, cell.box); @@ -300,9 +300,9 @@ void TableFormattingContext::run(Box const& box, LayoutMode, AvailableSpace cons row_width += column.used_width; } - row_state.set_content_height(row.used_width.value()); - row_state.set_content_width(row_width.value()); - row_state.set_content_y(row_top_offset.value()); + row_state.set_content_height(row.used_width); + row_state.set_content_width(row_width); + row_state.set_content_y(row_top_offset); row_top_offset += row_state.content_height(); } @@ -312,12 +312,12 @@ void TableFormattingContext::run(Box const& box, LayoutMode, AvailableSpace cons CSSPixels row_group_width = 0.0f; auto& row_group_box_state = m_state.get_mutable(row_group_box); - row_group_box_state.set_content_y(row_group_top_offset.value()); + row_group_box_state.set_content_y(row_group_top_offset); CSSPixels row_top_offset = 0.0f; row_group_box.template for_each_child_of_type([&](auto& row) { auto& row_state = m_state.get_mutable(row); - row_state.set_content_y(row_top_offset.value()); + row_state.set_content_y(row_top_offset); row_group_height += row_state.border_box_height(); row_group_width = max(row_group_width, row_state.border_box_width()); row_top_offset += row_state.border_box_height(); @@ -325,8 +325,8 @@ void TableFormattingContext::run(Box const& box, LayoutMode, AvailableSpace cons row_group_top_offset += row_top_offset; - row_group_box_state.set_content_height(row_group_height.value()); - row_group_box_state.set_content_width(row_group_width.value()); + row_group_box_state.set_content_height(row_group_height); + row_group_box_state.set_content_width(row_group_width); }); for (auto& cell : m_cells) { @@ -338,16 +338,16 @@ void TableFormattingContext::run(Box const& box, LayoutMode, AvailableSpace cons if (vertical_align.has()) { switch (vertical_align.get()) { case CSS::VerticalAlign::Middle: { - cell_state.padding_top += ((row_content_height - cell_border_box_height) / 2).value(); - cell_state.padding_bottom += ((row_content_height - cell_border_box_height) / 2).value(); + cell_state.padding_top += (row_content_height - cell_border_box_height) / 2; + cell_state.padding_bottom += (row_content_height - cell_border_box_height) / 2; break; } // FIXME: implement actual 'top' and 'bottom' support instead of fall back to 'baseline' case CSS::VerticalAlign::Top: case CSS::VerticalAlign::Bottom: case CSS::VerticalAlign::Baseline: { - cell_state.padding_top += (m_rows[cell.row_index].baseline - cell.baseline).value(); - cell_state.padding_bottom += (row_content_height - cell_border_box_height).value(); + cell_state.padding_top += m_rows[cell.row_index].baseline - cell.baseline; + cell_state.padding_bottom += row_content_height - cell_border_box_height; break; } default: @@ -355,10 +355,10 @@ void TableFormattingContext::run(Box const& box, LayoutMode, AvailableSpace cons } } - cell_state.offset = row_state.offset.translated(cell_state.border_box_left() + m_columns[cell.column_index].left_offset.value(), cell_state.border_box_top()); + cell_state.offset = row_state.offset.translated(cell_state.border_box_left() + m_columns[cell.column_index].left_offset, cell_state.border_box_top()); } - m_state.get_mutable(context_box()).set_content_height(total_content_height.value()); + m_state.get_mutable(context_box()).set_content_height(total_content_height); // FIXME: This is a total hack, we should respect the 'height' property. m_automatic_content_height = total_content_height;