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

148 lines
4.5 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
*/
#pragma once
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
#include <AK/ByteString.h>
LibGfx: Allow extracting paths from fonts and add Gfx::Path::text() This updates fonts so rather than rastering directly to a bitmap, you can extract paths for glyphs. This is then used to implement a Gfx::Path::text("some text", font) API, that if given a vector font appends the path of the text to your Gfx::Path. This then allows arbitrary manipulation of the text (rotation, skewing, etc), paving the way for Word Art in Serenity.
2023-11-04 21:41:24 +00:00
#include <AK/CharacterTypes.h>
Everywhere: Fix badly-formatted includes
2022-09-14 00:56:13 +02:00
#include <AK/Forward.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
#include <AK/Utf32View.h>
#include <AK/Utf8View.h>
#include <AK/Vector.h>
LibGfx: Move other font-related files to LibGfx/Font/
2022-04-09 09:28:38 +02:00
#include <LibGfx/Font/Font.h>
LibGfx+LibWeb: Update for_each_glyph_position to use font cascade list This change updates function that builds list of glyphs to use font cascade list to find font for each code point.
2023-12-09 23:45:57 +01:00
#include <LibGfx/FontCascadeList.h>
Everywhere: Fix badly-formatted includes
2022-09-14 00:56:13 +02:00
#include <LibGfx/Forward.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
#include <LibGfx/Rect.h>
#include <LibGfx/TextElision.h>
#include <LibGfx/TextWrapping.h>
namespace Gfx {
// FIXME: This currently isn't an ideal way of doing things; ideally, TextLayout
// would be doing the rendering by painting individual glyphs. However, this
// would regress our Unicode bidirectional text support. Therefore, fixing this
// requires:
// - Moving the bidirectional algorithm either here, or some place TextLayout
// can access;
// - Making TextLayout render the given text into something like a Vector<Line>
// where:
// using Line = Vector<DirectionalRun>;
// struct DirectionalRun {
// Utf32View glyphs;
// Vector<int> advance;
// TextDirection direction;
// };
// - Either;
// a) Making TextLayout output these Lines directly using a given Painter, or
// b) Taking the Lines from TextLayout and painting each glyph.
class TextLayout {
public:
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
TextLayout(Gfx::Font const& font, Utf8View const& text, FloatRect const& rect)
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
: m_font(font)
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
, m_font_metrics(font.pixel_metrics())
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
, m_text(text)
, m_rect(rect)
{
}
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
Vector<ByteString, 32> 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 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
return wrap_lines(elision, wrapping);
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 bounding_rect(TextWrapping) 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
private:
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
Vector<ByteString, 32> wrap_lines(TextElision, TextWrapping) const;
ByteString elide_text_from_right(Utf8View) 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
Font const& m_font;
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
FontPixelMetrics m_font_metrics;
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
Utf8View m_text;
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 m_rect;
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: Allow extracting paths from fonts and add Gfx::Path::text() This updates fonts so rather than rastering directly to a bitmap, you can extract paths for glyphs. This is then used to implement a Gfx::Path::text("some text", font) API, that if given a vector font appends the path of the text to your Gfx::Path. This then allows arbitrary manipulation of the text (rotation, skewing, etc), paving the way for Word Art in Serenity.
2023-11-04 21:41:24 +00:00
inline bool should_paint_as_space(u32 code_point)
{
return is_ascii_space(code_point) || code_point == 0xa0;
}
enum class IncludeLeftBearing {
Yes,
No
};
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
struct DrawGlyph {
LibGfx: Allow extracting paths from fonts and add Gfx::Path::text() This updates fonts so rather than rastering directly to a bitmap, you can extract paths for glyphs. This is then used to implement a Gfx::Path::text("some text", font) API, that if given a vector font appends the path of the text to your Gfx::Path. This then allows arbitrary manipulation of the text (rotation, skewing, etc), paving the way for Word Art in Serenity.
2023-11-04 21:41:24 +00:00
FloatPoint position;
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
u32 code_point;
LibGfx+LibAccelGfx+LibWeb: Use RefPtr for font in DrawGlyphOrEmoji
2023-12-09 23:14:07 +01:00
NonnullRefPtr<Font const> font;
LibWeb: Apply scroll boxes offsets after painting commands recording With this change, instead of applying scroll offsets during the recording of the painting command list, we do the following: 1. Collect all boxes with scrollable overflow into a PaintContext, each with an id and the total amount of scrolling offset accumulated from ancestor scrollable boxes. 2. During the recording phase assign a corresponding scroll_frame_id to each command that paints content within a scrollable box. 3. Before executing the recorded commands, translate each command that has a scroll_frame_id by the accumulated scroll offset. This approach has following advantages: - Implementing nested scrollables becomes much simpler, as the recording phase only requires the correct assignment of the nearest scrollable's scroll_frame_id, while the accumulated offset from ancestors is applied subsequently. - The recording of painting commands is not tied to a specific offset within scrollable boxes, which means in the future, it will be possible to update the scrolling offset and repaint without the need to re-record painting commands.
2023-12-29 06:10:32 +01:00
void translate_by(FloatPoint const& delta)
{
position.translate_by(delta);
}
LibGfx: Allow extracting paths from fonts and add Gfx::Path::text() This updates fonts so rather than rastering directly to a bitmap, you can extract paths for glyphs. This is then used to implement a Gfx::Path::text("some text", font) API, that if given a vector font appends the path of the text to your Gfx::Path. This then allows arbitrary manipulation of the text (rotation, skewing, etc), paving the way for Word Art in Serenity.
2023-11-04 21:41:24 +00:00
};
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
struct 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
FloatPoint position;
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
Gfx::Bitmap const* emoji;
LibGfx+LibAccelGfx+LibWeb: Use RefPtr for font in DrawGlyphOrEmoji
2023-12-09 23:14:07 +01:00
NonnullRefPtr<Font const> font;
LibWeb: Apply scroll boxes offsets after painting commands recording With this change, instead of applying scroll offsets during the recording of the painting command list, we do the following: 1. Collect all boxes with scrollable overflow into a PaintContext, each with an id and the total amount of scrolling offset accumulated from ancestor scrollable boxes. 2. During the recording phase assign a corresponding scroll_frame_id to each command that paints content within a scrollable box. 3. Before executing the recorded commands, translate each command that has a scroll_frame_id by the accumulated scroll offset. This approach has following advantages: - Implementing nested scrollables becomes much simpler, as the recording phase only requires the correct assignment of the nearest scrollable's scroll_frame_id, while the accumulated offset from ancestors is applied subsequently. - The recording of painting commands is not tied to a specific offset within scrollable boxes, which means in the future, it will be possible to update the scrolling offset and repaint without the need to re-record painting commands.
2023-12-29 06:10:32 +01:00
void translate_by(FloatPoint const& delta)
{
position.translate_by(delta);
}
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
};
using DrawGlyphOrEmoji = Variant<DrawGlyph, DrawEmoji>;
Variant<DrawGlyph, DrawEmoji> prepare_draw_glyph_or_emoji(FloatPoint point, Utf8CodePointIterator& it, Font const& font);
LibGfx: Allow extracting paths from fonts and add Gfx::Path::text() This updates fonts so rather than rastering directly to a bitmap, you can extract paths for glyphs. This is then used to implement a Gfx::Path::text("some text", font) API, that if given a vector font appends the path of the text to your Gfx::Path. This then allows arbitrary manipulation of the text (rotation, skewing, etc), paving the way for Word Art in Serenity.
2023-11-04 21:41:24 +00:00
template<typename Callback>
LibGfx+LibWeb: Update for_each_glyph_position to use font cascade list This change updates function that builds list of glyphs to use font cascade list to find font for each code point.
2023-12-09 23:45:57 +01:00
void for_each_glyph_position(FloatPoint baseline_start, Utf8View string, FontCascadeList const& font_list, Callback callback, IncludeLeftBearing include_left_bearing = IncludeLeftBearing::No, Optional<float&> width = {})
LibGfx: Allow extracting paths from fonts and add Gfx::Path::text() This updates fonts so rather than rastering directly to a bitmap, you can extract paths for glyphs. This is then used to implement a Gfx::Path::text("some text", font) API, that if given a vector font appends the path of the text to your Gfx::Path. This then allows arbitrary manipulation of the text (rotation, skewing, etc), paving the way for Word Art in Serenity.
2023-11-04 21:41:24 +00:00
{
LibGfx+LibWeb: Update for_each_glyph_position to use font cascade list This change updates function that builds list of glyphs to use font cascade list to find font for each code point.
2023-12-09 23:45:57 +01:00
float space_width = font_list.first().glyph_width(' ') + font_list.first().glyph_spacing();
LibGfx: Allow extracting paths from fonts and add Gfx::Path::text() This updates fonts so rather than rastering directly to a bitmap, you can extract paths for glyphs. This is then used to implement a Gfx::Path::text("some text", font) API, that if given a vector font appends the path of the text to your Gfx::Path. This then allows arbitrary manipulation of the text (rotation, skewing, etc), paving the way for Word Art in Serenity.
2023-11-04 21:41:24 +00:00
u32 last_code_point = 0;
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
auto point = baseline_start;
for (auto code_point_iterator = string.begin(); code_point_iterator != string.end(); ++code_point_iterator) {
LibGfx+LibWeb: Update for_each_glyph_position to use font cascade list This change updates function that builds list of glyphs to use font cascade list to find font for each code point.
2023-12-09 23:45:57 +01:00
auto it = code_point_iterator; // The callback function will advance the iterator, so create a copy for this lookup.
LibGfx: Allow extracting paths from fonts and add Gfx::Path::text() This updates fonts so rather than rastering directly to a bitmap, you can extract paths for glyphs. This is then used to implement a Gfx::Path::text("some text", font) API, that if given a vector font appends the path of the text to your Gfx::Path. This then allows arbitrary manipulation of the text (rotation, skewing, etc), paving the way for Word Art in Serenity.
2023-11-04 21:41:24 +00:00
auto code_point = *code_point_iterator;
LibGfx+LibWeb: Update for_each_glyph_position to use font cascade list This change updates function that builds list of glyphs to use font cascade list to find font for each code point.
2023-12-09 23:45:57 +01:00
RefPtr<Gfx::Font const> font = font_list.font_for_code_point(code_point);
point.set_y(baseline_start.y() - font->pixel_metrics().ascent);
LibGfx: Allow extracting paths from fonts and add Gfx::Path::text() This updates fonts so rather than rastering directly to a bitmap, you can extract paths for glyphs. This is then used to implement a Gfx::Path::text("some text", font) API, that if given a vector font appends the path of the text to your Gfx::Path. This then allows arbitrary manipulation of the text (rotation, skewing, etc), paving the way for Word Art in Serenity.
2023-11-04 21:41:24 +00:00
if (should_paint_as_space(code_point)) {
point.translate_by(space_width, 0);
last_code_point = code_point;
continue;
}
LibGfx+LibWeb: Update for_each_glyph_position to use font cascade list This change updates function that builds list of glyphs to use font cascade list to find font for each code point.
2023-12-09 23:45:57 +01:00
auto kerning = font->glyphs_horizontal_kerning(last_code_point, code_point);
LibGfx: Allow extracting paths from fonts and add Gfx::Path::text() This updates fonts so rather than rastering directly to a bitmap, you can extract paths for glyphs. This is then used to implement a Gfx::Path::text("some text", font) API, that if given a vector font appends the path of the text to your Gfx::Path. This then allows arbitrary manipulation of the text (rotation, skewing, etc), paving the way for Word Art in Serenity.
2023-11-04 21:41:24 +00:00
if (kerning != 0.0f)
point.translate_by(kerning, 0);
LibGfx+LibWeb: Update for_each_glyph_position to use font cascade list This change updates function that builds list of glyphs to use font cascade list to find font for each code point.
2023-12-09 23:45:57 +01:00
auto glyph_width = font->glyph_or_emoji_width(it) + font->glyph_spacing();
auto glyph_or_emoji = prepare_draw_glyph_or_emoji(point, code_point_iterator, *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 (include_left_bearing == IncludeLeftBearing::Yes) {
if (glyph_or_emoji.has<DrawGlyph>())
LibGfx+LibWeb: Update for_each_glyph_position to use font cascade list This change updates function that builds list of glyphs to use font cascade list to find font for each code point.
2023-12-09 23:45:57 +01:00
glyph_or_emoji.get<DrawGlyph>().position += FloatPoint(font->glyph_left_bearing(code_point), 0);
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
}
LibGfx: Allow extracting paths from fonts and add Gfx::Path::text() This updates fonts so rather than rastering directly to a bitmap, you can extract paths for glyphs. This is then used to implement a Gfx::Path::text("some text", font) API, that if given a vector font appends the path of the text to your Gfx::Path. This then allows arbitrary manipulation of the text (rotation, skewing, etc), paving the way for Word Art in Serenity.
2023-11-04 21:41:24 +00:00
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
callback(glyph_or_emoji);
LibGfx: Allow extracting paths from fonts and add Gfx::Path::text() This updates fonts so rather than rastering directly to a bitmap, you can extract paths for glyphs. This is then used to implement a Gfx::Path::text("some text", font) API, that if given a vector font appends the path of the text to your Gfx::Path. This then allows arbitrary manipulation of the text (rotation, skewing, etc), paving the way for Word Art in Serenity.
2023-11-04 21:41:24 +00:00
point.translate_by(glyph_width, 0);
last_code_point = code_point;
}
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
if (width.has_value())
LibGfx+LibWeb: Update for_each_glyph_position to use font cascade list This change updates function that builds list of glyphs to use font cascade list to find font for each code point.
2023-12-09 23:45:57 +01:00
*width = point.x() - font_list.first().glyph_spacing();
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
}
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