Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-30 21:01:00 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/Layout/InlineLevelIterator.cpp

694 lines
28 KiB
C++
Raw Normal View History

LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 13:19:50 +02:00
* Copyright (c) 2022, Andreas Kling <andreas@ladybird.org>
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
LibWeb: Layout/Shape font-variant-* css properties
2024-12-05 01:21:45 +01:00
#include <LibGfx/Font/FontVariant.h>
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
#include <LibWeb/Layout/BreakNode.h>
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
#include <LibWeb/Layout/InlineFormattingContext.h>
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
#include <LibWeb/Layout/InlineLevelIterator.h>
#include <LibWeb/Layout/InlineNode.h>
LibWeb: Make InlineLevelIterator ignore list item marker boxes Marker boxes are managed explicitly by the corresponding list item box.
2022-01-20 16:17:29 +01:00
#include <LibWeb/Layout/ListItemMarkerBox.h>
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
#include <LibWeb/Layout/ReplacedBox.h>
namespace Web::Layout {
LibWeb: Use cached UsedValues pointer in IFC and its helper classes This avoids expensive LayoutState lookups when we already have the pointer sitting around anyway.
2024-03-15 19:25:00 +01:00
InlineLevelIterator::InlineLevelIterator(Layout::InlineFormattingContext& inline_formatting_context, Layout::LayoutState& layout_state, Layout::BlockContainer const& containing_block, LayoutState::UsedValues const& containing_block_used_values, LayoutMode layout_mode)
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
: m_inline_formatting_context(inline_formatting_context)
LibWeb: Rename LayoutState::NodeState => LayoutState::UsedValues This object contains all the CSS "used values" as seen during the layout process, so calling it "used values" seems appropriate. :^)
2022-07-16 23:43:48 +02:00
, m_layout_state(layout_state)
LibWeb: Use cached UsedValues pointer in IFC and its helper classes This avoids expensive LayoutState lookups when we already have the pointer sitting around anyway.
2024-03-15 19:25:00 +01:00
, m_containing_block(containing_block)
, m_containing_block_used_values(containing_block_used_values)
, m_next_node(containing_block.first_child())
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
, m_layout_mode(layout_mode)
{
skip_to_next();
}
LibWeb: Start making our layout system "transactional" This patch adds a map of Layout::Node to FormattingState::NodeState. Instead of updating layout nodes incrementally as layout progresses through the formatting contexts, all updates are now written to the corresponding NodeState instead. At the end of layout, FormattingState::commit() is called, which transfers all the values from the NodeState objects to the Node. This will soon allow us to perform completely non-destructive layouts which don't affect the tree. Note that there are many imperfections here, and still many places where we assign to the NodeState, but later read directly from the Node instead. I'm just committing at this stage to make subsequent diffs easier to understand.
2022-02-20 15:51:24 +01:00
void InlineLevelIterator::enter_node_with_box_model_metrics(Layout::NodeWithStyleAndBoxModelMetrics const& node)
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
{
if (!m_extra_leading_metrics.has_value())
m_extra_leading_metrics = ExtraBoxMetrics {};
LibWeb: Start making our layout system "transactional" This patch adds a map of Layout::Node to FormattingState::NodeState. Instead of updating layout nodes incrementally as layout progresses through the formatting contexts, all updates are now written to the corresponding NodeState instead. At the end of layout, FormattingState::commit() is called, which transfers all the values from the NodeState objects to the Node. This will soon allow us to perform completely non-destructive layouts which don't affect the tree. Note that there are many imperfections here, and still many places where we assign to the NodeState, but later read directly from the Node instead. I'm just committing at this stage to make subsequent diffs easier to understand.
2022-02-20 15:51:24 +01:00
// FIXME: It's really weird that *this* is where we assign box model metrics for these layout nodes..
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
LibWeb: Rename LayoutState::NodeState => LayoutState::UsedValues This object contains all the CSS "used values" as seen during the layout process, so calling it "used values" seems appropriate. :^)
2022-07-16 23:43:48 +02:00
auto& used_values = m_layout_state.get_mutable(node);
LibWeb: Start making our layout system "transactional" This patch adds a map of Layout::Node to FormattingState::NodeState. Instead of updating layout nodes incrementally as layout progresses through the formatting contexts, all updates are now written to the corresponding NodeState instead. At the end of layout, FormattingState::commit() is called, which transfers all the values from the NodeState objects to the Node. This will soon allow us to perform completely non-destructive layouts which don't affect the tree. Note that there are many imperfections here, and still many places where we assign to the NodeState, but later read directly from the Node instead. I'm just committing at this stage to make subsequent diffs easier to understand.
2022-02-20 15:51:24 +01:00
auto const& computed_values = node.computed_values();
LibWeb: Use cached UsedValues pointer in IFC and its helper classes This avoids expensive LayoutState lookups when we already have the pointer sitting around anyway.
2024-03-15 19:25:00 +01:00
used_values.margin_left = computed_values.margin().left().to_px(node, m_containing_block_used_values.content_width());
LibWeb: Rename LayoutState::NodeState => LayoutState::UsedValues This object contains all the CSS "used values" as seen during the layout process, so calling it "used values" seems appropriate. :^)
2022-07-16 23:43:48 +02:00
used_values.border_left = computed_values.border_left().width;
LibWeb: Use cached UsedValues pointer in IFC and its helper classes This avoids expensive LayoutState lookups when we already have the pointer sitting around anyway.
2024-03-15 19:25:00 +01:00
used_values.padding_left = computed_values.padding().left().to_px(node, m_containing_block_used_values.content_width());
LibWeb: Start making our layout system "transactional" This patch adds a map of Layout::Node to FormattingState::NodeState. Instead of updating layout nodes incrementally as layout progresses through the formatting contexts, all updates are now written to the corresponding NodeState instead. At the end of layout, FormattingState::commit() is called, which transfers all the values from the NodeState objects to the Node. This will soon allow us to perform completely non-destructive layouts which don't affect the tree. Note that there are many imperfections here, and still many places where we assign to the NodeState, but later read directly from the Node instead. I'm just committing at this stage to make subsequent diffs easier to understand.
2022-02-20 15:51:24 +01:00
LibWeb: Resolve vertical borders for inline nodes Preparation for upcoming change where InlinePaintable will no longer be responsible for doing that.
2024-10-15 20:08:48 +02:00
used_values.border_top = computed_values.border_top().width;
used_values.border_bottom = computed_values.border_bottom().width;
LibWeb: Resolve vertical padding of inline elements
2024-04-23 13:34:09 -06:00
used_values.padding_bottom = computed_values.padding().bottom().to_px(node, m_containing_block_used_values.content_width());
used_values.padding_top = computed_values.padding().top().to_px(node, m_containing_block_used_values.content_width());
LibWeb: Rename LayoutState::NodeState => LayoutState::UsedValues This object contains all the CSS "used values" as seen during the layout process, so calling it "used values" seems appropriate. :^)
2022-07-16 23:43:48 +02:00
m_extra_leading_metrics->margin += used_values.margin_left;
m_extra_leading_metrics->border += used_values.border_left;
m_extra_leading_metrics->padding += used_values.padding_left;
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
LibWeb: Resolve CSS inset properties when entering inline-flow elements We don't actually apply the insets anywhere yet, but at least now they are available in the node's layout state.
2023-08-15 09:34:06 +02:00
// Now's our chance to resolve the inset properties for this node.
LibWeb: Fix percentage insets resolution for grid items compute_inset() was incorrectly retrieving the containing block size because containing_block() is unaware of grid areas that form a containing block for grid items but do not exist in the layout tree. With this change, we explicitly pass the containing block into compute_inset(), allowing it to correctly provide the containing block sizes for grid items.
2024-11-11 15:54:21 +01:00
m_inline_formatting_context.compute_inset(node, m_inline_formatting_context.content_box_rect(m_containing_block_used_values).size());
LibWeb: Resolve CSS inset properties when entering inline-flow elements We don't actually apply the insets anywhere yet, but at least now they are available in the node's layout state.
2023-08-15 09:34:06 +02:00
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
m_box_model_node_stack.append(node);
}
void InlineLevelIterator::exit_node_with_box_model_metrics()
{
if (!m_extra_trailing_metrics.has_value())
m_extra_trailing_metrics = ExtraBoxMetrics {};
auto& node = m_box_model_node_stack.last();
LibWeb: Rename LayoutState::NodeState => LayoutState::UsedValues This object contains all the CSS "used values" as seen during the layout process, so calling it "used values" seems appropriate. :^)
2022-07-16 23:43:48 +02:00
auto& used_values = m_layout_state.get_mutable(node);
LibJS+LibWeb: Wrap raw JS::Cell*/& fields in GCPtr/NonnullGCPtr
2023-02-26 16:09:02 -07:00
auto const& computed_values = node->computed_values();
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
LibWeb: Use cached UsedValues pointer in IFC and its helper classes This avoids expensive LayoutState lookups when we already have the pointer sitting around anyway.
2024-03-15 19:25:00 +01:00
used_values.margin_right = computed_values.margin().right().to_px(node, m_containing_block_used_values.content_width());
LibWeb: Rename LayoutState::NodeState => LayoutState::UsedValues This object contains all the CSS "used values" as seen during the layout process, so calling it "used values" seems appropriate. :^)
2022-07-16 23:43:48 +02:00
used_values.border_right = computed_values.border_right().width;
LibWeb: Use cached UsedValues pointer in IFC and its helper classes This avoids expensive LayoutState lookups when we already have the pointer sitting around anyway.
2024-03-15 19:25:00 +01:00
used_values.padding_right = computed_values.padding().right().to_px(node, m_containing_block_used_values.content_width());
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
LibWeb: Rename LayoutState::NodeState => LayoutState::UsedValues This object contains all the CSS "used values" as seen during the layout process, so calling it "used values" seems appropriate. :^)
2022-07-16 23:43:48 +02:00
m_extra_trailing_metrics->margin += used_values.margin_right;
m_extra_trailing_metrics->border += used_values.border_right;
m_extra_trailing_metrics->padding += used_values.padding_right;
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
m_box_model_node_stack.take_last();
}
LibWeb: Teach InlineLevelIterator to skip across inline-block elements We don't want to descend into inline-block containers when iterating inline-level items, since that would make the inline-level children of the inline-block bubble up to the containing block of the inline-block.
2022-01-20 12:18:25 +01:00
// This is similar to Layout::Node::next_in_pre_order() but will not descend into inline-block nodes.
LibWeb: Start making our layout system "transactional" This patch adds a map of Layout::Node to FormattingState::NodeState. Instead of updating layout nodes incrementally as layout progresses through the formatting contexts, all updates are now written to the corresponding NodeState instead. At the end of layout, FormattingState::commit() is called, which transfers all the values from the NodeState objects to the Node. This will soon allow us to perform completely non-destructive layouts which don't affect the tree. Note that there are many imperfections here, and still many places where we assign to the NodeState, but later read directly from the Node instead. I'm just committing at this stage to make subsequent diffs easier to understand.
2022-02-20 15:51:24 +01:00
Layout::Node const* InlineLevelIterator::next_inline_node_in_pre_order(Layout::Node const& current, Layout::Node const* stay_within)
LibWeb: Teach InlineLevelIterator to skip across inline-block elements We don't want to descend into inline-block containers when iterating inline-level items, since that would make the inline-level children of the inline-block bubble up to the containing block of the inline-block.
2022-01-20 12:18:25 +01:00
{
LibWeb: Use CSS::Display::is_flow_inside() in InlineLevelIterator This is a more correct check than !is_inline_block(), as it now enters all elements that have inline behavior on the outside and flow behavior on the inside.
2022-10-06 16:21:11 +02:00
if (current.first_child()
&& current.first_child()->display().is_inline_outside()
&& current.display().is_flow_inside()
&& !current.is_replaced_box()) {
LibWeb: Support CSS floats in inline flow CSS floats are now emitted by the InlineLevelIterator. When this happens, IFC coordinates with the parent BFC to float the box to the side, using the current LineBuilder state for vertical placement. This makes the "instructions" text on Acid3 render as a single contiguous flow of inline content.
2022-03-22 19:18:05 +01:00
if (!current.is_box() || !static_cast<Box const&>(current).is_out_of_flow(m_inline_formatting_context))
return current.first_child();
}
LibWeb: Teach InlineLevelIterator to skip across inline-block elements We don't want to descend into inline-block containers when iterating inline-level items, since that would make the inline-level children of the inline-block bubble up to the containing block of the inline-block.
2022-01-20 12:18:25 +01:00
LibWeb: Start making our layout system "transactional" This patch adds a map of Layout::Node to FormattingState::NodeState. Instead of updating layout nodes incrementally as layout progresses through the formatting contexts, all updates are now written to the corresponding NodeState instead. At the end of layout, FormattingState::commit() is called, which transfers all the values from the NodeState objects to the Node. This will soon allow us to perform completely non-destructive layouts which don't affect the tree. Note that there are many imperfections here, and still many places where we assign to the NodeState, but later read directly from the Node instead. I'm just committing at this stage to make subsequent diffs easier to understand.
2022-02-20 15:51:24 +01:00
Layout::Node const* node = &current;
Layout::Node const* next = nullptr;
LibWeb: Teach InlineLevelIterator to skip across inline-block elements We don't want to descend into inline-block containers when iterating inline-level items, since that would make the inline-level children of the inline-block bubble up to the containing block of the inline-block.
2022-01-20 12:18:25 +01:00
while (!(next = node->next_sibling())) {
node = node->parent();
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
// If node is the last node on the "box model node stack", pop it off.
if (!m_box_model_node_stack.is_empty()
LibJS+LibWeb: Wrap raw JS::Cell*/& fields in GCPtr/NonnullGCPtr
2023-02-26 16:09:02 -07:00
&& m_box_model_node_stack.last() == node) {
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
exit_node_with_box_model_metrics();
}
LibWeb: Teach InlineLevelIterator to skip across inline-block elements We don't want to descend into inline-block containers when iterating inline-level items, since that would make the inline-level children of the inline-block bubble up to the containing block of the inline-block.
2022-01-20 12:18:25 +01:00
if (!node || node == stay_within)
return nullptr;
}
LibWeb: Fix InlineLevelIterator not exiting box model metric nodes We were neglecting to pop nodes from the box model stack. The metrics were already being zeroed out when used, but let's not grow the stack needlessly.
2022-02-26 09:25:24 +01:00
// If node is the last node on the "box model node stack", pop it off.
if (!m_box_model_node_stack.is_empty()
LibJS+LibWeb: Wrap raw JS::Cell*/& fields in GCPtr/NonnullGCPtr
2023-02-26 16:09:02 -07:00
&& m_box_model_node_stack.last() == node) {
LibWeb: Fix InlineLevelIterator not exiting box model metric nodes We were neglecting to pop nodes from the box model stack. The metrics were already being zeroed out when used, but let's not grow the stack needlessly.
2022-02-26 09:25:24 +01:00
exit_node_with_box_model_metrics();
}
LibWeb: Teach InlineLevelIterator to skip across inline-block elements We don't want to descend into inline-block containers when iterating inline-level items, since that would make the inline-level children of the inline-block bubble up to the containing block of the inline-block.
2022-01-20 12:18:25 +01:00
return next;
}
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
void InlineLevelIterator::compute_next()
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
{
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
if (m_next_node == nullptr)
return;
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
do {
LibWeb: Use cached UsedValues pointer in IFC and its helper classes This avoids expensive LayoutState lookups when we already have the pointer sitting around anyway.
2024-03-15 19:25:00 +01:00
m_next_node = next_inline_node_in_pre_order(*m_next_node, m_containing_block);
LibWeb: Support masking of SVGForeignObjectPaintable
2024-04-25 21:10:30 +02:00
if (m_next_node && m_next_node->is_svg_mask_box()) {
// NOTE: It is possible to encounter SVGMaskBox nodes while doing layout of formatting context established by <foreignObject> with a mask.
// We should skip and let SVGFormattingContext take care of them.
m_next_node = m_next_node->next_sibling();
}
LibWeb: Support CSS floats in inline flow CSS floats are now emitted by the InlineLevelIterator. When this happens, IFC coordinates with the parent BFC to float the box to the side, using the current LineBuilder state for vertical placement. This makes the "instructions" text on Acid3 render as a single contiguous flow of inline content.
2022-03-22 19:18:05 +01:00
} while (m_next_node && (!m_next_node->is_inline() && !m_next_node->is_out_of_flow(m_inline_formatting_context)));
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
}
void InlineLevelIterator::skip_to_next()
{
LibWeb: Use CSS::Display::is_flow_inside() in InlineLevelIterator This is a more correct check than !is_inline_block(), as it now enters all elements that have inline behavior on the outside and flow behavior on the inside.
2022-10-06 16:21:11 +02:00
if (m_next_node
&& is<Layout::NodeWithStyleAndBoxModelMetrics>(*m_next_node)
&& m_next_node->display().is_flow_inside()
&& !m_next_node->is_out_of_flow(m_inline_formatting_context)
&& !m_next_node->is_replaced_box())
LibWeb: Start making our layout system "transactional" This patch adds a map of Layout::Node to FormattingState::NodeState. Instead of updating layout nodes incrementally as layout progresses through the formatting contexts, all updates are now written to the corresponding NodeState instead. At the end of layout, FormattingState::commit() is called, which transfers all the values from the NodeState objects to the Node. This will soon allow us to perform completely non-destructive layouts which don't affect the tree. Note that there are many imperfections here, and still many places where we assign to the NodeState, but later read directly from the Node instead. I'm just committing at this stage to make subsequent diffs easier to understand.
2022-02-20 15:51:24 +01:00
enter_node_with_box_model_metrics(static_cast<Layout::NodeWithStyleAndBoxModelMetrics const&>(*m_next_node));
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
m_current_node = m_next_node;
compute_next();
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
}
LibWeb: Remove unused argument of InlineLevelIterator::next Also remove unused method from LineBuilder.
2023-08-17 05:38:52 +00:00
Optional<InlineLevelIterator::Item> InlineLevelIterator::next()
LibWeb: Improve the line breaking algorithm Check the width of the next token after white space to decide line breaks. The next width can also be the total width of multiple tokens. This better follows the CSS Text specification and matches behavior of other browsers. Fixes #20388.
2023-08-19 03:36:53 +00:00
{
if (m_lookahead_items.is_empty())
return next_without_lookahead();
return m_lookahead_items.dequeue();
}
CSSPixels InlineLevelIterator::next_non_whitespace_sequence_width()
{
CSSPixels next_width = 0;
for (;;) {
auto next_item_opt = next_without_lookahead();
if (!next_item_opt.has_value())
break;
m_lookahead_items.enqueue(next_item_opt.release_value());
auto& next_item = m_lookahead_items.tail();
LibWeb: Stop collecting lookahead items on forced break This avoids a crash since such items don't have a node nor CSS properties. Fixes crashes on Wikipedia pages which contain preformatted code.
2023-08-22 06:38:17 +00:00
if (next_item.type == InlineLevelIterator::Item::Type::ForcedBreak)
break;
LibWeb: Improve the line breaking algorithm Check the width of the next token after white space to decide line breaks. The next width can also be the total width of multiple tokens. This better follows the CSS Text specification and matches behavior of other browsers. Fixes #20388.
2023-08-19 03:36:53 +00:00
if (next_item.node->computed_values().white_space() != CSS::WhiteSpace::Nowrap) {
if (next_item.type != InlineLevelIterator::Item::Type::Text)
break;
if (next_item.is_collapsible_whitespace)
break;
AK+Everywhere: Rename `verify_cast` to `as` Follow-up to fc20e61e7249006247b43f84a3189d5a37fa103e.
2025-01-21 09:12:05 -05:00
auto& next_text_node = as<Layout::TextNode>(*(next_item.node));
LibWeb: Port Layout::TextNode from DeprecatedString
2023-11-21 10:56:29 +13:00
auto next_view = next_text_node.text_for_rendering().bytes_as_string_view().substring_view(next_item.offset_in_node, next_item.length_in_node);
LibWeb: Improve the line breaking algorithm Check the width of the next token after white space to decide line breaks. The next width can also be the total width of multiple tokens. This better follows the CSS Text specification and matches behavior of other browsers. Fixes #20388.
2023-08-19 03:36:53 +00:00
if (next_view.is_whitespace())
break;
}
next_width += next_item.border_box_width();
}
return next_width;
}
LibWeb: Layout text chunks based on their Unicode direction Append text chunks to either the start or end of the text fragment, depending on the text direction. The direction is determined by what script its code points are from.
2024-08-18 17:58:05 +01:00
Gfx::GlyphRun::TextType InlineLevelIterator::resolve_text_direction_from_context()
{
VERIFY(m_text_node_context.has_value());
Optional<Gfx::GlyphRun::TextType> next_known_direction;
for (size_t i = 0;; ++i) {
auto peek = m_text_node_context->chunk_iterator.peek(i);
if (!peek.has_value())
break;
if (peek->text_type == Gfx::GlyphRun::TextType::Ltr || peek->text_type == Gfx::GlyphRun::TextType::Rtl) {
next_known_direction = peek->text_type;
break;
}
}
auto last_known_direction = m_text_node_context->last_known_direction;
if (last_known_direction.has_value() && next_known_direction.has_value() && *last_known_direction != *next_known_direction) {
switch (m_containing_block->computed_values().direction()) {
case CSS::Direction::Ltr:
return Gfx::GlyphRun::TextType::Ltr;
case CSS::Direction::Rtl:
return Gfx::GlyphRun::TextType::Rtl;
}
}
if (last_known_direction.has_value())
return *last_known_direction;
if (next_known_direction.has_value())
return *next_known_direction;
return Gfx::GlyphRun::TextType::ContextDependent;
}
LibWeb: Layout/Shape font-variant-* css properties
2024-12-05 01:21:45 +01:00
HashMap<StringView, u8> InlineLevelIterator::shape_features_map() const
{
HashMap<StringView, u8> features;
auto& computed_values = m_current_node->computed_values();
// 6.4 https://drafts.csswg.org/css-fonts/#font-variant-ligatures-prop
auto ligature_or_null = computed_values.font_variant_ligatures();
if (ligature_or_null.has_value()) {
auto ligature = ligature_or_null.release_value();
if (ligature.none) {
/* nothing */
} else {
switch (ligature.common) {
case Gfx::FontVariantLigatures::Common::Common:
// Enables display of common ligatures (OpenType features: liga, clig).
features.set("liga"sv, 1);
features.set("clig"sv, 1);
break;
case Gfx::FontVariantLigatures::Common::NoCommon:
// Disables display of common ligatures (OpenType features: liga, clig).
features.set("liga"sv, 0);
features.set("clig"sv, 0);
break;
case Gfx::FontVariantLigatures::Common::Unset:
break;
}
switch (ligature.discretionary) {
case Gfx::FontVariantLigatures::Discretionary::Discretionary:
// Enables display of discretionary ligatures (OpenType feature: dlig).
features.set("dlig"sv, 1);
break;
case Gfx::FontVariantLigatures::Discretionary::NoDiscretionary:
// Disables display of discretionary ligatures (OpenType feature: dlig).
features.set("dlig"sv, 0);
break;
case Gfx::FontVariantLigatures::Discretionary::Unset:
break;
}
switch (ligature.historical) {
case Gfx::FontVariantLigatures::Historical::Historical:
// Enables display of historical ligatures (OpenType feature: hlig).
features.set("hlig"sv, 1);
break;
case Gfx::FontVariantLigatures::Historical::NoHistorical:
// Disables display of historical ligatures (OpenType feature: hlig).
features.set("hlig"sv, 0);
break;
case Gfx::FontVariantLigatures::Historical::Unset:
break;
}
switch (ligature.contextual) {
case Gfx::FontVariantLigatures::Contextual::Contextual:
// Enables display of contextual ligatures (OpenType feature: calt).
features.set("calt"sv, 1);
break;
case Gfx::FontVariantLigatures::Contextual::NoContextual:
// Disables display of contextual ligatures (OpenType feature: calt).
features.set("calt"sv, 0);
break;
case Gfx::FontVariantLigatures::Contextual::Unset:
break;
}
}
} else {
// A value of normal specifies that common default features are enabled, as described in detail in the next section.
features.set("liga"sv, 1);
features.set("clig"sv, 1);
}
// 6.5 https://drafts.csswg.org/css-fonts/#font-variant-position-prop
switch (computed_values.font_variant_position()) {
case CSS::FontVariantPosition::Normal:
// None of the features listed below are enabled.
break;
case CSS::FontVariantPosition::Sub:
// Enables display of subscripts (OpenType feature: subs).
features.set("subs"sv, 1);
break;
case CSS::FontVariantPosition::Super:
// Enables display of superscripts (OpenType feature: sups).
features.set("sups"sv, 1);
break;
default:
break;
}
// 6.6 https://drafts.csswg.org/css-fonts/#font-variant-caps-prop
switch (computed_values.font_variant_caps()) {
case CSS::FontVariantCaps::Normal:
// None of the features listed below are enabled.
break;
case CSS::FontVariantCaps::SmallCaps:
// Enables display of small capitals (OpenType feature: smcp). Small-caps glyphs typically use the form of uppercase letters but are reduced to the size of lowercase letters.
features.set("smcp"sv, 1);
break;
case CSS::FontVariantCaps::AllSmallCaps:
// Enables display of small capitals for both upper and lowercase letters (OpenType features: c2sc, smcp).
features.set("c2sc"sv, 1);
features.set("smcp"sv, 1);
break;
case CSS::FontVariantCaps::PetiteCaps:
// Enables display of petite capitals (OpenType feature: pcap).
features.set("pcap"sv, 1);
break;
case CSS::FontVariantCaps::AllPetiteCaps:
// Enables display of petite capitals for both upper and lowercase letters (OpenType features: c2pc, pcap).
features.set("c2pc"sv, 1);
features.set("pcap"sv, 1);
break;
case CSS::FontVariantCaps::Unicase:
// Enables display of mixture of small capitals for uppercase letters with normal lowercase letters (OpenType feature: unic).
features.set("unic"sv, 1);
break;
case CSS::FontVariantCaps::TitlingCaps:
// Enables display of titling capitals (OpenType feature: titl).
features.set("titl"sv, 1);
break;
default:
break;
}
// 6.7 https://drafts.csswg.org/css-fonts/#font-variant-numeric-prop
auto numeric_or_null = computed_values.font_variant_numeric();
if (numeric_or_null.has_value()) {
auto numeric = numeric_or_null.release_value();
if (numeric.figure == Gfx::FontVariantNumeric::Figure::Oldstyle) {
// Enables display of old-style numerals (OpenType feature: onum).
features.set("onum"sv, 1);
} else if (numeric.figure == Gfx::FontVariantNumeric::Figure::Lining) {
// Enables display of lining numerals (OpenType feature: lnum).
features.set("lnum"sv, 1);
}
if (numeric.spacing == Gfx::FontVariantNumeric::Spacing::Proportional) {
// Enables display of proportional numerals (OpenType feature: pnum).
features.set("pnum"sv, 1);
} else if (numeric.spacing == Gfx::FontVariantNumeric::Spacing::Tabular) {
// Enables display of tabular numerals (OpenType feature: tnum).
features.set("tnum"sv, 1);
}
if (numeric.fraction == Gfx::FontVariantNumeric::Fraction::Diagonal) {
// Enables display of diagonal fractions (OpenType feature: frac).
features.set("frac"sv, 1);
} else if (numeric.fraction == Gfx::FontVariantNumeric::Fraction::Stacked) {
// Enables display of stacked fractions (OpenType feature: afrc).
features.set("afrc"sv, 1);
features.set("afrc"sv, 1);
}
if (numeric.ordinal) {
// Enables display of letter forms used with ordinal numbers (OpenType feature: ordn).
features.set("ordn"sv, 1);
}
if (numeric.slashed_zero) {
// Enables display of slashed zeros (OpenType feature: zero).
features.set("zero"sv, 1);
}
}
// 6.10 https://drafts.csswg.org/css-fonts/#font-variant-east-asian-prop
auto east_asian_or_null = computed_values.font_variant_east_asian();
if (east_asian_or_null.has_value()) {
auto east_asian = east_asian_or_null.release_value();
switch (east_asian.variant) {
case Gfx::FontVariantEastAsian::Variant::Jis78:
// Enables display of JIS78 forms (OpenType feature: jp78).
features.set("jp78"sv, 1);
break;
case Gfx::FontVariantEastAsian::Variant::Jis83:
// Enables display of JIS83 forms (OpenType feature: jp83).
features.set("jp83"sv, 1);
break;
case Gfx::FontVariantEastAsian::Variant::Jis90:
// Enables display of JIS90 forms (OpenType feature: jp90).
features.set("jp90"sv, 1);
break;
case Gfx::FontVariantEastAsian::Variant::Jis04:
// Enables display of JIS04 forms (OpenType feature: jp04).
features.set("jp04"sv, 1);
break;
case Gfx::FontVariantEastAsian::Variant::Simplified:
// Enables display of simplified forms (OpenType feature: smpl).
features.set("smpl"sv, 1);
break;
case Gfx::FontVariantEastAsian::Variant::Traditional:
// Enables display of traditional forms (OpenType feature: trad).
features.set("trad"sv, 1);
break;
default:
break;
}
switch (east_asian.width) {
case Gfx::FontVariantEastAsian::Width::FullWidth:
// Enables display of full-width forms (OpenType feature: fwid).
features.set("fwid"sv, 1);
break;
case Gfx::FontVariantEastAsian::Width::Proportional:
// Enables display of proportional-width forms (OpenType feature: pwid).
features.set("pwid"sv, 1);
break;
default:
break;
}
if (east_asian.ruby) {
// Enables display of ruby forms (OpenType feature: ruby).
features.set("ruby"sv, 1);
}
}
return features;
}
Gfx::ShapeFeatures InlineLevelIterator::create_and_merge_font_features() const
{
HashMap<StringView, u8> merged_features;
auto& computed_values = m_inline_formatting_context.containing_block().computed_values();
// https://www.w3.org/TR/css-fonts-3/#feature-precedence
// FIXME 1. Font features enabled by default, including features required for a given script.
// FIXME 2. If the font is defined via an @font-face rule, the font features implied by the font-feature-settings descriptor in the @font-face rule.
// 3. Font features implied by the value of the ‘font-variant’ property, the related ‘font-variant’ subproperties and any other CSS property that uses OpenType features (e.g. the ‘font-kerning’ property).
for (auto& it : shape_features_map()) {
merged_features.set(it.key, it.value);
}
// FIXME 4. Feature settings determined by properties other than ‘font-variant’ or ‘font-feature-settings’. For example, setting a non-default value for the ‘letter-spacing’ property disables common ligatures.
// 5. Font features implied by the value of ‘font-feature-settings’ property.
auto resolution_context = CSS::Length::ResolutionContext::for_layout_node(*m_current_node.ptr());
auto font_feature_settings = computed_values.font_feature_settings();
if (font_feature_settings.has_value()) {
auto const& feature_settings = font_feature_settings.value();
for (auto const& [key, feature_value] : feature_settings) {
merged_features.set(key, feature_value.resolved(resolution_context));
}
}
Gfx::ShapeFeatures shape_features;
shape_features.ensure_capacity(merged_features.size());
for (auto& it : merged_features) {
shape_features.append({ { it.key[0], it.key[1], it.key[2], it.key[3] }, static_cast<u32>(it.value) });
}
return shape_features;
}
LibWeb: Improve the line breaking algorithm Check the width of the next token after white space to decide line breaks. The next width can also be the total width of multiple tokens. This better follows the CSS Text specification and matches behavior of other browsers. Fixes #20388.
2023-08-19 03:36:53 +00:00
Optional<InlineLevelIterator::Item> InlineLevelIterator::next_without_lookahead()
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
{
if (!m_current_node)
return {};
if (is<Layout::TextNode>(*m_current_node)) {
LibWeb: Start making our layout system "transactional" This patch adds a map of Layout::Node to FormattingState::NodeState. Instead of updating layout nodes incrementally as layout progresses through the formatting contexts, all updates are now written to the corresponding NodeState instead. At the end of layout, FormattingState::commit() is called, which transfers all the values from the NodeState objects to the Node. This will soon allow us to perform completely non-destructive layouts which don't affect the tree. Note that there are many imperfections here, and still many places where we assign to the NodeState, but later read directly from the Node instead. I'm just committing at this stage to make subsequent diffs easier to understand.
2022-02-20 15:51:24 +01:00
auto& text_node = static_cast<Layout::TextNode const&>(*m_current_node);
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
LibWeb: Make whitespace collapsing stateless Previously, the whitespace collapsing code had a parameter telling it whether the previous text node ended in whitespace. This was not actually necessary, so let's get rid of it.
2022-03-27 21:14:10 +02:00
if (!m_text_node_context.has_value())
enter_text_node(text_node);
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
LibWeb: Layout text chunks based on their Unicode direction Append text chunks to either the start or end of the text fragment, depending on the text direction. The direction is determined by what script its code points are from.
2024-08-18 17:58:05 +01:00
auto chunk_opt = m_text_node_context->chunk_iterator.next();
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
if (!chunk_opt.has_value()) {
m_text_node_context = {};
skip_to_next();
LibWeb: Improve the line breaking algorithm Check the width of the next token after white space to decide line breaks. The next width can also be the total width of multiple tokens. This better follows the CSS Text specification and matches behavior of other browsers. Fixes #20388.
2023-08-19 03:36:53 +00:00
return next_without_lookahead();
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
}
LibWeb: Layout text chunks based on their Unicode direction Append text chunks to either the start or end of the text fragment, depending on the text direction. The direction is determined by what script its code points are from.
2024-08-18 17:58:05 +01:00
if (!m_text_node_context->chunk_iterator.peek(0).has_value())
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
m_text_node_context->is_last_chunk = true;
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
auto& chunk = chunk_opt.value();
LibWeb: Layout text chunks based on their Unicode direction Append text chunks to either the start or end of the text fragment, depending on the text direction. The direction is determined by what script its code points are from.
2024-08-18 17:58:05 +01:00
auto text_type = chunk.text_type;
if (text_type == Gfx::GlyphRun::TextType::Ltr || text_type == Gfx::GlyphRun::TextType::Rtl)
m_text_node_context->last_known_direction = text_type;
if (m_text_node_context->do_respect_linebreaks && chunk.has_breaking_newline) {
m_text_node_context->is_last_chunk = true;
if (chunk.is_all_whitespace)
text_type = Gfx::GlyphRun::TextType::EndPadding;
}
if (text_type == Gfx::GlyphRun::TextType::ContextDependent)
text_type = resolve_text_direction_from_context();
LibWeb: Make text newlines in "pre" mode emit a ForcedBreak item Instead of emitting a Text item with the "should_force_break" flag set to true, newlines in newline-preserving text content now timply turn into ForcedBreak items. This makes the <pre> element work again.
2022-03-26 18:59:54 +01:00
if (m_text_node_context->do_respect_linebreaks && chunk.has_breaking_newline) {
return Item {
.type = Item::Type::ForcedBreak,
};
}
LibWeb: Start implementing letter spacing Letter spacing is applied during text shaping and `shape_text` is used in places other `InlineLevelIterator` so way may have more work to do, however this is a good start :^).
2024-11-05 07:11:34 +00:00
auto resolution_context = CSS::Length::ResolutionContext::for_layout_node(text_node);
auto letter_spacing = text_node.computed_values().letter_spacing().resolved(resolution_context).to_px(text_node);
auto word_spacing = text_node.computed_values().word_spacing().resolved(resolution_context).to_px(text_node);
LibWeb: Start implementation of rendering tabs according to tab-size
2024-10-15 18:21:49 +01:00
auto x = 0.0f;
if (chunk.has_breaking_tab) {
CSSPixels accumulated_width;
// make sure to account for any fragments that take up a portion of the measured tab stop distance
auto fragments = m_containing_block_used_values.line_boxes.last().fragments();
for (auto const& frag : fragments) {
accumulated_width += frag.width();
}
// https://drafts.csswg.org/css-text/#tab-size-property
auto tab_size = text_node.computed_values().tab_size();
LibWeb: Bring tab-size closer to the spec When the css tab-size property is a number, we need to add the associated letter-spacing and word-spacing to it's width.
2024-10-23 08:27:22 +01:00
auto resolution_context = CSS::Length::ResolutionContext::for_layout_node(text_node);
LibWeb: Start implementation of rendering tabs according to tab-size
2024-10-15 18:21:49 +01:00
CSSPixels tab_width;
tab_width = tab_size.visit(
[&](CSS::LengthOrCalculated const& t) -> CSSPixels {
auto value = t.resolved(resolution_context);
return value.to_px(text_node);
},
[&](CSS::NumberOrCalculated const& n) -> CSSPixels {
LibWeb: Bring tab-size closer to the spec When the css tab-size property is a number, we need to add the associated letter-spacing and word-spacing to it's width.
2024-10-23 08:27:22 +01:00
auto tab_number = n.resolved(text_node);
LibWeb: Start implementation of rendering tabs according to tab-size
2024-10-15 18:21:49 +01:00
LibWeb: Bring tab-size closer to the spec When the css tab-size property is a number, we need to add the associated letter-spacing and word-spacing to it's width.
2024-10-23 08:27:22 +01:00
return CSSPixels::nearest_value_for(tab_number * (chunk.font->glyph_width(' ') + word_spacing.to_float() + letter_spacing.to_float()));
LibWeb: Start implementation of rendering tabs according to tab-size
2024-10-15 18:21:49 +01:00
});
// https://drafts.csswg.org/css-text/#white-space-phase-2
// if fragments have added to the width, calculate the net distance to the next tab stop, otherwise the shift will just be the tab width
auto tab_stop_dist = accumulated_width > 0 ? (ceil((accumulated_width / tab_width)) * tab_width) - accumulated_width : tab_width;
auto ch_width = chunk.font->glyph_width('0');
// If this distance is less than 0.5ch, then the subsequent tab stop is used instead
if (tab_stop_dist < ch_width * 0.5)
tab_stop_dist += tab_width;
// account for consecutive tabs
auto num_of_tabs = 0;
for (auto code_point : chunk.view) {
if (code_point != '\t')
break;
num_of_tabs++;
}
tab_stop_dist = tab_stop_dist * num_of_tabs;
LibWeb: Strip tabs before text shaping Handling tabs during text shaping caused issues because we tried to index 'input_glyph_info' whilst iterating until 'glyph_count' and these can be different sizes. The difference is due to when one or more characters get merged into the same glyph when calling 'input_glyph_info' (see https://lazka.github.io/pgi-docs/HarfBuzz-0.0/classes/glyph_info_t.html). We don't want to render tabs as they come up as tofu characters so instead let's strip them out of the text chunk before starting text shaping.
2024-10-22 13:07:26 +01:00
// remove tabs, we don't want to render them when we shape the text
chunk.view = chunk.view.substring_view(num_of_tabs);
LibWeb: Start implementation of rendering tabs according to tab-size
2024-10-15 18:21:49 +01:00
x = tab_stop_dist.to_float();
}
LibWeb: Layout/Shape font-variant-* css properties
2024-12-05 01:21:45 +01:00
auto shape_features = create_and_merge_font_features();
auto glyph_run = Gfx::shape_text({ x, 0 }, letter_spacing.to_float(), chunk.view, chunk.font, text_type, shape_features);
LibWeb: Start implementation of rendering tabs according to tab-size
2024-10-15 18:21:49 +01:00
LibGfx+LibWeb: Simplify text shaping API by removing per glyph callback All places where text shaping happens, the callback is used to simply append a glyph into the end of glyphs vector. This change removes the callback parameter and makes the text shaping function return a glyph run.
2024-09-14 19:54:41 +02:00
CSSPixels chunk_width = CSSPixels::nearest_value_for(glyph_run->width());
LibWeb: Don't add an extra glyph spacing to width of TextNode When calculating the width of text using a bitmap font, a glyph spacing is added at the end of each fragment, including the last one. This meant that everything was 1 pixel too long. This bug did not affect vector fonts.
2023-10-28 15:39:57 +02:00
LibWeb: Don't treat `content: ""` as collapsible whitespace I couldn't find anything in specs about this, but it seems to be roughly consistent with other engines.
2022-10-14 12:30:44 +02:00
// NOTE: We never consider `content: ""` to be collapsible whitespace.
bool is_generated_empty_string = text_node.is_generated() && chunk.length == 0;
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
Item item {
.type = Item::Type::Text,
.node = &text_node,
LibGfx+LibWeb: Simplify text shaping API by removing per glyph callback All places where text shaping happens, the callback is used to simply append a glyph into the end of glyphs vector. This change removes the callback parameter and makes the text shaping function return a glyph run.
2024-09-14 19:54:41 +02:00
.glyph_run = move(glyph_run),
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
.offset_in_node = chunk.start,
.length_in_node = chunk.length,
.width = chunk_width,
LibWeb: Don't treat `content: ""` as collapsible whitespace I couldn't find anything in specs about this, but it seems to be roughly consistent with other engines.
2022-10-14 12:30:44 +02:00
.is_collapsible_whitespace = m_text_node_context->do_collapse && chunk.is_all_whitespace && !is_generated_empty_string,
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
};
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
add_extra_box_model_metrics_to_item(item, m_text_node_context->is_first_chunk, m_text_node_context->is_last_chunk);
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
return item;
}
LibWeb: Don't skip position:relative elements in inline-level layout InlineLevelIterator was wrongly skipping over all positioned elements, instead of just the absolutely positioned ones.
2022-03-02 14:53:39 +01:00
if (m_current_node->is_absolutely_positioned()) {
LibWeb: Make InlineLevelIterator emit absolutely positioned items Note that we don't put absolutely positioned items on a line! This is just so that IFC can discover boxes and pass them along to BFC. This fixes an issue where only direct children of the IFC containing block were considered for absolute positioning. Now we pick up absolutely positioned children of nested inline nodes as well.
2022-03-07 22:27:09 +01:00
auto& node = *m_current_node;
LibWeb: Make InlineLevelIterator skip over positioned elements
2022-02-15 01:54:22 +01:00
skip_to_next();
LibWeb: Make InlineLevelIterator emit absolutely positioned items Note that we don't put absolutely positioned items on a line! This is just so that IFC can discover boxes and pass them along to BFC. This fixes an issue where only direct children of the IFC containing block were considered for absolute positioning. Now we pick up absolutely positioned children of nested inline nodes as well.
2022-03-07 22:27:09 +01:00
return Item {
.type = Item::Type::AbsolutelyPositionedElement,
.node = &node,
};
LibWeb: Make InlineLevelIterator skip over positioned elements
2022-02-15 01:54:22 +01:00
}
LibWeb: Support CSS floats in inline flow CSS floats are now emitted by the InlineLevelIterator. When this happens, IFC coordinates with the parent BFC to float the box to the side, using the current LineBuilder state for vertical placement. This makes the "instructions" text on Acid3 render as a single contiguous flow of inline content.
2022-03-22 19:18:05 +01:00
if (m_current_node->is_floating()) {
auto& node = *m_current_node;
skip_to_next();
return Item {
.type = Item::Type::FloatingElement,
.node = &node,
};
}
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
if (is<Layout::BreakNode>(*m_current_node)) {
LibWeb: Handle float clearing specified on line break elements
2023-07-19 23:44:40 +00:00
auto& node = *m_current_node;
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
skip_to_next();
return Item {
.type = Item::Type::ForcedBreak,
LibWeb: Handle float clearing specified on line break elements
2023-07-19 23:44:40 +00:00
.node = &node,
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
};
}
LibWeb: Make InlineLevelIterator ignore list item marker boxes Marker boxes are managed explicitly by the corresponding list item box.
2022-01-20 16:17:29 +01:00
if (is<Layout::ListItemMarkerBox>(*m_current_node)) {
skip_to_next();
LibWeb: Improve the line breaking algorithm Check the width of the next token after white space to decide line breaks. The next width can also be the total width of multiple tokens. This better follows the CSS Text specification and matches behavior of other browsers. Fixes #20388.
2023-08-19 03:36:53 +00:00
return next_without_lookahead();
LibWeb: Make InlineLevelIterator ignore list item marker boxes Marker boxes are managed explicitly by the corresponding list item box.
2022-01-20 16:17:29 +01:00
}
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
if (!is<Layout::Box>(*m_current_node)) {
skip_to_next();
LibWeb: Improve the line breaking algorithm Check the width of the next token after white space to decide line breaks. The next width can also be the total width of multiple tokens. This better follows the CSS Text specification and matches behavior of other browsers. Fixes #20388.
2023-08-19 03:36:53 +00:00
return next_without_lookahead();
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
}
if (is<Layout::ReplacedBox>(*m_current_node)) {
LibWeb: Start making our layout system "transactional" This patch adds a map of Layout::Node to FormattingState::NodeState. Instead of updating layout nodes incrementally as layout progresses through the formatting contexts, all updates are now written to the corresponding NodeState instead. At the end of layout, FormattingState::commit() is called, which transfers all the values from the NodeState objects to the Node. This will soon allow us to perform completely non-destructive layouts which don't affect the tree. Note that there are many imperfections here, and still many places where we assign to the NodeState, but later read directly from the Node instead. I'm just committing at this stage to make subsequent diffs easier to understand.
2022-02-20 15:51:24 +01:00
auto& replaced_box = static_cast<Layout::ReplacedBox const&>(*m_current_node);
// FIXME: This const_cast is gross.
const_cast<Layout::ReplacedBox&>(replaced_box).prepare_for_replaced_layout();
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
}
AK+Everywhere: Rename `verify_cast` to `as` Follow-up to fc20e61e7249006247b43f84a3189d5a37fa103e.
2025-01-21 09:12:05 -05:00
auto& box = as<Layout::Box>(*m_current_node);
LibWeb: Rename LayoutState::NodeState => LayoutState::UsedValues This object contains all the CSS "used values" as seen during the layout process, so calling it "used values" seems appropriate. :^)
2022-07-16 23:43:48 +02:00
auto& box_state = m_layout_state.get(box);
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
m_inline_formatting_context.dimension_box_on_line(box, m_layout_mode);
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
skip_to_next();
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
auto item = Item {
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
.type = Item::Type::Element,
.node = &box,
.offset_in_node = 0,
.length_in_node = 0,
LibWeb: Add accessors for UsedValues::computed_{width,height} This is preparation for doing some more work when assigning to these values.
2022-07-17 17:59:02 +02:00
.width = box_state.content_width(),
LibWeb: Start making our layout system "transactional" This patch adds a map of Layout::Node to FormattingState::NodeState. Instead of updating layout nodes incrementally as layout progresses through the formatting contexts, all updates are now written to the corresponding NodeState instead. At the end of layout, FormattingState::commit() is called, which transfers all the values from the NodeState objects to the Node. This will soon allow us to perform completely non-destructive layouts which don't affect the tree. Note that there are many imperfections here, and still many places where we assign to the NodeState, but later read directly from the Node instead. I'm just committing at this stage to make subsequent diffs easier to understand.
2022-02-20 15:51:24 +01:00
.padding_start = box_state.padding_left,
.padding_end = box_state.padding_right,
.border_start = box_state.border_left,
.border_end = box_state.border_right,
.margin_start = box_state.margin_left,
.margin_end = box_state.margin_right,
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
};
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
add_extra_box_model_metrics_to_item(item, true, true);
return item;
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
}
LibWeb: Make whitespace collapsing stateless Previously, the whitespace collapsing code had a parameter telling it whether the previous text node ended in whitespace. This was not actually necessary, so let's get rid of it.
2022-03-27 21:14:10 +02:00
void InlineLevelIterator::enter_text_node(Layout::TextNode const& text_node)
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
{
bool do_collapse = true;
bool do_wrap_lines = true;
bool do_respect_linebreaks = false;
if (text_node.computed_values().white_space() == CSS::WhiteSpace::Nowrap) {
do_collapse = true;
do_wrap_lines = false;
do_respect_linebreaks = false;
} else if (text_node.computed_values().white_space() == CSS::WhiteSpace::Pre) {
do_collapse = false;
do_wrap_lines = false;
do_respect_linebreaks = true;
} else if (text_node.computed_values().white_space() == CSS::WhiteSpace::PreLine) {
do_collapse = true;
do_wrap_lines = true;
do_respect_linebreaks = true;
} else if (text_node.computed_values().white_space() == CSS::WhiteSpace::PreWrap) {
do_collapse = false;
do_wrap_lines = true;
do_respect_linebreaks = true;
}
LibWeb: Don't collapse TextNode if it's editable Fixes #16127
2022-11-26 00:14:36 +01:00
if (text_node.dom_node().is_editable() && !text_node.dom_node().is_uninteresting_whitespace_node())
do_collapse = false;
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
m_text_node_context = TextNodeContext {
.do_collapse = do_collapse,
.do_wrap_lines = do_wrap_lines,
.do_respect_linebreaks = do_respect_linebreaks,
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
.is_first_chunk = true,
.is_last_chunk = false,
LibWeb: Move initial creation of Unicode segmenters to the Document The expensive part of creating a segmenter is doing the locale and UCD data lookups at creation time. Instead of doing this once per text node, cache the segmenters on the document, and clone them as needed (cloning is much, much cheaper). On a profile loading Ladybird's GitHub repo, the following hot methods changed as follows: ChunkIterator ctor: 6.08% -> 0.21% Segmenter factory: 5.86% -> 0% Segmenter clone: N/A -> 0.09%
2024-09-22 10:03:23 -04:00
.chunk_iterator = TextNode::ChunkIterator { text_node, do_wrap_lines, do_respect_linebreaks },
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
};
LibWeb: Support inline-level padding and border properly Here's roughly how this works: - InlineLevelIterator keeps a nesting stack of inline-level nodes with box model metrics. - When entering a node with box model metrics, we add them to the current "leading metrics". - When exiting a node with box model metrics, we add them to the current "trailing metrics". - Pending leading metrics are consumed by the first fragment added to the line. - Pending trailing metrics are consumed by the last fragment added to the line. Like before, the position of a line box fragment is the top left of its content box. However, fragments are placed horizontally along the line with space inserted for padding and border. InlineNode::paint() now expands the content rect as appropriate when painting background and borders. Note that margins and margin collapsing is not yet implemented. This makes the eyes on ACID2 horizontally centered. :^)
2022-02-14 15:52:29 +01:00
}
void InlineLevelIterator::add_extra_box_model_metrics_to_item(Item& item, bool add_leading_metrics, bool add_trailing_metrics)
{
if (add_leading_metrics && m_extra_leading_metrics.has_value()) {
item.margin_start += m_extra_leading_metrics->margin;
item.border_start += m_extra_leading_metrics->border;
item.padding_start += m_extra_leading_metrics->padding;
m_extra_leading_metrics = {};
}
if (add_trailing_metrics && m_extra_trailing_metrics.has_value()) {
item.margin_end += m_extra_trailing_metrics->margin;
item.border_end += m_extra_trailing_metrics->border;
item.padding_end += m_extra_trailing_metrics->padding;
m_extra_trailing_metrics = {};
}
LibWeb: Add inline-level iterator that enumerates items for line layout This patch adds a new mechanism that allows InlineFormattingContext to build line boxes incrementally instead of all-in-one go. Incremental build will eventually allow much better support for CSS floating objects.
2022-01-17 15:07:19 +01:00
}
}
Reference in a new issue Copy permalink