Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-19 23:53:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibWeb/Layout/LineBoxFragment.cpp

164 lines
5 KiB
C++
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 13:19:50 +02:00
* Copyright (c) 2018-2023, Andreas Kling <andreas@ladybird.org>
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*/
LibGfx: Remove Utf8View.h dependency from Font.h
2020-02-15 00:27:50 +01:00
#include <AK/Utf8View.h>
LibWeb: Use DOM Selection instead of ad-hoc layout tree selection Before this patch, we were expressing the current selection as a range between two points in the layout tree. This was a made-up concept I called LayoutRange (2x LayoutPosition) and as it turns out, we don't actually need it! Instead, we can just use the Selection API from the Selection API spec. This API expresses selection in terms of the DOM, and we already had many of the building blocks implemented. To ensure that selections get visually updated when the underlying Range of an active Selection is programmatically manipulated, Range now has an "associated Selection". If a range is updated while associated with a selection, we recompute layout tree selection states and repaint the page to make it user-visible.
2023-01-11 19:48:53 +01:00
#include <LibWeb/DOM/Range.h>
LibWeb: Rename FormattingState to LayoutState This seems a bit more descriptive (and also a bit shorter).
2022-07-16 23:30:32 +02:00
#include <LibWeb/Layout/LayoutState.h>
LibWeb: Allow layout nodes to have multiple paintables CSS fragmentation implies 1:N relationship between layout nodes and paintables. This change is a preparation for implementation of inline fragmentation where InlinePaintable will be replaced with PaintableWithLines corresponding to each line.
2024-10-14 16:07:56 +02:00
#include <LibWeb/Layout/TextNode.h>
LibWeb: Rename Layout::InitialContainingBlock to Layout::Viewport The name "initial containing block" was wrong for this, as it doesn't correspond to the HTML element, and that's specifically what it's supposed to do! :^)
2023-02-25 11:04:29 +01:00
#include <LibWeb/Layout/Viewport.h>
LibWeb: Teach line layout to collapse whitespace across fragments This kind of HTML now produces a single piece of whitespace: <span> </span> <span> </span> <span> </span> We achieve this by checking if the last fragment on the last line ends in whitespace. If so, we either don't add a fragment at all (for the current chunk) or we simply skip over all whitespace at the head of the current chunk (instead of collapsing it to a single ' '.)
2020-06-13 14:59:17 +02:00
#include <ctype.h>
LibHTML: Rewrite inline and text layout Inline layout is now done by LayoutBlock. Blocks with inline children will split them into line boxes during layout. A LayoutBlock can have zero or more LineBox objects. Each LineBox represents one visual line. A LineBox can have any number of LineBoxFragment children. A fragment is an offset+length into a specific LayoutNode. To paint a LayoutBlock with inline children, we walk its line boxes, and walk their fragments, painting each fragment at a time by calling LineBoxFragment::render(), which in turn calls the LayoutNode via LayoutText::render_fragment(). Hit testing works similarly. This is very incomplete and has many bugs, but should make it easier for us to move forward with this code.
2019-10-03 15:20:13 +02:00
LibWeb: Rename LayoutNode classes and move them into Layout namespace Bring the names of various boxes closer to spec language. This should hopefully make things easier to understand and hack on. :^) Some notable changes: - LayoutNode -> Layout::Node - LayoutBox -> Layout::Box - LayoutBlock -> Layout::BlockBox - LayoutReplaced -> Layout::ReplacedBox - LayoutDocument -> Layout::InitialContainingBlockBox - LayoutText -> Layout::TextNode - LayoutInline -> Layout::InlineNode Note that this is not strictly a "box tree" as we also hang inline/text nodes in the same tree, and they don't generate boxes. (Instead, they contribute line box fragments to their containing block!)
2020-11-22 15:53:01 +01:00
namespace Web::Layout {
LibWeb: Move everything into the Web namespace
2020-03-07 10:27:02 +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
LineBoxFragment::LineBoxFragment(Node const& layout_node, int start, int length, CSSPixelPoint offset, CSSPixelSize size, CSSPixels border_box_top, CSS::Direction direction, RefPtr<Gfx::GlyphRun> glyph_run)
: m_layout_node(layout_node)
, m_start(start)
, m_length(length)
, m_offset(offset)
, m_size(size)
, m_border_box_top(border_box_top)
, m_direction(direction)
, m_glyph_run(move(glyph_run))
{
if (m_glyph_run) {
m_current_insert_direction = resolve_glyph_run_direction(m_glyph_run->text_type());
if (m_direction == CSS::Direction::Rtl)
m_insert_position = m_size.width().to_float();
}
}
LibWeb: Teach line layout to collapse whitespace across fragments This kind of HTML now produces a single piece of whitespace: <span> </span> <span> </span> <span> </span> We achieve this by checking if the last fragment on the last line ends in whitespace. If so, we either don't add a fragment at all (for the current chunk) or we simply skip over all whitespace at the head of the current chunk (instead of collapsing it to a single ' '.)
2020-06-13 14:59:17 +02:00
bool LineBoxFragment::ends_in_whitespace() const
{
auto text = this->text();
if (text.is_empty())
return false;
return isspace(text[text.length() - 1]);
}
LibHTML: Implement "text-align: justify" In order for this to work nicely, I made the line box classes use float instead of int for its geometry information. Justification works by distributing all of the whitespace on the line (including the trailing whitespace before the line break) evenly across the spaces in-between words. We should probably use floating point (or maybe fixed point?) for all the layout metrics stuff. But one thing at a time. :^)
2019-10-20 12:30:25 +02:00
bool LineBoxFragment::is_justifiable_whitespace() const
LibHTML: Remove trailing whitespace in line boxes After the splitting-into-lines pass, remove any trailing whitespace from all of a block's line boxes. This improves the appearance of text-align: justify/right :^)
2019-10-20 17:18:28 +02:00
{
return text() == " ";
}
StringView LineBoxFragment::text() const
LibHTML: Implement "text-align: justify" In order for this to work nicely, I made the line box classes use float instead of int for its geometry information. Justification works by distributing all of the whitespace on the line (including the trailing whitespace before the line break) evenly across the spaces in-between words. We should probably use floating point (or maybe fixed point?) for all the layout metrics stuff. But one thing at a time. :^)
2019-10-20 12:30:25 +02:00
{
LibWeb: Rename LayoutNode classes and move them into Layout namespace Bring the names of various boxes closer to spec language. This should hopefully make things easier to understand and hack on. :^) Some notable changes: - LayoutNode -> Layout::Node - LayoutBox -> Layout::Box - LayoutBlock -> Layout::BlockBox - LayoutReplaced -> Layout::ReplacedBox - LayoutDocument -> Layout::InitialContainingBlockBox - LayoutText -> Layout::TextNode - LayoutInline -> Layout::InlineNode Note that this is not strictly a "box tree" as we also hang inline/text nodes in the same tree, and they don't generate boxes. (Instead, they contribute line box fragments to their containing block!)
2020-11-22 15:53:01 +01:00
if (!is<TextNode>(layout_node()))
LibHTML: Remove trailing whitespace in line boxes After the splitting-into-lines pass, remove any trailing whitespace from all of a block's line boxes. This improves the appearance of text-align: justify/right :^)
2019-10-20 17:18:28 +02:00
return {};
LibWeb: Port Layout::TextNode from DeprecatedString
2023-11-21 10:56:29 +13:00
return verify_cast<TextNode>(layout_node()).text_for_rendering().bytes_as_string_view().substring_view(m_start, m_length);
LibHTML: Implement "text-align: justify" In order for this to work nicely, I made the line box classes use float instead of int for its geometry information. Justification works by distributing all of the whitespace on the line (including the trailing whitespace before the line break) evenly across the spaces in-between words. We should probably use floating point (or maybe fixed point?) for all the layout metrics stuff. But one thing at a time. :^)
2019-10-20 12:30:25 +02:00
}
LibHTML: Build some foundation for text selection Add LayoutPosition and LayoutRange classes. The layout tree root node now has a selection() LayoutRange. It's essentially a start and end LayoutPosition. A LayoutPosition is a LayoutNode, and an optional index into that node. The index is only relevant for text nodes, where it's the character index into the rendered text. HtmlView now updates the selection start/end of the LayoutDocument when clicking and dragging with the left mouse button. We don't paint the selection yet, and there's no way to copy what's selected. It only exists as a LayoutRange.
2019-11-05 22:13:26 +01:00
LibWeb: Convert Paintable coordinates to new pixel units This fixes a few sizing issues too. The page size is now correct in most cases! \o/ We get to remove some of the `to_type<>()` shenanigans, though it reappears in some other places.
2022-10-31 19:46:55 +00:00
CSSPixelRect const LineBoxFragment::absolute_rect() const
LibWeb: Rework the layout engine to use relative offsets The box tree and line boxes now all store a relative offset from their containing block, instead of an absolute (document-relative) position. This removes a huge pain point from the layout system which was having to adjust offsets recursively when something moved. It also makes some layout logic significantly simpler. Every box can still find its absolute position by walking its chain of containing blocks and accumulating the translation from the root. This is currently what we do both for rendering and hit testing.
2020-06-10 10:42:29 +02:00
{
LibWeb: Convert Paintable coordinates to new pixel units This fixes a few sizing issues too. The page size is now correct in most cases! \o/ We get to remove some of the `to_type<>()` shenanigans, though it reappears in some other places.
2022-10-31 19:46:55 +00:00
CSSPixelRect rect { {}, size() };
LibWeb/Layout: Rename Box::{paint => paintable}_box() It returns a PaintableBox, not a 'PaintBox'.
2023-04-20 16:00:42 +01:00
rect.set_location(m_layout_node->containing_block()->paintable_box()->absolute_position());
LibGfx: Unify Rect, Point, and Size This commit unifies methods and method/param names between the above classes, as well as adds [[nodiscard]] and ALWAYS_INLINE where appropriate. It also renamed the various move_by methods to translate_by, as that more closely matches the transformation terminology.
2021-04-12 11:47:09 -07:00
rect.translate_by(offset());
LibWeb: Rework the layout engine to use relative offsets The box tree and line boxes now all store a relative offset from their containing block, instead of an absolute (document-relative) position. This removes a huge pain point from the layout system which was having to adjust offsets recursively when something moved. It also makes some layout logic significantly simpler. Every box can still find its absolute position by walking its chain of containing blocks and accumulating the translation from the root. This is currently what we do both for rendering and hit testing.
2020-06-10 10:42:29 +02:00
return rect;
}
LibWeb: Consider margins of atomic inlines in layout According to CSS Inline Layout Module Level 3 § 2.2 Step 1. atomic inlines should be layed out in a line box based on their margin box. However, up until this patch we were unconditionally considering only the border box during line box height calculation. This made us essentially drop all vertical margins for atomic inlines.
2023-03-14 10:28:01 +01:00
bool LineBoxFragment::is_atomic_inline() const
{
return layout_node().is_replaced_box() || (layout_node().display().is_inline_outside() && !layout_node().display().is_flow_inside());
}
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
CSS::Direction LineBoxFragment::resolve_glyph_run_direction(Gfx::GlyphRun::TextType text_type) const
{
switch (text_type) {
case Gfx::GlyphRun::TextType::Common:
case Gfx::GlyphRun::TextType::ContextDependent:
case Gfx::GlyphRun::TextType::EndPadding:
return m_direction;
case Gfx::GlyphRun::TextType::Ltr:
return CSS::Direction::Ltr;
case Gfx::GlyphRun::TextType::Rtl:
return CSS::Direction::Rtl;
default:
VERIFY_NOT_REACHED();
}
}
void LineBoxFragment::append_glyph_run(RefPtr<Gfx::GlyphRun> const& glyph_run, CSSPixels run_width)
{
switch (m_direction) {
case CSS::Direction::Ltr:
append_glyph_run_ltr(glyph_run, run_width);
break;
case CSS::Direction::Rtl:
append_glyph_run_rtl(glyph_run, run_width);
break;
}
}
void LineBoxFragment::append_glyph_run_ltr(RefPtr<Gfx::GlyphRun> const& glyph_run, CSSPixels run_width)
{
auto run_direction = resolve_glyph_run_direction(glyph_run->text_type());
if (m_current_insert_direction != run_direction) {
if (run_direction == CSS::Direction::Rtl)
m_insert_position = width().to_float();
m_current_insert_direction = run_direction;
}
switch (run_direction) {
case CSS::Direction::Ltr:
for (auto& glyph : glyph_run->glyphs()) {
LibGfx+LibWeb: Remove DrawEmoji variant in GlyphRun It was needed to support bitmap emoji rendering but no longer used after switching to Skia+HarfBuzz for text rendering.
2024-09-06 01:19:53 +02:00
glyph.position.translate_by(width().to_float(), 0);
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
m_glyph_run->append(glyph);
}
break;
case CSS::Direction::Rtl:
for (auto& glyph : m_glyph_run->glyphs()) {
LibGfx+LibWeb: Remove DrawEmoji variant in GlyphRun It was needed to support bitmap emoji rendering but no longer used after switching to Skia+HarfBuzz for text rendering.
2024-09-06 01:19:53 +02:00
if (glyph.position.x() >= m_insert_position)
glyph.position.translate_by(run_width.to_float(), 0);
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
}
for (auto& glyph : glyph_run->glyphs()) {
LibGfx+LibWeb: Remove DrawEmoji variant in GlyphRun It was needed to support bitmap emoji rendering but no longer used after switching to Skia+HarfBuzz for text rendering.
2024-09-06 01:19:53 +02:00
glyph.position.translate_by(m_insert_position, 0);
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
m_glyph_run->append(glyph);
}
break;
}
m_size.set_width(width() + run_width);
}
void LineBoxFragment::append_glyph_run_rtl(RefPtr<Gfx::GlyphRun> const& glyph_run, CSSPixels run_width)
{
auto run_direction = resolve_glyph_run_direction(glyph_run->text_type());
if (m_current_insert_direction != run_direction) {
if (run_direction == CSS::Direction::Ltr)
m_insert_position = 0;
m_current_insert_direction = run_direction;
}
switch (run_direction) {
case CSS::Direction::Ltr:
for (auto& glyph : m_glyph_run->glyphs()) {
LibGfx+LibWeb: Remove DrawEmoji variant in GlyphRun It was needed to support bitmap emoji rendering but no longer used after switching to Skia+HarfBuzz for text rendering.
2024-09-06 01:19:53 +02:00
if (glyph.position.x() >= m_insert_position)
glyph.position.translate_by(run_width.to_float(), 0);
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
}
for (auto& glyph : glyph_run->glyphs()) {
LibGfx+LibWeb: Remove DrawEmoji variant in GlyphRun It was needed to support bitmap emoji rendering but no longer used after switching to Skia+HarfBuzz for text rendering.
2024-09-06 01:19:53 +02:00
glyph.position.translate_by(m_insert_position, 0);
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
m_glyph_run->append(glyph);
}
break;
case CSS::Direction::Rtl:
if (glyph_run->text_type() != Gfx::GlyphRun::TextType::EndPadding) {
for (auto& glyph : m_glyph_run->glyphs()) {
LibGfx+LibWeb: Remove DrawEmoji variant in GlyphRun It was needed to support bitmap emoji rendering but no longer used after switching to Skia+HarfBuzz for text rendering.
2024-09-06 01:19:53 +02:00
glyph.position.translate_by(run_width.to_float(), 0);
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
}
}
for (auto& glyph : glyph_run->glyphs()) {
m_glyph_run->append(glyph);
}
break;
}
m_size.set_width(width() + run_width);
m_insert_position += run_width.to_float();
}
LibWeb: Move everything into the Web namespace
2020-03-07 10:27:02 +01:00
}
Reference in a new issue Copy permalink