Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-04 07:10:57 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibGfx/TextLayout.cpp

259 lines
8.4 KiB
C++
Raw Normal View History

Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2021, sin-ack <sin-ack@protonmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include "TextLayout.h"
LibGfx: Decouple glyph positions calculation from draw_text_run() This change separates a part of the `draw_text_run()` function, which is responsible for calculating the positions for glyphs that need to be painted, into a separate function called `get_glyph_run()`. It is a part of the preparation for text run painting using OpenGL, where we can't immediately blit glyph bitmaps but instead need to prepare a sequence of quads for them in advance.
2023-11-05 00:17:04 +01:00
#include "Font/Emoji.h"
#include <AK/Debug.h>
#include <LibUnicode/CharacterTypes.h>
#include <LibUnicode/Emoji.h>
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
namespace Gfx {
LibGfx: Make TextLayout algorithm whitespace-aware This converts the TextLayout algorithm from handling just words to handling blocks of strings. With this model, whitespace is preserved and inserted as-is, rather than being eaten and then replaced with a single space (or none, if the whitespace was at the start of the word). Closes #9032.
2021-07-27 19:50:11 +00:00
enum class BlockType {
Newline,
Whitespace,
Word
};
struct Block {
BlockType type;
Utf8View characters;
};
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
LibGfx: Make text painting better at aligning vector fonts vertically This is achieved by simplifying the logic in TextLayout. We get rid of all the various ways that the layout bounding rect can get cropped. Then we make sure to use the right pixel metrics. Finally we use the font's own line gap metrics instead of hard-coding 4. The end result is that text painted with vector fonts now gets pretty reasonable vertical alignment in most cases.
2023-01-06 11:55:23 +01:00
FloatRect TextLayout::bounding_rect(TextWrapping wrapping) const
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
{
LibGfx: Make text painting better at aligning vector fonts vertically This is achieved by simplifying the logic in TextLayout. We get rid of all the various ways that the layout bounding rect can get cropped. Then we make sure to use the right pixel metrics. Finally we use the font's own line gap metrics instead of hard-coding 4. The end result is that text painted with vector fonts now gets pretty reasonable vertical alignment in most cases.
2023-01-06 11:55:23 +01:00
auto lines = wrap_lines(TextElision::None, wrapping);
if (lines.is_empty()) {
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
return {};
}
LibGfx: Avoid rounding/truncating glyph positions till blitting This keeps some overloads that accept ints to avoid adding calls to .to_type<float>() all over the place.
2023-01-01 19:42:00 +01:00
FloatRect bounding_rect = {
LibGfx: Make text painting better at aligning vector fonts vertically This is achieved by simplifying the logic in TextLayout. We get rid of all the various ways that the layout bounding rect can get cropped. Then we make sure to use the right pixel metrics. Finally we use the font's own line gap metrics instead of hard-coding 4. The end result is that text painted with vector fonts now gets pretty reasonable vertical alignment in most cases.
2023-01-06 11:55:23 +01:00
0, 0, 0, (static_cast<float>(lines.size()) * (m_font_metrics.ascent + m_font_metrics.descent + m_font_metrics.line_gap)) - m_font_metrics.line_gap
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
};
for (auto& line : lines) {
LibGfx: Slim down Gfx::TextLayout API by removing unused accessors Also store the Font as a const reference instead of a raw pointer, since we don't allow a null Font here.
2023-01-05 20:41:19 +01:00
auto line_width = m_font.width(line);
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
if (line_width > bounding_rect.width())
bounding_rect.set_width(line_width);
}
return bounding_rect;
}
LibGfx: Make text painting better at aligning vector fonts vertically This is achieved by simplifying the logic in TextLayout. We get rid of all the various ways that the layout bounding rect can get cropped. Then we make sure to use the right pixel metrics. Finally we use the font's own line gap metrics instead of hard-coding 4. The end result is that text painted with vector fonts now gets pretty reasonable vertical alignment in most cases.
2023-01-06 11:55:23 +01:00
Vector<DeprecatedString, 32> TextLayout::wrap_lines(TextElision elision, TextWrapping wrapping) const
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
{
LibGfx: Make TextLayout algorithm whitespace-aware This converts the TextLayout algorithm from handling just words to handling blocks of strings. With this model, whitespace is preserved and inserted as-is, rather than being eaten and then replaced with a single space (or none, if the whitespace was at the start of the word). Closes #9032.
2021-07-27 19:50:11 +00:00
Vector<Block> blocks;
Optional<BlockType> current_block_type;
LibGfx: Hotfix a -Wmaybe-uninitialized failure on the build bots
2021-07-27 22:08:46 +02:00
size_t block_start_offset = 0;
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
LibGfx: Make TextLayout algorithm whitespace-aware This converts the TextLayout algorithm from handling just words to handling blocks of strings. With this model, whitespace is preserved and inserted as-is, rather than being eaten and then replaced with a single space (or none, if the whitespace was at the start of the word). Closes #9032.
2021-07-27 19:50:11 +00:00
size_t offset = 0;
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
for (auto it = m_text.begin(); !it.done(); ++it) {
LibGfx: Make TextLayout algorithm whitespace-aware This converts the TextLayout algorithm from handling just words to handling blocks of strings. With this model, whitespace is preserved and inserted as-is, rather than being eaten and then replaced with a single space (or none, if the whitespace was at the start of the word). Closes #9032.
2021-07-27 19:50:11 +00:00
offset = m_text.iterator_offset(it);
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
switch (*it) {
case '\t':
case ' ': {
LibGfx: Make TextLayout algorithm whitespace-aware This converts the TextLayout algorithm from handling just words to handling blocks of strings. With this model, whitespace is preserved and inserted as-is, rather than being eaten and then replaced with a single space (or none, if the whitespace was at the start of the word). Closes #9032.
2021-07-27 19:50:11 +00:00
if (current_block_type.has_value() && current_block_type.value() != BlockType::Whitespace) {
blocks.append({
current_block_type.value(),
m_text.substring_view(block_start_offset, offset - block_start_offset),
});
current_block_type.clear();
}
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
LibGfx: Make TextLayout algorithm whitespace-aware This converts the TextLayout algorithm from handling just words to handling blocks of strings. With this model, whitespace is preserved and inserted as-is, rather than being eaten and then replaced with a single space (or none, if the whitespace was at the start of the word). Closes #9032.
2021-07-27 19:50:11 +00:00
if (!current_block_type.has_value()) {
current_block_type = BlockType::Whitespace;
block_start_offset = offset;
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
}
continue;
}
LibGfx: Make TextLayout algorithm whitespace-aware This converts the TextLayout algorithm from handling just words to handling blocks of strings. With this model, whitespace is preserved and inserted as-is, rather than being eaten and then replaced with a single space (or none, if the whitespace was at the start of the word). Closes #9032.
2021-07-27 19:50:11 +00:00
case '\n':
case '\r': {
if (current_block_type.has_value()) {
blocks.append({
current_block_type.value(),
m_text.substring_view(block_start_offset, offset - block_start_offset),
});
current_block_type.clear();
}
blocks.append({ BlockType::Newline, Utf8View {} });
continue;
}
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
default: {
LibGfx: Make TextLayout algorithm whitespace-aware This converts the TextLayout algorithm from handling just words to handling blocks of strings. With this model, whitespace is preserved and inserted as-is, rather than being eaten and then replaced with a single space (or none, if the whitespace was at the start of the word). Closes #9032.
2021-07-27 19:50:11 +00:00
if (current_block_type.has_value() && current_block_type.value() != BlockType::Word) {
blocks.append({
current_block_type.value(),
m_text.substring_view(block_start_offset, offset - block_start_offset),
});
current_block_type.clear();
}
if (!current_block_type.has_value()) {
current_block_type = BlockType::Word;
block_start_offset = offset;
}
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
}
}
}
LibGfx: Make TextLayout algorithm whitespace-aware This converts the TextLayout algorithm from handling just words to handling blocks of strings. With this model, whitespace is preserved and inserted as-is, rather than being eaten and then replaced with a single space (or none, if the whitespace was at the start of the word). Closes #9032.
2021-07-27 19:50:11 +00:00
if (current_block_type.has_value()) {
blocks.append({
current_block_type.value(),
m_text.substring_view(block_start_offset, m_text.byte_length() - block_start_offset),
});
}
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
Vector<DeprecatedString> lines;
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
StringBuilder builder;
LibGfx: Avoid rounding/truncating glyph positions till blitting This keeps some overloads that accept ints to avoid adding calls to .to_type<float>() all over the place.
2023-01-01 19:42:00 +01:00
float line_width = 0;
LibGfx: Take the glyph spacing into account when building a line Without this, a word might be added to a line despite going outside the rect, due to the glyph spacing between blocks not being considered.
2021-07-27 21:24:47 +00:00
size_t current_block = 0;
LibGfx: Make TextLayout algorithm whitespace-aware This converts the TextLayout algorithm from handling just words to handling blocks of strings. With this model, whitespace is preserved and inserted as-is, rather than being eaten and then replaced with a single space (or none, if the whitespace was at the start of the word). Closes #9032.
2021-07-27 19:50:11 +00:00
for (Block& block : blocks) {
switch (block.type) {
case BlockType::Newline: {
Everywhere: Rename to_{string => deprecated_string}() where applicable This will make it easier to support both string types at the same time while we convert code, and tracking down remaining uses. One big exception is Value::to_string() in LibJS, where the name is dictated by the ToString AO.
2022-12-06 01:12:49 +00:00
lines.append(builder.to_deprecated_string());
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
builder.clear();
line_width = 0;
LibGfx: Take the glyph spacing into account when building a line Without this, a word might be added to a line despite going outside the rect, due to the glyph spacing between blocks not being considered.
2021-07-27 21:24:47 +00:00
current_block++;
LibGfx: Make TextLayout algorithm whitespace-aware This converts the TextLayout algorithm from handling just words to handling blocks of strings. With this model, whitespace is preserved and inserted as-is, rather than being eaten and then replaced with a single space (or none, if the whitespace was at the start of the word). Closes #9032.
2021-07-27 19:50:11 +00:00
continue;
}
case BlockType::Whitespace:
case BlockType::Word: {
LibGfx: Slim down Gfx::TextLayout API by removing unused accessors Also store the Font as a const reference instead of a raw pointer, since we don't allow a null Font here.
2023-01-05 20:41:19 +01:00
float block_width = m_font.width(block.characters);
LibGfx: Take the glyph spacing into account when building a line Without this, a word might be added to a line despite going outside the rect, due to the glyph spacing between blocks not being considered.
2021-07-27 21:24:47 +00:00
// FIXME: This should look at the specific advance amount of the
// last character, but we don't support that yet.
if (current_block != blocks.size() - 1) {
LibGfx: Slim down Gfx::TextLayout API by removing unused accessors Also store the Font as a const reference instead of a raw pointer, since we don't allow a null Font here.
2023-01-05 20:41:19 +01:00
block_width += m_font.glyph_spacing();
LibGfx: Take the glyph spacing into account when building a line Without this, a word might be added to a line despite going outside the rect, due to the glyph spacing between blocks not being considered.
2021-07-27 21:24:47 +00:00
}
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
LibGfx: Avoid rounding/truncating glyph positions till blitting This keeps some overloads that accept ints to avoid adding calls to .to_type<float>() all over the place.
2023-01-01 19:42:00 +01:00
if (wrapping == TextWrapping::Wrap && line_width + block_width > m_rect.width()) {
Everywhere: Rename to_{string => deprecated_string}() where applicable This will make it easier to support both string types at the same time while we convert code, and tracking down remaining uses. One big exception is Value::to_string() in LibJS, where the name is dictated by the ToString AO.
2022-12-06 01:12:49 +00:00
lines.append(builder.to_deprecated_string());
LibGfx: Remove extra space considered during wrapping This was previously required because the whitespace was consumed and manually added back after the fact, but now that we preserve whitespace, this breaks wrapping of text with whitespace after it.
2021-07-27 21:11:05 +00:00
builder.clear();
line_width = 0;
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
}
LibGfx: Make TextLayout algorithm whitespace-aware This converts the TextLayout algorithm from handling just words to handling blocks of strings. With this model, whitespace is preserved and inserted as-is, rather than being eaten and then replaced with a single space (or none, if the whitespace was at the start of the word). Closes #9032.
2021-07-27 19:50:11 +00:00
builder.append(block.characters.as_string());
line_width += block_width;
LibGfx: Take the glyph spacing into account when building a line Without this, a word might be added to a line despite going outside the rect, due to the glyph spacing between blocks not being considered.
2021-07-27 21:24:47 +00:00
current_block++;
LibGfx: Make TextLayout algorithm whitespace-aware This converts the TextLayout algorithm from handling just words to handling blocks of strings. With this model, whitespace is preserved and inserted as-is, rather than being eaten and then replaced with a single space (or none, if the whitespace was at the start of the word). Closes #9032.
2021-07-27 19:50:11 +00:00
}
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
}
}
LibGfx: Make text painting better at aligning vector fonts vertically This is achieved by simplifying the logic in TextLayout. We get rid of all the various ways that the layout bounding rect can get cropped. Then we make sure to use the right pixel metrics. Finally we use the font's own line gap metrics instead of hard-coding 4. The end result is that text painted with vector fonts now gets pretty reasonable vertical alignment in most cases.
2023-01-06 11:55:23 +01:00
auto last_line = builder.to_deprecated_string();
if (!last_line.is_empty())
lines.append(last_line);
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
switch (elision) {
case TextElision::None:
break;
case TextElision::Right: {
LibGfx: Make text painting better at aligning vector fonts vertically This is achieved by simplifying the logic in TextLayout. We get rid of all the various ways that the layout bounding rect can get cropped. Then we make sure to use the right pixel metrics. Finally we use the font's own line gap metrics instead of hard-coding 4. The end result is that text painted with vector fonts now gets pretty reasonable vertical alignment in most cases.
2023-01-06 11:55:23 +01:00
lines.at(lines.size() - 1) = elide_text_from_right(Utf8View { lines.at(lines.size() - 1) });
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
break;
}
}
return lines;
}
LibGfx: Make text painting better at aligning vector fonts vertically This is achieved by simplifying the logic in TextLayout. We get rid of all the various ways that the layout bounding rect can get cropped. Then we make sure to use the right pixel metrics. Finally we use the font's own line gap metrics instead of hard-coding 4. The end result is that text painted with vector fonts now gets pretty reasonable vertical alignment in most cases.
2023-01-06 11:55:23 +01:00
DeprecatedString TextLayout::elide_text_from_right(Utf8View text) const
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
{
LibGfx: Slim down Gfx::TextLayout API by removing unused accessors Also store the Font as a const reference instead of a raw pointer, since we don't allow a null Font here.
2023-01-05 20:41:19 +01:00
float text_width = m_font.width(text);
LibGfx: Make text painting better at aligning vector fonts vertically This is achieved by simplifying the logic in TextLayout. We get rid of all the various ways that the layout bounding rect can get cropped. Then we make sure to use the right pixel metrics. Finally we use the font's own line gap metrics instead of hard-coding 4. The end result is that text painted with vector fonts now gets pretty reasonable vertical alignment in most cases.
2023-01-06 11:55:23 +01:00
if (text_width > static_cast<float>(m_rect.width())) {
LibGfx: Slim down Gfx::TextLayout API by removing unused accessors Also store the Font as a const reference instead of a raw pointer, since we don't allow a null Font here.
2023-01-05 20:41:19 +01:00
float ellipsis_width = m_font.width("..."sv);
LibGfx: Avoid rounding/truncating glyph positions till blitting This keeps some overloads that accept ints to avoid adding calls to .to_type<float>() all over the place.
2023-01-01 19:42:00 +01:00
float current_width = ellipsis_width;
LibGfx: Slim down Gfx::TextLayout API by removing unused accessors Also store the Font as a const reference instead of a raw pointer, since we don't allow a null Font here.
2023-01-05 20:41:19 +01:00
size_t glyph_spacing = m_font.glyph_spacing();
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
// FIXME: This code will break when the font has glyphs with advance
// amounts different from the actual width of the glyph
// (which is the case with many TrueType fonts).
if (ellipsis_width < text_width) {
size_t offset = 0;
for (auto it = text.begin(); !it.done(); ++it) {
LibGfx: Consider multi-code point glyphs when computing text width Currently, we compute the width of text one code point at a time. This ignores grapheme clusters (emoji in particular). One effect of this is when highlighting a multi-code point emoji. We will errantly increase the highlight rect to the sum of all code point widths, rather than just the width of the resolved emoji bitmap.
2023-02-20 13:15:06 -05:00
auto glyph_width = m_font.glyph_or_emoji_width(it);
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
// NOTE: Glyph spacing should not be added after the last glyph on the line,
// but since we are here because the last glyph does not actually fit on the line,
// we don't have to worry about spacing.
LibGfx: Avoid rounding/truncating glyph positions till blitting This keeps some overloads that accept ints to avoid adding calls to .to_type<float>() all over the place.
2023-01-01 19:42:00 +01:00
auto width_with_this_glyph_included = current_width + glyph_width + glyph_spacing;
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
if (width_with_this_glyph_included > m_rect.width())
break;
current_width += glyph_width + glyph_spacing;
offset = text.iterator_offset(it);
}
StringBuilder builder;
builder.append(text.substring_view(0, offset).as_string());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
builder.append("..."sv);
Everywhere: Rename to_{string => deprecated_string}() where applicable This will make it easier to support both string types at the same time while we convert code, and tracking down remaining uses. One big exception is Value::to_string() in LibJS, where the name is dictated by the ToString AO.
2022-12-06 01:12:49 +00:00
return builder.to_deprecated_string();
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
}
}
return text.as_string();
}
LibGfx: Decouple glyph positions calculation from draw_text_run() This change separates a part of the `draw_text_run()` function, which is responsible for calculating the positions for glyphs that need to be painted, into a separate function called `get_glyph_run()`. It is a part of the preparation for text run painting using OpenGL, where we can't immediately blit glyph bitmaps but instead need to prepare a sequence of quads for them in advance.
2023-11-05 00:17:04 +01:00
DrawGlyphOrEmoji prepare_draw_glyph_or_emoji(FloatPoint point, Utf8CodePointIterator& it, Font const& font)
{
u32 code_point = *it;
auto next_code_point = it.peek(1);
ScopeGuard consume_variation_selector = [&, initial_it = it] {
static auto const variation_selector = Unicode::property_from_string("Variation_Selector"sv);
if (!variation_selector.has_value())
return;
// If we advanced the iterator to consume an emoji sequence, don't look for another variation selector.
if (initial_it != it)
return;
// Otherwise, discard one code point if it's a variation selector.
if (next_code_point.has_value() && Unicode::code_point_has_property(*next_code_point, *variation_selector))
++it;
};
// NOTE: We don't check for emoji
auto font_contains_glyph = font.contains_glyph(code_point);
auto check_for_emoji = !font.has_color_bitmaps() && Unicode::could_be_start_of_emoji_sequence(it, font_contains_glyph ? Unicode::SequenceType::EmojiPresentation : Unicode::SequenceType::Any);
// If the font contains the glyph, and we know it's not the start of an emoji, draw a text glyph.
if (font_contains_glyph && !check_for_emoji) {
return DrawGlyph {
.position = point,
.code_point = code_point,
LibGfx+LibAccelGfx+LibWeb: Use RefPtr for font in DrawGlyphOrEmoji
2023-12-09 23:14:07 +01:00
.font = font,
LibGfx: Decouple glyph positions calculation from draw_text_run() This change separates a part of the `draw_text_run()` function, which is responsible for calculating the positions for glyphs that need to be painted, into a separate function called `get_glyph_run()`. It is a part of the preparation for text run painting using OpenGL, where we can't immediately blit glyph bitmaps but instead need to prepare a sequence of quads for them in advance.
2023-11-05 00:17:04 +01:00
};
}
// If we didn't find a text glyph, or have an emoji variation selector or regional indicator, try to draw an emoji glyph.
if (auto const* emoji = Emoji::emoji_for_code_point_iterator(it)) {
return DrawEmoji {
LibGfx+LibWeb: Calculate and save glyph positions during layout Previously, we determined the positions of glyphs for each text run at the time of painting, which constituted a significant portion of the painting process according to profiles. However, since we already go through each glyph to figure out the width of each fragment during layout, we can simultaneously gather data about the position of each glyph in the layout phase and utilize this information in the painting phase. I had to update expectations for a couple of reference tests. These updates are due to the fact that we now measure glyph positions during layout using a 1x font, and then linearly scale each glyph's position to device pixels during painting. This approach should be acceptable, considering we measure a fragment's width and height with an unscaled font during layout.
2023-12-02 18:38:05 +01:00
.position = point,
LibGfx: Decouple glyph positions calculation from draw_text_run() This change separates a part of the `draw_text_run()` function, which is responsible for calculating the positions for glyphs that need to be painted, into a separate function called `get_glyph_run()`. It is a part of the preparation for text run painting using OpenGL, where we can't immediately blit glyph bitmaps but instead need to prepare a sequence of quads for them in advance.
2023-11-05 00:17:04 +01:00
.emoji = emoji,
LibGfx+LibAccelGfx+LibWeb: Use RefPtr for font in DrawGlyphOrEmoji
2023-12-09 23:14:07 +01:00
.font = font,
LibGfx: Decouple glyph positions calculation from draw_text_run() This change separates a part of the `draw_text_run()` function, which is responsible for calculating the positions for glyphs that need to be painted, into a separate function called `get_glyph_run()`. It is a part of the preparation for text run painting using OpenGL, where we can't immediately blit glyph bitmaps but instead need to prepare a sequence of quads for them in advance.
2023-11-05 00:17:04 +01:00
};
}
// If that failed, but we have a text glyph fallback, draw that.
if (font_contains_glyph) {
return DrawGlyph {
.position = point,
.code_point = code_point,
LibGfx+LibAccelGfx+LibWeb: Use RefPtr for font in DrawGlyphOrEmoji
2023-12-09 23:14:07 +01:00
.font = font,
LibGfx: Decouple glyph positions calculation from draw_text_run() This change separates a part of the `draw_text_run()` function, which is responsible for calculating the positions for glyphs that need to be painted, into a separate function called `get_glyph_run()`. It is a part of the preparation for text run painting using OpenGL, where we can't immediately blit glyph bitmaps but instead need to prepare a sequence of quads for them in advance.
2023-11-05 00:17:04 +01:00
};
}
// No suitable glyph found, draw a replacement character.
dbgln_if(EMOJI_DEBUG, "Failed to find a glyph or emoji for code_point {}", code_point);
return DrawGlyph {
.position = point,
.code_point = 0xFFFD,
LibGfx+LibAccelGfx+LibWeb: Use RefPtr for font in DrawGlyphOrEmoji
2023-12-09 23:14:07 +01:00
.font = font,
LibGfx: Decouple glyph positions calculation from draw_text_run() This change separates a part of the `draw_text_run()` function, which is responsible for calculating the positions for glyphs that need to be painted, into a separate function called `get_glyph_run()`. It is a part of the preparation for text run painting using OpenGL, where we can't immediately blit glyph bitmaps but instead need to prepare a sequence of quads for them in advance.
2023-11-05 00:17:04 +01:00
};
}
Userland: Move text wrapping/elision into the new TextLayout :^) This class now contains all the fun bits about laying out text in a rect. It will handle line wrapping at a certain width, cutting off lines that don't fit the given rect, and handling text elision. Painter::draw_text now internally uses this. Future work here would be not laying out text twice (once actually preparing the lines to be rendered and once to get the bounding box), and possibly adding left elision if necessary. Additionally, this commit makes the Utf32View versions of Painter::draw_text convert to Utf8View internally. The intention is to completely remove those versions, but they're kept at the moment to keep the scope of this PR small.
2021-07-25 21:20:11 +00:00
}
Reference in a new issue Copy permalink