mirrors/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-01-26 03:02:27 -05:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibGfx/Painter.h

205 lines
11 KiB
C
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
/*
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 11:09:48 +02: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 09:38:21 +01:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*/
Intense hacking on Widgets.
2018-10-10 16:49:36 +02:00
#pragma once
LibGfx: More work on header dependency reduction
2020-02-14 23:28:42 +01:00
#include <AK/Forward.h>
LibGfx: Move a bunch of LogStream::operator<< to cpp files
2020-02-15 00:58:14 +01: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 21:41:10 +01:00
#include <AK/Vector.h>
#include <LibGfx/Color.h>
LibGfx: Move other font-related files to LibGfx/Font/
2022-04-09 09:28:38 +02:00
#include <LibGfx/Font/FontDatabase.h>
LibGfx: More work on header dependency reduction
2020-02-14 23:28:42 +01:00
#include <LibGfx/Forward.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 21:41:10 +01:00
#include <LibGfx/Point.h>
#include <LibGfx/Rect.h>
#include <LibGfx/Size.h>
LibGfx: Rename from LibDraw :^)
2020-02-06 12:04:00 +01: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 12:04:00 +01: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>
Intense hacking on Widgets.
2018-10-10 16:49:36 +02: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 11:56:38 +01:00
namespace Gfx {
Intense hacking on Widgets.
2018-10-10 16:49:36 +02:00
class Painter {
public:
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 12:10:47 -05: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 13:26:37 -06: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 11:58:33 +01:00
enum class LineStyle {
Solid,
Dotted,
LibGfx: Add support for dashed lines Non-configurable for now.
2020-05-10 16:17:26 +01: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 11:58:33 +01: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 19:48:56 +01: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 17:16:38 +02: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 19:48:56 +01:00
BilinearBlend,
};
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
void clear_rect(IntRect const&, Color);
void fill_rect(IntRect const&, Color);
void fill_rect_with_dither_pattern(IntRect const&, Color, Color);
void fill_rect_with_checkerboard(IntRect const&, IntSize const&, Color color_dark, Color color_light);
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);
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);
void draw_bitmap(IntPoint const&, CharacterBitmap const&, Color = Color());
void draw_bitmap(IntPoint const&, 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 19:48:56 +01: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 13:00:53 +02: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);
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
void draw_triangle(IntPoint const&, IntPoint const&, IntPoint const&, Color);
LibGUI: Add drawing triangle from coordinate list
2022-06-13 20:03:09 +02:00
void draw_triangle(IntPoint const& offset, Span<IntPoint const>, Color);
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
void draw_ellipse_intersecting(IntRect const&, Color, int thickness = 1);
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(IntPoint const&, Color, bool blend = false);
void set_pixel(int x, int y, Color color, bool blend = false) { set_pixel({ x, y }, color, blend); }
LibGfx: Add Painter::get_pixel() This is required to do some painting tricks in LibWeb, this has to be added to the painter so it can apply the paint translation first.
2022-06-15 21:05:58 +01:00
Optional<Color> get_pixel(IntPoint const&);
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 08:31:29 +01:00
ErrorOr<NonnullRefPtr<Bitmap>> get_region_bitmap(IntRect const&, BitmapFormat format, Optional<IntRect&> actual_region = {});
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
void draw_line(IntPoint const&, IntPoint const&, Color, int thickness = 1, LineStyle style = LineStyle::Solid, Color alternate_color = Color::Transparent);
LibGfx: Add Painter::draw_triangle_wave() This patch adds support for drawing triangular waves. For now those can only be horizontal, but as they are intended for underlining text, it's an okay way to handle this.
2022-01-20 19:55:14 +01:00
void draw_triangle_wave(IntPoint const&, IntPoint const&, Color color, int amplitude, int thickness = 1);
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
void draw_quadratic_bezier_curve(IntPoint const& control_point, IntPoint const&, IntPoint const&, Color, int thickness = 1, LineStyle style = LineStyle::Solid);
LibGfx: Implement cubic bezier curves by splitting them to subcurves This makes them significantly more nicer-looking, and fixes a FIXME :^)
2021-09-17 18:42:30 +04:30
void draw_cubic_bezier_curve(IntPoint const& control_point_0, IntPoint const& control_point_1, IntPoint const&, IntPoint const&, Color, int thickness = 1, LineStyle style = LineStyle::Solid);
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
void draw_elliptical_arc(IntPoint const& p1, IntPoint const& p2, IntPoint const& center, FloatPoint const& radii, float x_axis_rotation, float theta_1, float theta_delta, Color, int thickness = 1, LineStyle style = LineStyle::Solid);
void blit(IntPoint const&, Gfx::Bitmap const&, IntRect const& src_rect, float opacity = 1.0f, bool apply_alpha = true);
void blit_dimmed(IntPoint const&, Gfx::Bitmap const&, IntRect const& src_rect);
void blit_brightened(IntPoint const&, Gfx::Bitmap const&, IntRect const& src_rect);
void blit_filtered(IntPoint const&, Gfx::Bitmap const&, IntRect const& src_rect, Function<Color(Color)>);
void draw_tiled_bitmap(IntRect const& dst_rect, Gfx::Bitmap const&);
void blit_offset(IntPoint const&, Gfx::Bitmap const&, IntRect const& src_rect, IntPoint const&);
void blit_disabled(IntPoint const&, Gfx::Bitmap const&, IntRect const&, Palette const&);
void blit_tiled(IntRect const&, Gfx::Bitmap const&, IntRect const& src_rect);
Everywhere: Pass AK::StringView by value
2021-11-11 00:55:02 +01: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 17:36:28 +04:30
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+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
void draw_text(Function<void(IntRect const&, Utf8CodePointIterator&)>, IntRect const&, StringView, Font const&, TextAlignment = TextAlignment::TopLeft, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
void draw_text(Function<void(IntRect const&, Utf8CodePointIterator&)>, IntRect const&, Utf8View const&, Font const&, TextAlignment = TextAlignment::TopLeft, TextElision = TextElision::None, TextWrapping = TextWrapping::DontWrap);
void draw_text(Function<void(IntRect 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-11 00:55:02 +01:00
void draw_ui_text(Gfx::IntRect const&, StringView, Gfx::Font const&, TextAlignment, Gfx::Color);
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
void draw_glyph(IntPoint const&, u32, Color);
void draw_glyph(IntPoint const&, u32, Font const&, Color);
void draw_emoji(IntPoint const&, Gfx::Bitmap const&, Font const&);
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
void draw_glyph_or_emoji(IntPoint const&, u32, Font const&, Color);
void draw_glyph_or_emoji(IntPoint const&, Utf8CodePointIterator&, Font const&, Color);
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
void draw_circle_arc_intersecting(IntRect const&, IntPoint const&, int radius, Color, int thickness);
Update Painter class to the new coding style.
2019-01-12 17:02:54 +01: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 13:40:48 +02:00
// Streamlined text drawing routine that does no wrapping/elision/alignment.
void draw_text_run(FloatPoint const& baseline_start, Utf8View const&, Font const&, Color);
LibGfx: Add Painter::fill_rect_with_rounded_corners() This paints a rectangle with rounded corners each specified by a radius.
2021-05-15 23:33:21 +02:00
enum class CornerOrientation {
TopLeft,
TopRight,
BottomRight,
BottomLeft
};
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
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 23:33:21 +02:00
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
static void for_each_line_segment_on_bezier_curve(FloatPoint const& control_point, FloatPoint const& p1, FloatPoint const& p2, Function<void(FloatPoint const&, FloatPoint const&)>&);
static void for_each_line_segment_on_bezier_curve(FloatPoint const& control_point, FloatPoint const& p1, FloatPoint const& p2, Function<void(FloatPoint const&, FloatPoint const&)>&&);
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 11:55:12 +04:30
LibGfx: Implement cubic bezier curves by splitting them to subcurves This makes them significantly more nicer-looking, and fixes a FIXME :^)
2021-09-17 18:42:30 +04:30
static void for_each_line_segment_on_cubic_bezier_curve(FloatPoint const& control_point_0, FloatPoint const& control_point_1, FloatPoint const& p1, FloatPoint const& p2, Function<void(FloatPoint const&, FloatPoint const&)>&);
static void for_each_line_segment_on_cubic_bezier_curve(FloatPoint const& control_point_0, FloatPoint const& control_point_1, FloatPoint const& p1, FloatPoint const& p2, Function<void(FloatPoint const&, FloatPoint const&)>&&);
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
static void for_each_line_segment_on_elliptical_arc(FloatPoint const& p1, FloatPoint const& p2, FloatPoint const& center, FloatPoint const radii, float x_axis_rotation, float theta_1, float theta_delta, Function<void(FloatPoint const&, FloatPoint const&)>&);
static void for_each_line_segment_on_elliptical_arc(FloatPoint const& p1, FloatPoint const& p2, FloatPoint const& center, FloatPoint const radii, float x_axis_rotation, float theta_1, float theta_delta, Function<void(FloatPoint const&, FloatPoint const&)>&&);
LibGfx: Add elliptical curves to Path
2020-07-21 23:46:15 -07:00
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
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 21:03:17 +02: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 11:55:12 +04:30
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 13:41:03 +02:00
void fill_path(Path const&, Color, 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 11:55:12 +04:30
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 16:09:38 +01: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 17:36:28 +04:30
void set_font(Font const& font) { state().font = &font; }
Add a simple Font class.
2018-10-11 23:45:57 +02:00
Meta: Tweak .clang-format to not wrap braces after enums.
2019-06-07 17:13:23 +02:00
enum class DrawOp {
WindowServer: Clang-Format
2019-06-05 09:22:11 -07:00
Copy,
LibGfx: Add ability to draw inverted rectangles
2020-09-07 22:25:30 -06:00
Xor,
Invert
WindowServer: Clang-Format
2019-06-05 09:22:11 -07: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 16:48:02 +01: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 03:52:09 +01:00
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
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 23:40:12 +01: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 15:37:23 +01:00
Revert "LibGfx: Add directional floating-point scaling to Painter" This reverts commit ff76a5b8d2e4dfe007c20a1376cb6862a2c2dbe0.
2021-05-03 16:37:05 +02:00
void translate(int dx, int dy) { translate({ dx, dy }); }
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
void translate(IntPoint const& 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 13:13:25 +01:00
LibGfx: Add a way to get the Painter's current 2D translation
2022-10-01 14:04:05 +02: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 11:56:38 +01: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 14:28:39 +01: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 16:48:02 +01:00
void save() { m_state_stack.append(m_state_stack.last()); }
WindowServer: Clang-Format
2019-06-05 09:22:11 -07: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 20:42:32 +01:00
VERIFY(m_state_stack.size() > 1);
WindowServer: Clang-Format
2019-06-05 09:22:11 -07: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 16:48:02 +01: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-15 19:30:47 -07: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 17:19:56 +01:00
protected:
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
IntRect to_physical(IntRect const& r) const { return r.translated(translation()) * scale(); }
IntPoint to_physical(IntPoint const& p) const { return p.translated(translation()) * scale(); }
void set_physical_pixel_with_draw_op(u32& pixel, Color const&);
void fill_physical_scanline_with_draw_op(int y, int x, int width, Color const& color);
void fill_rect_with_draw_op(IntRect const&, Color);
void blit_with_opacity(IntPoint const&, Gfx::Bitmap const&, IntRect const& src_rect, float opacity, bool apply_alpha = true);
void draw_physical_pixel(IntPoint const&, Color, int thickness = 1);
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 03:52:09 +01: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 16:48:02 +01:00
struct State {
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
Font const* font;
Revert "LibGfx: Add directional floating-point scaling to Painter" This reverts commit ff76a5b8d2e4dfe007c20a1376cb6862a2c2dbe0.
2021-05-03 16:37:05 +02: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 09:59:22 -05: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 16:48:02 +01:00
DrawOp draw_op;
};
State& state() { return m_state_stack.last(); }
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
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 16:48:02 +01:00
LibGfx: Switch Painter.{h,cpp} to use east-const
2021-09-17 17:36:28 +04:30
void fill_physical_rect(IntRect const&, Color);
Revert "LibGfx: Add directional floating-point scaling to Painter" This reverts commit ff76a5b8d2e4dfe007c20a1376cb6862a2c2dbe0.
2021-05-03 16:37:05 +02: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 10:57:59 +02: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 11:56:38 +01: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 14:02:19 +02: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>
void do_draw_text(IntRect const&, Utf8View const& text, Font const&, TextAlignment, TextElision, TextWrapping, DrawGlyphFunction);
Intense hacking on Widgets.
2018-10-10 16:49:36 +02:00
};
SharedGraphics: Add PainterStateSaver RAII helper and Point::operator-(). Two little things to help tidy up a bit in WSWindowManager.
2019-03-09 16:54:41 +01:00
class PainterStateSaver {
public:
SharedGraphics: Move PainterStateSaver out of line.
2019-04-16 01:01:03 +02: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 16:54:41 +01: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 11:56:38 +01:00
Everywhere: Pass AK::StringView by value
2021-11-11 00:55:02 +01:00
String 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-11 01:09:44 +02: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 11:56:38 +01:00
}
Reference in a new issue Copy permalink