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

206 lines
10 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: Implement simple signed distance field rendering This is mostly a simple grayscale bilinear scale, with an extra step of computing the distance and alpha with a little smoothing. This can be used to paint more scalable UI elements/icons from rather small distance fields. A tiny 16x16 SDF seems to do a decent job for simple icons.
2023-03-21 19:20:00 +00:00
#include <LibGfx/GrayscaleBitmap.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 {
LibGfx: Move Gfx::color_for_format() to header
2024-01-05 23:32:29 +00:00
ALWAYS_INLINE static Color color_for_format(BitmapFormat format, ARGB32 value)
{
switch (format) {
case BitmapFormat::BGRA8888:
return Color::from_argb(value);
case BitmapFormat::BGRx8888:
return Color::from_rgb(value);
// FIXME: Handle other formats
default:
VERIFY_NOT_REACHED();
}
}
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 {
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,
LibGfx: Implement box sampling image scaling Box sampling is a scaling algorithm that averages all the pixels that form the source for the target pixel. For example, if you would resize a 9x9 image to 3x3, each target pixel would encompass a 3x3 pixel area in the source image. Box sampling is a near perfect scaling algorithm for downscaling. When upscaling with this algorithm, the result is similar to nearest neighbor or smooth pixels.
2023-05-18 22:26:34 +00:00
BoxSampling,
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_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 = {});
LibGfx: Add support to draw radial gradients with an rotation angle
2023-04-25 15:45:45 +00:00
void fill_rect_with_radial_gradient(IntRect const&, ReadonlySpan<ColorStop>, IntPoint center, IntSize size, Optional<float> repeat_length = {}, Optional<float> rotation_angle = {});
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);
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, 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 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 blit(IntPoint, Gfx::Bitmap const&, IntRect const& src_rect, float opacity = 1.0f, bool apply_alpha = true);
LibGfx: Add apply_alpha option to Painter::blit_filtered()
2023-07-29 18:33:53 +00:00
void blit_filtered(IntPoint, Gfx::Bitmap const&, IntRect const& src_rect, Function<Color(Color)> const&, bool apply_alpha = true);
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&, Utf32View const&, Font 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);
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);
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);
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_emoji(IntPoint, Gfx::Bitmap const&, Font const&);
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, Font const&, Color);
void draw_glyph_or_emoji(FloatPoint, Utf8CodePointIterator&, Font const&, Color);
LibGfx: Implement simple signed distance field rendering This is mostly a simple grayscale bilinear scale, with an extra step of computing the distance and alpha with a little smoothing. This can be used to paint more scalable UI elements/icons from rather small distance fields. A tiny 16x16 SDF seems to do a decent job for simple icons.
2023-03-21 19:20:00 +00:00
void draw_signed_distance_field(IntRect const& dst_rect, Color, Gfx::GrayscaleBitmap const&, float smoothing);
Update Painter class to the new coding style.
2019-01-12 16:02:54 +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: 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 all fill_path() code member functions and move into .cpp This makes all the code for fill_path() member functions of the painter, and moves them into a new FillPathImplementation.cpp. This allows us to avoid polluting Painter.h with implementation details, and makes the edit, compile, retry loop much shorter.
2023-03-11 16:50:54 +00:00
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);
LibWeb+LibGfx: Allow filling with a paint style and opacity
2023-06-11 12:40:42 +00:00
void fill_path(Path const&, PaintStyle const& paint_style, float opacity = 1.0f, 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
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; }
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: Make all fill_path() code member functions and move into .cpp This makes all the code for fill_path() member functions of the painter, and moves them into a new FillPathImplementation.cpp. This allows us to avoid polluting Painter.h with implementation details, and makes the edit, compile, retry loop much shorter.
2023-03-11 16:50:54 +00:00
friend AntiAliasingPainter;
LibGfx: Implement new antialiased filled path rasterizer This is an implementation of the scanline edge-flag algorithm for antialiased path filling described here: https://mlab.taik.fi/~kkallio/antialiasing/EdgeFlagAA.pdf The initial implementation does not try to implement every possible optimization in favour of keeping things simple. However, it does support: - Both evenodd and nonzero fill rules - Applying paint styles/gradients - A range of samples per pixel (8, 16, 32) - Very nice antialiasing :^) This replaces the previous path filling code, that only really applied antialiasing in the x-axis. There's some very nice improvements around the web with this change, especially for small icons. Strokes are still a bit wonky, as they don't yet use this rasterizer, but I think it should be possible to convert them to do so.
2023-05-31 18:02:00 +00:00
template<unsigned SamplesPerPixel>
friend class EdgeFlagPathRasterizer;
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
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 {
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
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 14:19:34 +00:00
ByteString 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