beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 07:30:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Userland/Libraries/LibGfx/Painter.h

302 lines
16 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 08:38:21 +00:00
/*
LibGfx: Adjust parameter order for Painter::draw_ui_text() Let's put the rect first so it's the same as draw_text().
2021-04-09 09:09:48 +00:00
* Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.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 08:38:21 +00: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 08:24:48 +00: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 08:38:21 +00:00
*/
Intense hacking on Widgets.
2018-10-10 14:49:36 +00:00
#pragma once
LibGfx: More work on header dependency reduction
2020-02-14 22:28:42 +00:00
#include <AK/Forward.h>
LibGfx: Speed up fill_path() with per scanline clipping & fast fills This improves fill_path() performance by adding an API to the painter that allows painting an entire scanline rather than just a pixel. With this paths can be clipped a scanline at a time rather than each pixel, removing a fair amount of checks. Along with optimized clipping, this can now use a fast_u32_fill() to paint all but the subpixels of a scanline if a solid color with no alpha channel is used (which is quite common in SVGs). This reduces scrolling around on svg.html from 21% in set_pixel() and 19% in fill_path() to just 7.8% in fill_path (with set_pixel() eliminated). Now fill_path() is far from the slowest code when scrolling the page.
2023-03-08 19:49:00 +00:00
#include <AK/Memory.h>
LibGfx: Move a bunch of LogStream::operator<< to cpp files
2020-02-14 23:58:14 +00:00
#include <AK/NonnullRefPtr.h>
LibGfx+LibGUI: Support multi code point emojis in text painting :^) This necessitates switching from passing a single code point to the callback to passing a non-const Utf8CodePointIterator instead. Note that the text selection mechanisms in LibGUI and LibWeb don't handle this properly yet; they still assume that each code point renders as one glyph. Similarly, width calculations for text widths don't either, so a single such an emoji will require space for more than one glyph. It also doesn't work in LibVT's TerminalWidget, where each code point is handled and rendered separately, so LibGfx never gets a chance to check if subsequent code points could result in a combined emoji.
2022-02-22 21:55:01 +00:00
#include <AK/Utf8View.h>
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
#include <AK/Vector.h>
#include <LibGfx/Color.h>
LibGfx: Move other font-related files to LibGfx/Font/
2022-04-09 07:28:38 +00:00
#include <LibGfx/Font/FontDatabase.h>
LibGfx: More work on header dependency reduction
2020-02-14 22:28:42 +00:00
#include <LibGfx/Forward.h>
LibWeb+LibGfx: Migrate (most of) the CSS gradient painting to LibGfx This moves the CSS gradient painting to the painter creating: - Painter::fill_rect_with_linear_gradient() - Painter::fill_rect_with_conic_gradient() - Painter::fill_rect_with_radial_gradient() This has a few benefits: - The gradients can now easily respect the painter scale - The Painter::fill_pixels() escape hatch can be removed - We can remove the old fixed color stop gradient code - The old functions are now just a shim - Anywhere can now easily use this gradient painting code! This only leaves the color stop resolution in LibWeb (which is fine). Just means in LibGfx you have to actually specify color stop positions. (Also while here add a small optimization to avoid generating excessively long gradient lines)
2023-01-10 01:07:06 +00:00
#include <LibGfx/Gradients.h>
LibGfx: Update fill_path() to support taking a PaintStyle This means fill_path() now paints the scanlines its self rather than calling draw_line() which easily allows each pixel along the scanline to have a different color.
2023-01-15 22:15:24 +00:00
#include <LibGfx/PaintStyle.h>
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
#include <LibGfx/Point.h>
#include <LibGfx/Rect.h>
#include <LibGfx/Size.h>
LibGfx: Rename from LibDraw :^)
2020-02-06 11:04:00 +00:00
#include <LibGfx/TextAlignment.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/TextDirection.h>
LibGfx: Rename from LibDraw :^)
2020-02-06 11:04:00 +00:00
#include <LibGfx/TextElision.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/TextWrapping.h>
LibGfx: Update fill_path() to support taking a PaintStyle This means fill_path() now paints the scanlines its self rather than calling draw_line() which easily allows each pixel along the scanline to have a different color.
2023-01-15 22:15:24 +00:00
LibDraw: Put all classes in the Gfx namespace I started adding things to a Draw namespace, but it somehow felt really wrong seeing Draw::Rect and Draw::Bitmap, etc. So instead, let's rename the library to LibGfx. :^)
2020-02-06 10:56:38 +00:00
namespace Gfx {
Intense hacking on Widgets.
2018-10-10 14:49:36 +00:00
class Painter {
public:
LibGfx+LibGUI: Use constant for line spacing instead of magic number
2022-11-28 15:02:08 +00:00
static constexpr int LINE_SPACING = 4;
LibGfx: Give Bitmap a scale factor Gfx::Bitmap can now store its scale factor. Normally it's 1, but in high dpi mode it can be 2. If a Bitmap with a scale factor of 2 is blitted to a Painter with scale factor of 2, the pixels can be copied over without any resampling. (When blitting a Bitmap with a scale factor of 1 to a Painter with scale factor of 2, the Bitmap is painted at twice its width and height at paint time. Blitting a Bitmap with a scale factor of 2 to a Painter with scale factor 1 is not supported.) A Bitmap with scale factor of 2 reports the same width() and height() as one with scale factor 1. That's important because many places in the codebase use a bitmap's width() and height() to layout Widgets, and all widget coordinates are in logical coordinates as well, per Documentation/HighDPI.md. Bitmap grows physical_width() / physical_height() to access the actual pixel size. Update a few callers that work with pixels to call this instead. Make Painter's constructor take its scale factor from the target bitmap that's passed in, and update its various blit() methods to handle blitting a 2x bitmap to a 2x painter. This allows removing some gnarly code in Compositor. (In return, put some new gnarly code in LibGfxScaleDemo to preserve behavior there.) No intended behavior change.
2021-01-19 17:10:47 +00:00
explicit Painter(Gfx::Bitmap&);
Libraries: Use default constructors/destructors in LibGfx https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-14 19:26:37 +00:00
~Painter() = default;
LibGfx: Replace 'bool dotted' with a LineStyle::{Solid,Dotted} enum Just a bool is insufficient as we'll have to support dashed lines as well.
2020-05-10 10:58:33 +00:00
enum class LineStyle {
Solid,
Dotted,
LibGfx: Add support for dashed lines Non-configurable for now.
2020-05-10 15:17:26 +00:00
Dashed,
LibGfx: Replace 'bool dotted' with a LineStyle::{Solid,Dotted} enum Just a bool is insufficient as we'll have to support dashed lines as well.
2020-05-10 10:58:33 +00:00
};
LibGfx: Add optional bilinear filtering to draw_scaled_bitmap() The algorithm is quite simple: You grab a 2x2 area of pixels around the point you want from the source bitmap, and then linearly interpolate between them based on how far they are from that point. This works well when scaling up images, and moderately well when scaling down - small details may get skipped over. The way GPUs solve this is with mipmaps, which is not something I want to get into right now. (And increases the memory usage per bitmap by 50%.) I have not focused on performance, but this does reuse much of the existing fixed-point calculation, and uses constexpr so that the performance for nearest-neighbor should be the same as it was previously.
2021-09-20 18:48:56 +00:00
enum class ScalingMode {
LibGfx: Add NearestFractional scaling type to painter This is useful for cases where you want to avoid scaling artifacts.
2022-12-04 20:23:53 +00:00
NearestFractional,
LibGfx: Add optional bilinear filtering to draw_scaled_bitmap() The algorithm is quite simple: You grab a 2x2 area of pixels around the point you want from the source bitmap, and then linearly interpolate between them based on how far they are from that point. This works well when scaling up images, and moderately well when scaling down - small details may get skipped over. The way GPUs solve this is with mipmaps, which is not something I want to get into right now. (And increases the memory usage per bitmap by 50%.) I have not focused on performance, but this does reuse much of the existing fixed-point calculation, and uses constexpr so that the performance for nearest-neighbor should be the same as it was previously.
2021-09-20 18:48:56 +00:00
NearestNeighbor,
LibGfx: Implement SmoothPixels scaling mode If you wanted to upscale an image, you had two options: - use Nearest Neighbor: it's probably a good choice. The image stays sharp.. unless you aren't using integer scales. - use Bilinear blending, but this on the other hand, doesn't handle upscaling well. It just blurs everything. But what if we could take the best of both of them and make the image sharp on integers and just blur it a little when needed? Well, there's Smooth Pixels! This mode is similar to the Bilinear Blend, with the main difference is that the blend ratio is multiplied by the current scale, so the blur on corners can be only 1px wide. From my testing this mode doesn't handles downscaling as good as the Bilinear blending though.
2022-06-03 15:16:38 +00:00
SmoothPixels,
LibGfx: Add optional bilinear filtering to draw_scaled_bitmap() The algorithm is quite simple: You grab a 2x2 area of pixels around the point you want from the source bitmap, and then linearly interpolate between them based on how far they are from that point. This works well when scaling up images, and moderately well when scaling down - small details may get skipped over. The way GPUs solve this is with mipmaps, which is not something I want to get into right now. (And increases the memory usage per bitmap by 50%.) I have not focused on performance, but this does reuse much of the existing fixed-point calculation, and uses constexpr so that the performance for nearest-neighbor should be the same as it was previously.
2021-09-20 18:48:56 +00:00
BilinearBlend,
PixelPaint+LibGfx: Allow resizing images and layers This PR adds resize ability to PixelPaint as per issue 11862. The previous behaviour was to always rescale the canvas when resizing an image. This adds a checkbox to toggle between rescaling, and resizing which blits the existing canvas to the top left of the new, resized canvas. As part of this, a new ScalingMode is added to LibGfx - None.
2022-10-10 19:54:06 +00:00
None,
LibGfx: Add optional bilinear filtering to draw_scaled_bitmap() The algorithm is quite simple: You grab a 2x2 area of pixels around the point you want from the source bitmap, and then linearly interpolate between them based on how far they are from that point. This works well when scaling up images, and moderately well when scaling down - small details may get skipped over. The way GPUs solve this is with mipmaps, which is not something I want to get into right now. (And increases the memory usage per bitmap by 50%.) I have not focused on performance, but this does reuse much of the existing fixed-point calculation, and uses constexpr so that the performance for nearest-neighbor should be the same as it was previously.
2021-09-20 18:48:56 +00:00
};
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
void clear_rect(IntRect const&, Color);
void fill_rect(IntRect const&, Color);
LibGfx: Add Painter::fill_rect(rect, paint_style) The usual fill_rect()... but with style :^)
2023-01-15 22:18:46 +00:00
void fill_rect(IntRect const&, PaintStyle const&);
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
void fill_rect_with_dither_pattern(IntRect const&, Color, Color);
Meta+Userland: Pass Gfx::IntSize by value Just two ints like Gfx::IntPoint.
2022-12-06 21:35:32 +00:00
void fill_rect_with_checkerboard(IntRect const&, IntSize, Color color_dark, Color color_light);
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
void fill_rect_with_gradient(Orientation, IntRect const&, Color gradient_start, Color gradient_end);
void fill_rect_with_gradient(IntRect const&, Color gradient_start, Color gradient_end);
Everywhere: Use ReadonlySpan<T> instead of Span<T const>
2023-02-05 19:02:54 +00:00
void fill_rect_with_linear_gradient(IntRect const&, ReadonlySpan<ColorStop>, float angle, Optional<float> repeat_length = {});
void fill_rect_with_conic_gradient(IntRect const&, ReadonlySpan<ColorStop>, IntPoint center, float start_angle, Optional<float> repeat_length = {});
void fill_rect_with_radial_gradient(IntRect const&, ReadonlySpan<ColorStop>, IntPoint center, IntSize size, Optional<float> repeat_length = {});
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
void fill_rect_with_rounded_corners(IntRect const&, Color, int radius);
void fill_rect_with_rounded_corners(IntRect const&, Color, int top_left_radius, int top_right_radius, int bottom_right_radius, int bottom_left_radius);
void fill_ellipse(IntRect const&, Color);
void draw_rect(IntRect const&, Color, bool rough = false);
void draw_rect_with_thickness(IntRect const&, Color, int thickness);
void draw_focus_rect(IntRect const&, Color);
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
void draw_bitmap(IntPoint, CharacterBitmap const&, Color = Color());
void draw_bitmap(IntPoint, GlyphBitmap const&, Color = Color());
LibGfx: Add optional bilinear filtering to draw_scaled_bitmap() The algorithm is quite simple: You grab a 2x2 area of pixels around the point you want from the source bitmap, and then linearly interpolate between them based on how far they are from that point. This works well when scaling up images, and moderately well when scaling down - small details may get skipped over. The way GPUs solve this is with mipmaps, which is not something I want to get into right now. (And increases the memory usage per bitmap by 50%.) I have not focused on performance, but this does reuse much of the existing fixed-point calculation, and uses constexpr so that the performance for nearest-neighbor should be the same as it was previously.
2021-09-20 18:48:56 +00:00
void draw_scaled_bitmap(IntRect const& dst_rect, Gfx::Bitmap const&, IntRect const& src_rect, float opacity = 1.0f, ScalingMode = ScalingMode::NearestNeighbor);
void draw_scaled_bitmap(IntRect const& dst_rect, Gfx::Bitmap const&, FloatRect const& src_rect, float opacity = 1.0f, ScalingMode = ScalingMode::NearestNeighbor);
LibWeb+LibGfx: Move the blit image through 2D transfrom to Gfx::Painter Even though this code is obnoxiously slow, it still belongs in LibGfx and should not be hidden away in LibWeb's CanvasRenderingContext2D.
2022-09-24 11:00:53 +00:00
void draw_scaled_bitmap_with_transform(IntRect const& dst_rect, Gfx::Bitmap const&, FloatRect const& src_rect, Gfx::AffineTransform const&, float opacity = 1.0f, ScalingMode = ScalingMode::NearestNeighbor);
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
void draw_triangle(IntPoint, IntPoint, IntPoint, Color);
Everywhere: Use ReadonlySpan<T> instead of Span<T const>
2023-02-05 19:02:54 +00:00
void draw_triangle(IntPoint offset, ReadonlySpan<IntPoint>, Color);
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
void draw_ellipse_intersecting(IntRect const&, Color, int thickness = 1);
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
void set_pixel(IntPoint, Color, bool blend = false);
LibGfx: AntiAliasingPainter::draw_circle/fill_rect_with_rounded_corners Follows the efficient algorithm from this paper: https://cs.uwaterloo.ca/research/tr/1984/CS-84-38.pdf Can be extended ellipses in future.
2022-03-10 02:21:02 +00:00
void set_pixel(int x, int y, Color color, bool blend = false) { set_pixel({ x, y }, color, blend); }
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
Optional<Color> get_pixel(IntPoint);
LibGfx: Support getting a bitmap for a region of painter This will be needed so we can apply filter effects to the backdrop of an element in LibWeb. This now also allows getting a crop of a bitmap in a different format than the source bitmap. This is for if the painter's bitmap does not have an alpha channel, but you want to ensure the cropped bitmap does.
2022-09-15 07:31:29 +00:00
ErrorOr<NonnullRefPtr<Bitmap>> get_region_bitmap(IntRect const&, BitmapFormat format, Optional<IntRect&> actual_region = {});
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
void draw_line(IntPoint, IntPoint, Color, int thickness = 1, LineStyle style = LineStyle::Solid, Color alternate_color = Color::Transparent);
void draw_triangle_wave(IntPoint, IntPoint, Color color, int amplitude, int thickness = 1);
void draw_quadratic_bezier_curve(IntPoint control_point, IntPoint, IntPoint, Color, int thickness = 1, LineStyle style = LineStyle::Solid);
void draw_cubic_bezier_curve(IntPoint control_point_0, IntPoint control_point_1, IntPoint, IntPoint, Color, int thickness = 1, LineStyle style = LineStyle::Solid);
LibGfx+LibWeb: Store radii as FloatSize rather than FloatPoint Radii are sizes, not points. This becomes important when mapping them through a 2D transform.
2023-02-10 09:52:14 +00:00
void draw_elliptical_arc(IntPoint p1, IntPoint p2, IntPoint center, FloatSize radii, float x_axis_rotation, float theta_1, float theta_delta, Color, int thickness = 1, LineStyle style = LineStyle::Solid);
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
void blit(IntPoint, Gfx::Bitmap const&, IntRect const& src_rect, float opacity = 1.0f, bool apply_alpha = true);
void blit_dimmed(IntPoint, Gfx::Bitmap const&, IntRect const& src_rect);
void blit_brightened(IntPoint, Gfx::Bitmap const&, IntRect const& src_rect);
void blit_filtered(IntPoint, Gfx::Bitmap const&, IntRect const& src_rect, Function<Color(Color)>);
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
void draw_tiled_bitmap(IntRect const& dst_rect, Gfx::Bitmap const&);
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
void blit_offset(IntPoint, Gfx::Bitmap const&, IntRect const& src_rect, IntPoint);
void blit_disabled(IntPoint, Gfx::Bitmap const&, IntRect const&, Palette const&);
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
void blit_tiled(IntRect const&, Gfx::Bitmap const&, IntRect const& src_rect);
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 18:42:00 +00:00
void draw_text(FloatRect const&, StringView, Font const&, TextAlignment = TextAlignment::TopLeft, Color = Color::Black, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
void draw_text(FloatRect const&, StringView, TextAlignment = TextAlignment::TopLeft, Color = Color::Black, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
void draw_text(FloatRect const&, Utf32View const&, Font const&, TextAlignment = TextAlignment::TopLeft, Color = Color::Black, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
void draw_text(FloatRect const&, Utf32View const&, TextAlignment = TextAlignment::TopLeft, Color = Color::Black, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
void draw_text(Function<void(FloatRect const&, Utf8CodePointIterator&)>, FloatRect const&, StringView, Font const&, TextAlignment = TextAlignment::TopLeft, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
void draw_text(Function<void(FloatRect const&, Utf8CodePointIterator&)>, FloatRect const&, Utf8View const&, Font const&, TextAlignment = TextAlignment::TopLeft, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
void draw_text(Function<void(FloatRect const&, Utf8CodePointIterator&)>, FloatRect const&, Utf32View const&, Font const&, TextAlignment = TextAlignment::TopLeft, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
Everywhere: Pass AK::StringView by value
2021-11-10 23:55:02 +00:00
void draw_text(IntRect const&, StringView, Font const&, TextAlignment = TextAlignment::TopLeft, Color = Color::Black, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
void draw_text(IntRect const&, StringView, TextAlignment = TextAlignment::TopLeft, Color = Color::Black, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
void draw_text(IntRect const&, Utf32View const&, Font const&, TextAlignment = TextAlignment::TopLeft, Color = Color::Black, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
void draw_text(IntRect const&, Utf32View const&, TextAlignment = TextAlignment::TopLeft, Color = Color::Black, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
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 18:42:00 +00:00
void draw_text(Function<void(FloatRect const&, Utf8CodePointIterator&)>, IntRect const&, StringView, Font const&, TextAlignment = TextAlignment::TopLeft, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
void draw_text(Function<void(FloatRect const&, Utf8CodePointIterator&)>, IntRect const&, Utf8View const&, Font const&, TextAlignment = TextAlignment::TopLeft, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
void draw_text(Function<void(FloatRect const&, Utf8CodePointIterator&)>, IntRect const&, Utf32View const&, Font const&, TextAlignment = TextAlignment::TopLeft, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
Everywhere: Pass AK::StringView by value
2021-11-10 23:55:02 +00:00
void draw_ui_text(Gfx::IntRect const&, StringView, Gfx::Font const&, TextAlignment, Gfx::Color);
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
void draw_glyph(IntPoint, u32, Color);
void draw_glyph(IntPoint, u32, Font const&, Color);
void draw_emoji(IntPoint, Gfx::Bitmap const&, Font const&);
void draw_glyph_or_emoji(IntPoint, u32, Font const&, Color);
void draw_glyph_or_emoji(IntPoint, Utf8CodePointIterator&, Font const&, Color);
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 18:42:00 +00:00
void draw_glyph(FloatPoint, u32, Color);
void draw_glyph(FloatPoint, u32, Font const&, Color);
void draw_glyph_or_emoji(FloatPoint, u32, Font const&, Color);
void draw_glyph_or_emoji(FloatPoint, Utf8CodePointIterator&, Font const&, Color);
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
void draw_circle_arc_intersecting(IntRect const&, IntPoint, int radius, Color, int thickness);
Update Painter class to the new coding style.
2019-01-12 16:02:54 +00:00
LibGfx: Add Painter::draw_text_run(), a simplified text painting API This API does: - Take a Utf8View - Take the starting point on the baseline as its input coordinate This API does not: - Align the text - Wrap the text - Elide too-long text into "..."
2022-03-28 11:40:48 +00:00
// Streamlined text drawing routine that does no wrapping/elision/alignment.
LibGfx: Add int overloads for (AntiAliasing)Painter float methods Without this change, the upcoming LibWeb pixel types will require a silly doubled conversion in some places. eg: `some_rect.to_type<int>().to_type<float>()` With these overloads, we can get away with `some_rect.to_type<int>()`.
2022-12-07 20:50:34 +00:00
void draw_text_run(IntPoint baseline_start, Utf8View const&, Font const&, Color);
Meta+Userland: Pass Gfx::FloatPoint by value Just a small 8-byte value like Gfx::IntPoint.
2022-12-06 20:57:07 +00:00
void draw_text_run(FloatPoint baseline_start, Utf8View const&, Font const&, Color);
LibGfx: Add Painter::draw_text_run(), a simplified text painting API This API does: - Take a Utf8View - Take the starting point on the baseline as its input coordinate This API does not: - Align the text - Wrap the text - Elide too-long text into "..."
2022-03-28 11:40:48 +00:00
LibGfx: Add Painter::fill_rect_with_rounded_corners() This paints a rectangle with rounded corners each specified by a radius.
2021-05-15 21:33:21 +00:00
enum class CornerOrientation {
TopLeft,
TopRight,
BottomRight,
BottomLeft
};
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
void fill_rounded_corner(IntRect const&, int radius, Color, CornerOrientation);
LibGfx: Add Painter::fill_rect_with_rounded_corners() This paints a rectangle with rounded corners each specified by a radius.
2021-05-15 21:33:21 +00:00
Meta+Userland: Pass Gfx::FloatPoint by value Just a small 8-byte value like Gfx::IntPoint.
2022-12-06 20:57:07 +00:00
static void for_each_line_segment_on_bezier_curve(FloatPoint control_point, FloatPoint p1, FloatPoint p2, Function<void(FloatPoint, FloatPoint)>&);
static void for_each_line_segment_on_bezier_curve(FloatPoint control_point, FloatPoint p1, FloatPoint p2, Function<void(FloatPoint, FloatPoint)>&&);
LibGfx: Implement filling paths There are some imperfections with intersecting edges (because the main algorithm used is scanline, and that is not geared towards drawing complex shapes), however, it behaves mostly fine for normal use :^)
2020-05-06 07:25:12 +00:00
Meta+Userland: Pass Gfx::FloatPoint by value Just a small 8-byte value like Gfx::IntPoint.
2022-12-06 20:57:07 +00:00
static void for_each_line_segment_on_cubic_bezier_curve(FloatPoint control_point_0, FloatPoint control_point_1, FloatPoint p1, FloatPoint p2, Function<void(FloatPoint, FloatPoint)>&);
static void for_each_line_segment_on_cubic_bezier_curve(FloatPoint control_point_0, FloatPoint control_point_1, FloatPoint p1, FloatPoint p2, Function<void(FloatPoint, FloatPoint)>&&);
LibGfx: Implement cubic bezier curves by splitting them to subcurves This makes them significantly more nicer-looking, and fixes a FIXME :^)
2021-09-17 14:12:30 +00:00
LibGfx+LibWeb: Store radii as FloatSize rather than FloatPoint Radii are sizes, not points. This becomes important when mapping them through a 2D transform.
2023-02-10 09:52:14 +00:00
static void for_each_line_segment_on_elliptical_arc(FloatPoint p1, FloatPoint p2, FloatPoint center, FloatSize radii, float x_axis_rotation, float theta_1, float theta_delta, Function<void(FloatPoint, FloatPoint)>&);
static void for_each_line_segment_on_elliptical_arc(FloatPoint p1, FloatPoint p2, FloatPoint center, FloatSize radii, float x_axis_rotation, float theta_1, float theta_delta, Function<void(FloatPoint, FloatPoint)>&&);
LibGfx: Add elliptical curves to Path
2020-07-22 06:46:15 +00:00
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
void stroke_path(Path const&, Color, int thickness);
LibGfx: Add Gfx::Path, a basic 2D path with <canvas> semantics This will be used to implement painting of 2D paths. This first patch adds support for line_to(), move_to() and close(). It will try to have the same semantics as the HTML <canvas> element. To stroke a Path, simply pass it to Painter::stroke_path().
2020-04-16 19:03:17 +00:00
LibGfx: Implement filling paths There are some imperfections with intersecting edges (because the main algorithm used is scanline, and that is not geared towards drawing complex shapes), however, it behaves mostly fine for normal use :^)
2020-05-06 07:25:12 +00:00
enum class WindingRule {
Nonzero,
EvenOdd,
};
LibGfx: Make Painter::fill_path() take Path by const reference Taking a mutable reference here made the API look very strange.
2021-09-17 11:41:03 +00:00
void fill_path(Path const&, Color, WindingRule rule = WindingRule::Nonzero);
LibGfx: Update fill_path() to support taking a PaintStyle This means fill_path() now paints the scanlines its self rather than calling draw_line() which easily allows each pixel along the scanline to have a different color.
2023-01-15 22:15:24 +00:00
void fill_path(Path const&, PaintStyle const& paint_style, WindingRule rule = WindingRule::Nonzero);
LibGfx: Implement filling paths There are some imperfections with intersecting edges (because the main algorithm used is scanline, and that is not geared towards drawing complex shapes), however, it behaves mostly fine for normal use :^)
2020-05-06 07:25:12 +00:00
LibGfx: Load default font lazily This is required when trying to use a Painter from lagom, due to /res/font not being present
2021-11-28 15:09:38 +00:00
Font const& font() const
{
if (!state().font)
return FontDatabase::default_font();
return *state().font;
}
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
void set_font(Font const& font) { state().font = &font; }
Add a simple Font class.
2018-10-11 21:45:57 +00:00
Meta: Tweak .clang-format to not wrap braces after enums.
2019-06-07 15:13:23 +00:00
enum class DrawOp {
WindowServer: Clang-Format
2019-06-05 16:22:11 +00:00
Copy,
LibGfx: Add ability to draw inverted rectangles
2020-09-08 04:25:30 +00:00
Xor,
Invert
WindowServer: Clang-Format
2019-06-05 16:22:11 +00:00
};
SharedGraphics: Give painter a state stack and save()/restore() operations. This will make some painting code a lot less confusing since there's no need to manually undo translations, clips, etc.
2019-03-09 15:48:02 +00:00
void set_draw_op(DrawOp op) { state().draw_op = op; }
DrawOp draw_op() const { return state().draw_op; }
Hook up the PS2MouseDevice to the AbstractScreen+WindowManager. Render the mouse cursor by xor'ing the pixels. I don't know anything about hardware cursors yet and this way we don't need to recompose the window hierarchy every time you move the mouse. :^)
2019-01-11 02:52:09 +00:00
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
void add_clip_rect(IntRect const& rect);
Let userland retain the window backing store while drawing into it. To start painting, call: gui$get_window_backing_store() Then finish up with: gui$release_window_backing_store() Process will retain the underlying GraphicsBitmap behind the scenes. This fixes racing between the WindowServer and GUI clients. This patch also adds a WSWindowLocker that is exactly what it sounds like.
2019-01-24 22:40:12 +00:00
void clear_clip_rect();
FontEditor: Minor UI improvements. - Implement focus for custom widgets. - Add two live demo labels with an English pangram in upper/lower case.
2019-02-04 14:37:23 +00:00
Revert "LibGfx: Add directional floating-point scaling to Painter" This reverts commit ff76a5b8d2e4dfe007c20a1376cb6862a2c2dbe0.
2021-05-03 14:37:05 +00:00
void translate(int dx, int dy) { translate({ dx, dy }); }
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
void translate(IntPoint delta) { state().translation.translate_by(delta); }
GTextEditor: Improvements to cursor rendering. The view now scrolls along with you as you move the cursor around.
2019-03-07 12:13:25 +00:00
LibGfx: Add a way to get the Painter's current 2D translation
2022-10-01 12:04:05 +00:00
IntPoint translation() const { return state().translation; }
LibDraw: Put all classes in the Gfx namespace I started adding things to a Draw namespace, but it somehow felt really wrong seeing Draw::Rect and Draw::Bitmap, etc. So instead, let's rename the library to LibGfx. :^)
2020-02-06 10:56:38 +00:00
Gfx::Bitmap* target() { return m_target.ptr(); }
Port Terminal to LibGUI. To facilitate listening for action on arbitrary file descriptors, I've added a GNotifier class. It's quite simple but very useful: GNotifier notifier(fd, GNotifier::Read); notifier.on_ready_to_read = [this] (GNotifier& fd) { // read from fd or whatever else you like :^) }; The callback will get invoked by GEventLoop when select() says we have something to read on the fd.
2019-02-10 13:28:39 +00:00
SharedGraphics: Give painter a state stack and save()/restore() operations. This will make some painting code a lot less confusing since there's no need to manually undo translations, clips, etc.
2019-03-09 15:48:02 +00:00
void save() { m_state_stack.append(m_state_stack.last()); }
WindowServer: Clang-Format
2019-06-05 16:22:11 +00:00
void restore()
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(m_state_stack.size() > 1);
WindowServer: Clang-Format
2019-06-05 16:22:11 +00:00
m_state_stack.take_last();
}
SharedGraphics: Give painter a state stack and save()/restore() operations. This will make some painting code a lot less confusing since there's no need to manually undo translations, clips, etc.
2019-03-09 15:48:02 +00:00
LibGUI: Improve IconView rubberband performance Rather than invalidating the entire window, which is very expensive on the transparent desktop widget, just invalidate the areas that actually need updating.
2021-02-16 02:30:47 +00:00
IntRect clip_rect() const { return state().clip_rect; }
LibGfx: Support scaling in AntiAliasingPainter::draw_circle() Previously the painter would crash if scaling was enabled.
2022-03-19 00:29:22 +00:00
int scale() const { return state().scale; }
LibGfx: Speed up fill_path() with per scanline clipping & fast fills This improves fill_path() performance by adding an API to the painter that allows painting an entire scanline rather than just a pixel. With this paths can be clipped a scanline at a time rather than each pixel, removing a fair amount of checks. Along with optimized clipping, this can now use a fast_u32_fill() to paint all but the subpixels of a scanline if a solid color with no alpha channel is used (which is quite common in SVGs). This reduces scrolling around on svg.html from 21% in set_pixel() and 19% in fill_path() to just 7.8% in fill_path (with set_pixel() eliminated). Now fill_path() is far from the slowest code when scrolling the page.
2023-03-08 19:49:00 +00:00
template<typename T, typename TColorOrFunction>
ALWAYS_INLINE void draw_scanline_for_fill_path(int y, T x_start, T x_end, TColorOrFunction color)
{
// Note: This is really an internal function for FillPathImplementation.h to use.
// This allows fill path to clip more of the pixels and reduce the number of clipping checks
// to the number of scanlines (and allows for a fast fill).
// Fill path should scale the scanlines before calling this.
VERIFY(scale() == 1);
constexpr bool is_floating_point = IsSameIgnoringCV<T, int>;
constexpr bool has_constant_color = IsSameIgnoringCV<TColorOrFunction, Color>;
int x1 = 0;
int x2 = 0;
u8 left_subpixel_alpha = 0;
u8 right_subpixel_alpha = 0;
if constexpr (is_floating_point) {
x1 = ceilf(x_start);
x2 = floorf(x_end);
left_subpixel_alpha = (x1 - x_start) * 255;
right_subpixel_alpha = (x_end - x2) * 255;
x1 -= left_subpixel_alpha > 0;
x2 += right_subpixel_alpha > 0;
} else {
x1 = x_start;
x2 = x_end;
}
IntRect scanline(x1, y, x2 - x1, 1);
scanline = scanline.translated(translation());
auto clipped = scanline.intersected(clip_rect());
if (clipped.is_empty())
return;
auto get_color = [&](int offset) {
if constexpr (has_constant_color) {
return color;
} else {
return color(offset);
}
};
if constexpr (is_floating_point) {
// Paint left and right subpixels (then remove them from the scanline).
auto get_color_with_alpha = [&](int offset, u8 alpha) {
auto color_at_offset = get_color(offset);
u8 color_alpha = (alpha * color_at_offset.alpha()) / 255;
return color_at_offset.with_alpha(color_alpha);
};
if (clipped.left() == scanline.left() && left_subpixel_alpha)
set_physical_pixel(clipped.top_left(), get_color_with_alpha(0, left_subpixel_alpha), true);
if (clipped.right() == scanline.right() && right_subpixel_alpha)
set_physical_pixel(clipped.top_right(), get_color_with_alpha(scanline.width(), right_subpixel_alpha), true);
clipped.shrink(0, right_subpixel_alpha > 0, 0, left_subpixel_alpha > 0);
}
if constexpr (has_constant_color) {
if (color.alpha() == 255) {
// Speedy path: Constant color and no alpha blending.
fast_u32_fill(m_target->scanline(clipped.y()) + clipped.x(), color.value(), clipped.width());
return;
}
}
for (int x = clipped.x(); x <= clipped.right(); x++) {
set_physical_pixel({ x, clipped.y() }, get_color(x - scanline.x()), true);
}
}
LibGUI: Add a GPainter class that inherits from Painter. This gets rid of the last little piece of LibGUI knowledge in Painter.
2019-03-28 16:19:56 +00:00
protected:
LibWeb+LibGfx: Migrate (most of) the CSS gradient painting to LibGfx This moves the CSS gradient painting to the painter creating: - Painter::fill_rect_with_linear_gradient() - Painter::fill_rect_with_conic_gradient() - Painter::fill_rect_with_radial_gradient() This has a few benefits: - The gradients can now easily respect the painter scale - The Painter::fill_pixels() escape hatch can be removed - We can remove the old fixed color stop gradient code - The old functions are now just a shim - Anywhere can now easily use this gradient painting code! This only leaves the color stop resolution in LibWeb (which is fine). Just means in LibGfx you have to actually specify color stop positions. (Also while here add a small optimization to avoid generating excessively long gradient lines)
2023-01-10 01:07:06 +00:00
friend GradientLine;
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
IntRect to_physical(IntRect const& r) const { return r.translated(translation()) * scale(); }
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
IntPoint to_physical(IntPoint p) const { return p.translated(translation()) * scale(); }
Meta+Userland: Pass Gfx::Color by value Gfx::Color is always 4 bytes (it's just a wrapper over u32) it's less work just to pass the color directly. This also updates IPCCompiler to prevent from generating Gfx::Color const &, which makes replacement easier.
2022-12-06 19:43:46 +00:00
void set_physical_pixel_with_draw_op(u32& pixel, Color);
void fill_physical_scanline_with_draw_op(int y, int x, int width, Color color);
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
void fill_rect_with_draw_op(IntRect const&, Color);
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
void blit_with_opacity(IntPoint, Gfx::Bitmap const&, IntRect const& src_rect, float opacity, bool apply_alpha = true);
void draw_physical_pixel(IntPoint, Color, int thickness = 1);
LibGfx: Add Painter::fill_pixels() This function fills a region of pixels with the result of a callback function. This is an alternative to a for loop that repeatedly calls Painter::set_pixel(), which can get very expensive due to the clipping checks set_pixel() does each call.
2022-12-24 14:18:53 +00:00
void set_physical_pixel(IntPoint, Color color, bool blend);
Hook up the PS2MouseDevice to the AbstractScreen+WindowManager. Render the mouse cursor by xor'ing the pixels. I don't know anything about hardware cursors yet and this way we don't need to recompose the window hierarchy every time you move the mouse. :^)
2019-01-11 02:52:09 +00:00
SharedGraphics: Give painter a state stack and save()/restore() operations. This will make some painting code a lot less confusing since there's no need to manually undo translations, clips, etc.
2019-03-09 15:48:02 +00:00
struct State {
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
Font const* font;
Revert "LibGfx: Add directional floating-point scaling to Painter" This reverts commit ff76a5b8d2e4dfe007c20a1376cb6862a2c2dbe0.
2021-05-03 14:37:05 +00:00
IntPoint translation;
int scale = 1;
LibGfx/Painter: Keep translation and clip_rect in logical coordinates Moves Painter away from general affine transport support a bit, but this scale factor business does feel like it's a bit different. This is conceptually cleaner (everything should use logical coordinates as much as possible), and it means the code in GUI::Painter() will work without changes due to that, but the draw function implementations overall get a bit murkier (draw_rect() becomes nicer though). Still, feels like the right direction. No behavior change.
2021-01-20 14:59:22 +00:00
IntRect clip_rect;
SharedGraphics: Give painter a state stack and save()/restore() operations. This will make some painting code a lot less confusing since there's no need to manually undo translations, clips, etc.
2019-03-09 15:48:02 +00:00
DrawOp draw_op;
};
State& state() { return m_state_stack.last(); }
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
State const& state() const { return m_state_stack.last(); }
SharedGraphics: Give painter a state stack and save()/restore() operations. This will make some painting code a lot less confusing since there's no need to manually undo translations, clips, etc.
2019-03-09 15:48:02 +00:00
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 13:06:28 +00:00
void fill_physical_rect(IntRect const&, Color);
Revert "LibGfx: Add directional floating-point scaling to Painter" This reverts commit ff76a5b8d2e4dfe007c20a1376cb6862a2c2dbe0.
2021-05-03 14:37:05 +00:00
LibGfx: Rename Rect,Point,Size => IntRect,IntPoint,IntSize This fits nicer with FloatRect,FloatPoint,FloatSize and gives a much better visual clue about what type of metric is being used.
2020-06-10 08:57:59 +00:00
IntRect m_clip_origin;
LibDraw: Put all classes in the Gfx namespace I started adding things to a Draw namespace, but it somehow felt really wrong seeing Draw::Rect and Draw::Bitmap, etc. So instead, let's rename the library to LibGfx. :^)
2020-02-06 10:56:38 +00:00
NonnullRefPtr<Gfx::Bitmap> m_target;
Sprinkle use of AK::Vector in various places. Some of these are less helpful than others. Avoiding a bunch of mallocs in the event loop wakeup code is definitely nice.
2019-04-20 12:02:19 +00:00
Vector<State, 4> m_state_stack;
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:
Vector<DirectionalRun> split_text_into_directional_runs(Utf8View const&, TextDirection initial_direction);
bool text_contains_bidirectional_text(Utf8View const&, TextDirection);
template<typename DrawGlyphFunction>
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 18:42:00 +00:00
void do_draw_text(FloatRect const&, Utf8View const& text, Font const&, TextAlignment, TextElision, TextWrapping, DrawGlyphFunction);
Intense hacking on Widgets.
2018-10-10 14:49:36 +00:00
};
SharedGraphics: Add PainterStateSaver RAII helper and Point::operator-(). Two little things to help tidy up a bit in WSWindowManager.
2019-03-09 15:54:41 +00:00
class PainterStateSaver {
public:
SharedGraphics: Move PainterStateSaver out of line.
2019-04-15 23:01:03 +00:00
explicit PainterStateSaver(Painter&);
~PainterStateSaver();
SharedGraphics: Add PainterStateSaver RAII helper and Point::operator-(). Two little things to help tidy up a bit in WSWindowManager.
2019-03-09 15:54:41 +00:00
private:
Painter& m_painter;
};
LibDraw: Put all classes in the Gfx namespace I started adding things to a Draw namespace, but it somehow felt really wrong seeing Draw::Rect and Draw::Bitmap, etc. So instead, let's rename the library to LibGfx. :^)
2020-02-06 10:56:38 +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
DeprecatedString parse_ampersand_string(StringView, Optional<size_t>* underline_offset = nullptr);
LibGUI+LibGfx: Collapse the '&' from Alt shortcuts in tooltip texts Also resolve a FIXME about using GUI::Label auto-sizing since we're changing this code and it simplifies what we're doing. Fixes #6219.
2021-04-10 23:09:44 +00:00
LibDraw: Put all classes in the Gfx namespace I started adding things to a Draw namespace, but it somehow felt really wrong seeing Draw::Rect and Draw::Bitmap, etc. So instead, let's rename the library to LibGfx. :^)
2020-02-06 10:56:38 +00:00
}
Reference in a new issue Copy permalink