Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-25 18:34:14 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibWeb/HTML/CanvasRenderingContext2D.h

149 lines
5.6 KiB
C
Raw Normal View History

Meta: Add missing copyright headers
2020-04-06 11:09:01 +02:00
/*
LibGfx: Introduce a new Gfx::Painter with a Skia backend This new painter is written with a virtual interface from the start, and we begin with a Skia backend. This patch adds enough to support our basic 2D HTML canvas usecase.
2024-07-05 15:36:55 +02:00
* Copyright (c) 2020-2024, Andreas Kling <andreas@ladybird.org>
LibWeb: Implement CanvasRenderingContext2D.drawImage() closer to spec Also add support for HTMLCanvasElement for the image parameter, leading to replacing HTMLImageElement with the CanvasImageSource Variant type. Also stub out the 'check the usability of the image argument' and 'is not origin-clean' operations, while taking into consideration that these can throw (and require DOM::ExceptionOr).
2022-03-04 19:02:10 +01:00
* Copyright (c) 2021-2022, Linus Groh <linusg@serenityos.org>
Meta: Add missing copyright headers
2020-04-06 11:09:01 +02: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 missing copyright headers
2020-04-06 11:09:01 +02:00
*/
LibWeb: Add <canvas> element and start fleshing out CRC2D This patch adds HTMLCanvasElement along with a LayoutCanvas object. The DOM and layout parts are very similar to <img> elements. The <canvas> element holds a Gfx::Bitmap which is sized according to the "width" and "height" attributes on the element. Calling .getContext("2d") on a <canvas> element gives you a context object that draws into the underlying Gfx::Bitmap of the <canvas>. The context weakly points to the <canvas> which allows it to outlive the canvas element if needed. This is really quite cool. :^)
2020-03-19 19:07:56 +01:00
#pragma once
LibWeb: Make canvas text preparation handle multi-code point glyphs
2023-02-22 11:48:05 -05:00
#include <AK/String.h>
LibWeb: Implement CanvasRenderingContext2D.drawImage() closer to spec Also add support for HTMLCanvasElement for the image parameter, leading to replacing HTMLImageElement with the CanvasImageSource Variant type. Also stub out the 'check the usability of the image argument' and 'is not origin-clean' operations, while taking into consideration that these can throw (and require DOM::ExceptionOr).
2022-03-04 19:02:10 +01:00
#include <AK/Variant.h>
LibWeb: Use an AffineTransform for CanvasRenderingContext2D :^) This will allow us to support complex 2D transforms.
2020-04-12 19:22:42 +02:00
#include <LibGfx/AffineTransform.h>
LibWeb: Add <canvas> element and start fleshing out CRC2D This patch adds HTMLCanvasElement along with a LayoutCanvas object. The DOM and layout parts are very similar to <img> elements. The <canvas> element holds a Gfx::Bitmap which is sized according to the "width" and "height" attributes on the element. Calling .getContext("2d") on a <canvas> element gives you a context object that draws into the underlying Gfx::Bitmap of the <canvas>. The context weakly points to the <canvas> which allows it to outlive the canvas element if needed. This is really quite cool. :^)
2020-03-19 19:07:56 +01:00
#include <LibGfx/Color.h>
#include <LibGfx/Forward.h>
LibGfx: Introduce a new Gfx::Painter with a Skia backend This new painter is written with a virtual interface from the start, and we begin with a Skia backend. This patch adds enough to support our basic 2D HTML canvas usecase.
2024-07-05 15:36:55 +02:00
#include <LibGfx/Painter.h>
LibGfx+LibWeb: Add new Path class with Skia backend, use for 2D canvas This thing is essentially a wrapper around an SkPath, although we do some indirection via a PathImpl class to keep the door open for alternative rasterizer/path backends in the future. We also update the 2D canvas code, since that was the only code that used Painter+DeprecatedPath, and this allows us to just drop that code instead of temporarily supporting it until the next commit.
2024-08-08 15:12:29 +02:00
#include <LibGfx/Path.h>
LibWeb: Make 2D and 3D canvas rendering contexts GC-allocated
2022-09-02 15:53:02 +02:00
#include <LibWeb/Bindings/PlatformObject.h>
LibWeb: Add initial implementation of CRC2D.globalAlpha Works for fills and strokes (using colors, gradients, or patterns), along with images. fill_rect() has been updated to use fill_path(), which allows it to easily transform the rect, and already supports opacity. Co-authored-by: MacDue <macdue@dueutil.tech>
2023-05-19 22:42:47 +02:00
#include <LibWeb/HTML/Canvas/CanvasCompositing.h>
LibWeb: Extract CanvasDrawImage class from CRC2D
2022-08-12 17:28:54 +01:00
#include <LibWeb/HTML/Canvas/CanvasDrawImage.h>
LibWeb: Extract CanvasDrawPath class from CRC2D Again, this is an entirely virtual class since the methods involve direct access to the Painter. Though, maybe I could just expose the Painter...
2022-08-12 16:52:17 +01:00
#include <LibWeb/HTML/Canvas/CanvasDrawPath.h>
LibWeb: Extract CanvasFillStrokeStyles class from CRC2D
2022-08-12 15:46:31 +01:00
#include <LibWeb/HTML/Canvas/CanvasFillStrokeStyles.h>
LibWeb: Extract CanvasImageData class from CRC2D
2022-08-12 17:37:09 +01:00
#include <LibWeb/HTML/Canvas/CanvasImageData.h>
LibWeb: Implement CRC2D.imageSmoothingEnabled We now select between nearest neighbor and bilinear filtering when scaling images in CRC2D.drawImage(). This patch also adds CRC2D.imageSmoothingQuality but it's ignored for now as we don't have a bunch of different quality levels to map it to. Work towards #17993 (Ruffle Flash Player)
2023-03-29 18:35:02 +02:00
#include <LibWeb/HTML/Canvas/CanvasImageSmoothing.h>
LibWeb: Extract CanvasPath class from CRC2D This better matches the spec, and makes it possible for things like Path2D to reuse the same implementation without duplicate code. :^)
2022-08-11 16:10:04 +01:00
#include <LibWeb/HTML/Canvas/CanvasPath.h>
LibWeb: Extract CanvasPathDrawingStyles class from CRC2D
2022-08-12 17:43:37 +01:00
#include <LibWeb/HTML/Canvas/CanvasPathDrawingStyles.h>
LibWeb: Extract CanvasRect class from CRC2D This one requires drawing to the canvas, so it doesn't make so much sense to move the implementation over.
2022-08-12 16:06:32 +01:00
#include <LibWeb/HTML/Canvas/CanvasRect.h>
LibWeb: Extract CanvasState class from CRC2D As with CanvasPath, this is to better match the spec IDL.
2022-08-12 14:00:00 +01:00
#include <LibWeb/HTML/Canvas/CanvasState.h>
LibWeb: Extract CanvasText class from CRC2D
2022-08-12 19:10:01 +01:00
#include <LibWeb/HTML/Canvas/CanvasText.h>
LibWeb: Add Canvas Context2D basic text align and text baseline support Add the CanvasTextDrawingStyles mixin with the textAlign and textBaseline attributes. Update fill_text in CanvasRenderingContext2D to move the text rect by the text align and text baseline attributes. Wrote a simple HTML example to showcase the new features.
2023-08-03 12:18:17 +02:00
#include <LibWeb/HTML/Canvas/CanvasTextDrawingStyles.h>
LibWeb: Extract CanvasTransform class from CRC2D The implementation of this got a little funky, because it has to access methods from CanvasState.
2022-08-12 14:48:11 +01:00
#include <LibWeb/HTML/Canvas/CanvasTransform.h>
LibWeb: Add barebones CanvasGradient object Also add the CanvasRenderingContext2D APIs to go along with it. Note that it can't be used for anything yet.
2022-02-03 20:08:27 +01:00
#include <LibWeb/HTML/CanvasGradient.h>
LibWeb: Implement CanvasRenderingContext2D.measureText This requires an implementation of the "text preparation algorithm" as specified here: html.spec.whatwg.org/multipage/canvas.html#text-preparation-algorithm However, we're missing a lot of things such as the CanvasTextDrawingStyles interface, so most of the algorithm was not implemented. Additionally, we also are not able to use a LineBox like the algorithm suggests, because our layouting infra is not up to the task yet. The prepare_text function does nothing other than figuring out the width of the given text and return glyphs with offsets at the moment.
2021-12-30 22:15:38 +00:00
#include <LibWeb/Layout/InlineNode.h>
#include <LibWeb/Layout/LineBox.h>
LibWeb: Move ExceptionOr from DOM/ to WebIDL/ This is a concept fully defined in the Web IDL spec and doesn't belong in the DOM directory/namespace - not even DOMException, despite the name :^)
2022-09-25 17:03:42 +01:00
#include <LibWeb/WebIDL/ExceptionOr.h>
LibWeb: Add <canvas> element and start fleshing out CRC2D This patch adds HTMLCanvasElement along with a LayoutCanvas object. The DOM and layout parts are very similar to <img> elements. The <canvas> element holds a Gfx::Bitmap which is sized according to the "width" and "height" attributes on the element. Calling .getContext("2d") on a <canvas> element gives you a context object that draws into the underlying Gfx::Bitmap of the <canvas>. The context weakly points to the <canvas> which allows it to outlive the canvas element if needed. This is really quite cool. :^)
2020-03-19 19:07:56 +01:00
LibWeb: Move HTML classes into the Web::HTML namespace
2020-07-28 18:20:36 +02:00
namespace Web::HTML {
LibWeb: Add <canvas> element and start fleshing out CRC2D This patch adds HTMLCanvasElement along with a LayoutCanvas object. The DOM and layout parts are very similar to <img> elements. The <canvas> element holds a Gfx::Bitmap which is sized according to the "width" and "height" attributes on the element. Calling .getContext("2d") on a <canvas> element gives you a context object that draws into the underlying Gfx::Bitmap of the <canvas>. The context weakly points to the <canvas> which allows it to outlive the canvas element if needed. This is really quite cool. :^)
2020-03-19 19:07:56 +01:00
class CanvasRenderingContext2D
LibWeb: Make 2D and 3D canvas rendering contexts GC-allocated
2022-09-02 15:53:02 +02:00
: public Bindings::PlatformObject
LibWeb: Extract CanvasState class from CRC2D As with CanvasPath, this is to better match the spec IDL.
2022-08-12 14:00:00 +01:00
, public CanvasPath
LibWeb: Extract CanvasTransform class from CRC2D The implementation of this got a little funky, because it has to access methods from CanvasState.
2022-08-12 14:48:11 +01:00
, public CanvasState
LibWeb: Extract CanvasFillStrokeStyles class from CRC2D
2022-08-12 15:46:31 +01:00
, public CanvasTransform<CanvasRenderingContext2D>
LibWeb: Extract CanvasRect class from CRC2D This one requires drawing to the canvas, so it doesn't make so much sense to move the implementation over.
2022-08-12 16:06:32 +01:00
, public CanvasFillStrokeStyles<CanvasRenderingContext2D>
LibWeb: Extract CanvasDrawPath class from CRC2D Again, this is an entirely virtual class since the methods involve direct access to the Painter. Though, maybe I could just expose the Painter...
2022-08-12 16:52:17 +01:00
, public CanvasRect
LibWeb: Extract CanvasText class from CRC2D
2022-08-12 19:10:01 +01:00
, public CanvasDrawPath
LibWeb: Extract CanvasDrawImage class from CRC2D
2022-08-12 17:28:54 +01:00
, public CanvasText
LibWeb: Extract CanvasImageData class from CRC2D
2022-08-12 17:37:09 +01:00
, public CanvasDrawImage
LibWeb: Extract CanvasPathDrawingStyles class from CRC2D
2022-08-12 17:43:37 +01:00
, public CanvasImageData
LibWeb: Implement CRC2D.imageSmoothingEnabled We now select between nearest neighbor and bilinear filtering when scaling images in CRC2D.drawImage(). This patch also adds CRC2D.imageSmoothingQuality but it's ignored for now as we don't have a bunch of different quality levels to map it to. Work towards #17993 (Ruffle Flash Player)
2023-03-29 18:35:02 +02:00
, public CanvasImageSmoothing
LibWeb: Add initial implementation of CRC2D.globalAlpha Works for fills and strokes (using colors, gradients, or patterns), along with images. fill_rect() has been updated to use fill_path(), which allows it to easily transform the rect, and already supports opacity. Co-authored-by: MacDue <macdue@dueutil.tech>
2023-05-19 22:42:47 +02:00
, public CanvasCompositing
LibWeb: Add Canvas Context2D basic text align and text baseline support Add the CanvasTextDrawingStyles mixin with the textAlign and textBaseline attributes. Update fill_text in CanvasRenderingContext2D to move the text rect by the text align and text baseline attributes. Wrote a simple HTML example to showcase the new features.
2023-08-03 12:18:17 +02:00
, public CanvasPathDrawingStyles<CanvasRenderingContext2D>
, public CanvasTextDrawingStyles<CanvasRenderingContext2D> {
LibWeb: Add <canvas> element and start fleshing out CRC2D This patch adds HTMLCanvasElement along with a LayoutCanvas object. The DOM and layout parts are very similar to <img> elements. The <canvas> element holds a Gfx::Bitmap which is sized according to the "width" and "height" attributes on the element. Calling .getContext("2d") on a <canvas> element gives you a context object that draws into the underlying Gfx::Bitmap of the <canvas>. The context weakly points to the <canvas> which allows it to outlive the canvas element if needed. This is really quite cool. :^)
2020-03-19 19:07:56 +01:00
LibWeb: Make 2D and 3D canvas rendering contexts GC-allocated
2022-09-02 15:53:02 +02:00
WEB_PLATFORM_OBJECT(CanvasRenderingContext2D, Bindings::PlatformObject);
LibWeb: Put most LibWeb GC objects in type-specific heap blocks With this change, we now have ~1200 CellAllocators across both LibJS and LibWeb in a normal WebContent instance. This gives us a minimum heap size of 4.7 MiB in the scenario where we only have one cell allocated per type. Of course, in practice there will be many more of each type, so the effective overhead is quite a bit smaller than that in practice. I left a few types unconverted to this mechanism because I got tired of doing this. :^)
2023-11-19 19:47:52 +01:00
JS_DECLARE_ALLOCATOR(CanvasRenderingContext2D);
LibWeb: Add <canvas> element and start fleshing out CRC2D This patch adds HTMLCanvasElement along with a LayoutCanvas object. The DOM and layout parts are very similar to <img> elements. The <canvas> element holds a Gfx::Bitmap which is sized according to the "width" and "height" attributes on the element. Calling .getContext("2d") on a <canvas> element gives you a context object that draws into the underlying Gfx::Bitmap of the <canvas>. The context weakly points to the <canvas> which allows it to outlive the canvas element if needed. This is really quite cool. :^)
2020-03-19 19:07:56 +01:00
public:
LibJS: Make Heap::allocate<T>() infallible Stop worrying about tiny OOMs. Work towards #20449. While going through these, I also changed the function signature in many places where returning ThrowCompletionOr<T> is no longer necessary.
2023-08-13 13:05:26 +02:00
[[nodiscard]] static JS::NonnullGCPtr<CanvasRenderingContext2D> create(JS::Realm&, HTMLCanvasElement&);
LibWeb: Make 2D and 3D canvas rendering contexts GC-allocated
2022-09-02 15:53:02 +02:00
virtual ~CanvasRenderingContext2D() override;
LibWeb: Add <canvas> element and start fleshing out CRC2D This patch adds HTMLCanvasElement along with a LayoutCanvas object. The DOM and layout parts are very similar to <img> elements. The <canvas> element holds a Gfx::Bitmap which is sized according to the "width" and "height" attributes on the element. Calling .getContext("2d") on a <canvas> element gives you a context object that draws into the underlying Gfx::Bitmap of the <canvas>. The context weakly points to the <canvas> which allows it to outlive the canvas element if needed. This is really quite cool. :^)
2020-03-19 19:07:56 +01:00
LibWeb: Extract CanvasRect class from CRC2D This one requires drawing to the canvas, so it doesn't make so much sense to move the implementation over.
2022-08-12 16:06:32 +01:00
virtual void fill_rect(float x, float y, float width, float height) override;
virtual void stroke_rect(float x, float y, float width, float height) override;
virtual void clear_rect(float x, float y, float width, float height) override;
LibWeb: Add CanvasRenderingContext2D.drawImage(image, x, y) This function allows you to draw a loaded <img> element into a canvas.
2020-04-14 20:38:44 +02:00
LibWeb: Move ExceptionOr from DOM/ to WebIDL/ This is a concept fully defined in the Web IDL spec and doesn't belong in the DOM directory/namespace - not even DOMException, despite the name :^)
2022-09-25 17:03:42 +01:00
virtual WebIDL::ExceptionOr<void> draw_image_internal(CanvasImageSource const&, float source_x, float source_y, float source_width, float source_height, float destination_x, float destination_y, float destination_width, float destination_height) override;
LibWeb: Add CanvasRenderingContext2D.drawImage(image, x, y) This function allows you to draw a loaded <img> element into a canvas.
2020-04-14 20:38:44 +02:00
LibWeb: Extract CanvasDrawPath class from CRC2D Again, this is an entirely virtual class since the methods involve direct access to the Painter. Though, maybe I could just expose the Painter...
2022-08-12 16:52:17 +01:00
virtual void begin_path() override;
virtual void stroke() override;
virtual void stroke(Path2D const& path) override;
LibWeb: Generate CanvasRenderingContext2D bindings from IDL :^) We're still missing optional argument support, so this implementation doesn't support fill(), only fill(fill_rule). Still it's really nice to get rid of so much hand-written wrapper code.
2020-06-22 18:39:22 +02:00
LibWeb: Port CanvasRenderingContext2D from DeprecatedString to String
2023-09-06 19:41:48 +12:00
virtual void fill_text(StringView, float x, float y, Optional<double> max_width) override;
virtual void stroke_text(StringView, float x, float y, Optional<double> max_width) override;
LibWeb: Add a naive implemention of CanvasRenderingContext2D::fill_text This doesnt actually account for several unimplemented attributes (like ltr/rtl, alignment, etc) yet, so this should be expanded in the future.
2021-04-15 20:36:10 +03:00
LibWeb: Port CanvasRenderingContext2D from DeprecatedString to String
2023-09-06 19:41:48 +12:00
virtual void fill(StringView fill_rule) override;
virtual void fill(Path2D& path, StringView fill_rule) override;
LibWeb: Add some basic path drawing functionality to the canvas element This patch adds the following methods to CanvasRenderingContext2D: - beginPath() - moveTo(x, y) - lineTo(x, y) - closePath() - stroke() We also add the lineWidth property. :^)
2020-04-16 21:06:03 +02:00
LibWeb: Use correct IDL definition for CanvasImageData methods It is now possible to pass an optional `ImageDataSettings` object to the `CanvasImageData.createImageData()` and `CanvasImageData.getImageData()` methods.
2024-05-15 23:53:29 +01:00
virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> create_image_data(int width, int height, Optional<ImageDataSettings> const& settings = {}) const override;
virtual WebIDL::ExceptionOr<JS::GCPtr<ImageData>> get_image_data(int x, int y, int width, int height, Optional<ImageDataSettings> const& settings = {}) const override;
LibWeb: Extract CanvasImageData class from CRC2D
2022-08-12 17:37:09 +01:00
virtual void put_image_data(ImageData const&, float x, float y) override;
LibWeb: Add ImageData objects and implement 2D context putImageData() An ImageData is a wrapper around a Bitmap wrapper around a JS::Uint8ClampedArray.
2020-04-21 23:49:51 +02:00
LibWeb: Extract CanvasState class from CRC2D As with CanvasPath, this is to better match the spec IDL.
2022-08-12 14:00:00 +01:00
virtual void reset_to_default_state() override;
LibWeb: Implement CanvasRenderingContext2D.save()
2021-12-27 14:31:23 +01:00
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
JS::NonnullGCPtr<HTMLCanvasElement> canvas_for_binding() const;
LibWeb: Add CanvasRenderingContext2D.canvas
2020-05-21 00:09:31 +01:00
LibWeb: Port CanvasRenderingContext2D from DeprecatedString to String
2023-09-06 19:41:48 +12:00
virtual JS::NonnullGCPtr<TextMetrics> measure_text(StringView text) override;
LibWeb: Implement CanvasRenderingContext2D.measureText This requires an implementation of the "text preparation algorithm" as specified here: html.spec.whatwg.org/multipage/canvas.html#text-preparation-algorithm However, we're missing a lot of things such as the CanvasTextDrawingStyles interface, so most of the algorithm was not implemented. Additionally, we also are not able to use a LineBox like the algorithm suggests, because our layouting infra is not up to the task yet. The prepare_text function does nothing other than figuring out the width of the given text and return glyphs with offsets at the moment.
2021-12-30 22:15:38 +00:00
LibWeb: Port CanvasRenderingContext2D from DeprecatedString to String
2023-09-06 19:41:48 +12:00
virtual void clip(StringView fill_rule) override;
virtual void clip(Path2D& path, StringView fill_rule) override;
LibWeb: Implement CanvasRenderingContext2D.transform
2022-04-10 18:46:04 +01:00
LibWeb: Implement CRC2D.imageSmoothingEnabled We now select between nearest neighbor and bilinear filtering when scaling images in CRC2D.drawImage(). This patch also adds CRC2D.imageSmoothingQuality but it's ignored for now as we don't have a bunch of different quality levels to map it to. Work towards #17993 (Ruffle Flash Player)
2023-03-29 18:35:02 +02:00
virtual bool image_smoothing_enabled() const override;
virtual void set_image_smoothing_enabled(bool) override;
virtual Bindings::ImageSmoothingQuality image_smoothing_quality() const override;
virtual void set_image_smoothing_quality(Bindings::ImageSmoothingQuality) override;
LibWeb: Add initial implementation of CRC2D.globalAlpha Works for fills and strokes (using colors, gradients, or patterns), along with images. fill_rect() has been updated to use fill_path(), which allows it to easily transform the rect, and already supports opacity. Co-authored-by: MacDue <macdue@dueutil.tech>
2023-05-19 22:42:47 +02:00
virtual float global_alpha() const override;
virtual void set_global_alpha(float) override;
LibWeb: Add Canvas Context2D basic font property support
2023-08-07 21:48:49 +02:00
HTMLCanvasElement& canvas_element();
HTMLCanvasElement const& canvas_element() const;
LibGfx: Introduce a new Gfx::Painter with a Skia backend This new painter is written with a virtual interface from the start, and we begin with a Skia backend. This patch adds enough to support our basic 2D HTML canvas usecase.
2024-07-05 15:36:55 +02:00
[[nodiscard]] Gfx::Painter* painter();
LibWeb: Add <canvas> element and start fleshing out CRC2D This patch adds HTMLCanvasElement along with a LayoutCanvas object. The DOM and layout parts are very similar to <img> elements. The <canvas> element holds a Gfx::Bitmap which is sized according to the "width" and "height" attributes on the element. Calling .getContext("2d") on a <canvas> element gives you a context object that draws into the underlying Gfx::Bitmap of the <canvas>. The context weakly points to the <canvas> which allows it to outlive the canvas element if needed. This is really quite cool. :^)
2020-03-19 19:07:56 +01:00
private:
LibWeb: Remove unecessary dependence on Window from HTML classes These classes only needed Window to get at its realm. Pass a realm directly to construct HTML classes.
2022-09-25 16:38:21 -06:00
explicit CanvasRenderingContext2D(JS::Realm&, HTMLCanvasElement&);
LibWeb: Make 2D and 3D canvas rendering contexts GC-allocated
2022-09-02 15:53:02 +02:00
LibJS: Make Cell::initialize() return void Stop worrying about tiny OOMs. Work towards #20405
2023-08-07 08:41:28 +02:00
virtual void initialize(JS::Realm&) override;
LibWeb: Make 2D and 3D canvas rendering contexts GC-allocated
2022-09-02 15:53:02 +02:00
virtual void visit_edges(Cell::Visitor&) override;
LibWeb: Add <canvas> element and start fleshing out CRC2D This patch adds HTMLCanvasElement along with a LayoutCanvas object. The DOM and layout parts are very similar to <img> elements. The <canvas> element holds a Gfx::Bitmap which is sized according to the "width" and "height" attributes on the element. Calling .getContext("2d") on a <canvas> element gives you a context object that draws into the underlying Gfx::Bitmap of the <canvas>. The context weakly points to the <canvas> which allows it to outlive the canvas element if needed. This is really quite cool. :^)
2020-03-19 19:07:56 +01:00
LibWeb: Implement CanvasRenderingContext2D.measureText This requires an implementation of the "text preparation algorithm" as specified here: html.spec.whatwg.org/multipage/canvas.html#text-preparation-algorithm However, we're missing a lot of things such as the CanvasTextDrawingStyles interface, so most of the algorithm was not implemented. Additionally, we also are not able to use a LineBox like the algorithm suggests, because our layouting infra is not up to the task yet. The prepare_text function does nothing other than figuring out the width of the given text and return glyphs with offsets at the moment.
2021-12-30 22:15:38 +00:00
struct PreparedTextGlyph {
LibWeb: Make canvas text preparation handle multi-code point glyphs
2023-02-22 11:48:05 -05:00
String glyph;
LibWeb: Implement CanvasRenderingContext2D.measureText This requires an implementation of the "text preparation algorithm" as specified here: html.spec.whatwg.org/multipage/canvas.html#text-preparation-algorithm However, we're missing a lot of things such as the CanvasTextDrawingStyles interface, so most of the algorithm was not implemented. Additionally, we also are not able to use a LineBox like the algorithm suggests, because our layouting infra is not up to the task yet. The prepare_text function does nothing other than figuring out the width of the given text and return glyphs with offsets at the moment.
2021-12-30 22:15:38 +00:00
Gfx::IntPoint position;
};
struct PreparedText {
Vector<PreparedTextGlyph> glyphs;
Gfx::TextAlignment physical_alignment;
Gfx::IntRect bounding_box;
};
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void did_draw(Gfx::FloatRect const&);
LibWeb: Add initial implementation of CRC2D.clip() This allows clipping your drawing by any path you like! To do this all painting has been wrapped around a new draw_clipped() helper method, which handles the clipping before/after painting. Note: This clipping is currently missing support for intersecting clip paths.
2023-04-06 20:57:59 +01:00
LibWeb: Add Canvas Context2D basic font property support
2023-08-07 21:48:49 +02:00
RefPtr<Gfx::Font const> current_font();
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
PreparedText prepare_text(ByteString const& text, float max_width = INFINITY);
LibWeb: Add basic support for requestAnimationFrame() We now support rAF, driven by GUI::DisplayLink callbacks. It's a bit strange how we keep registering new callbacks over and over. That's something we can definitely optimize. This allows you to update animations/whatever without doing it more often than the browser can display.
2020-03-22 21:15:49 +01:00
LibGfx+LibWeb: Add new Path class with Skia backend, use for 2D canvas This thing is essentially a wrapper around an SkPath, although we do some indirection via a PathImpl class to keep the door open for alternative rasterizer/path backends in the future. We also update the 2D canvas code, since that was the only code that used Painter+DeprecatedPath, and this allows us to just drop that code instead of temporarily supporting it until the next commit.
2024-08-08 15:12:29 +02:00
[[nodiscard]] Gfx::Path rect_path(float x, float y, float width, float height);
[[nodiscard]] Gfx::Path text_path(StringView text, float x, float y, Optional<double> max_width);
LibWeb: Add initial implementation of CRC2D.globalAlpha Works for fills and strokes (using colors, gradients, or patterns), along with images. fill_rect() has been updated to use fill_path(), which allows it to easily transform the rect, and already supports opacity. Co-authored-by: MacDue <macdue@dueutil.tech>
2023-05-19 22:42:47 +02:00
LibGfx+LibWeb: Add new Path class with Skia backend, use for 2D canvas This thing is essentially a wrapper around an SkPath, although we do some indirection via a PathImpl class to keep the door open for alternative rasterizer/path backends in the future. We also update the 2D canvas code, since that was the only code that used Painter+DeprecatedPath, and this allows us to just drop that code instead of temporarily supporting it until the next commit.
2024-08-08 15:12:29 +02:00
void stroke_internal(Gfx::Path const&);
void fill_internal(Gfx::Path const&, Gfx::WindingRule);
void clip_internal(Gfx::Path&, Gfx::WindingRule);
LibWeb: Teach CRC2D to draw Path2Ds :^)
2022-08-11 17:39:37 +01:00
LibWeb: Make 2D and 3D canvas rendering contexts GC-allocated
2022-09-02 15:53:02 +02:00
JS::NonnullGCPtr<HTMLCanvasElement> m_element;
LibGfx: Introduce a new Gfx::Painter with a Skia backend This new painter is written with a virtual interface from the start, and we begin with a Skia backend. This patch adds enough to support our basic 2D HTML canvas usecase.
2024-07-05 15:36:55 +02:00
OwnPtr<Gfx::Painter> m_painter;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
LibWeb: Add CanvasRenderingContext2D's origin-clean flag
2022-03-04 18:57:29 +01:00
// https://html.spec.whatwg.org/multipage/canvas.html#concept-canvas-origin-clean
bool m_origin_clean { true };
LibWeb: Add <canvas> element and start fleshing out CRC2D This patch adds HTMLCanvasElement along with a LayoutCanvas object. The DOM and layout parts are very similar to <img> elements. The <canvas> element holds a Gfx::Bitmap which is sized according to the "width" and "height" attributes on the element. Calling .getContext("2d") on a <canvas> element gives you a context object that draws into the underlying Gfx::Bitmap of the <canvas>. The context weakly points to the <canvas> which allows it to outlive the canvas element if needed. This is really quite cool. :^)
2020-03-19 19:07:56 +01:00
};
LibWeb: Implement CanvasRenderingContext2D.drawImage() closer to spec Also add support for HTMLCanvasElement for the image parameter, leading to replacing HTMLImageElement with the CanvasImageSource Variant type. Also stub out the 'check the usability of the image argument' and 'is not origin-clean' operations, while taking into consideration that these can throw (and require DOM::ExceptionOr).
2022-03-04 19:02:10 +01:00
enum class CanvasImageSourceUsability {
Bad,
Good,
};
LibWeb: Move ExceptionOr from DOM/ to WebIDL/ This is a concept fully defined in the Web IDL spec and doesn't belong in the DOM directory/namespace - not even DOMException, despite the name :^)
2022-09-25 17:03:42 +01:00
WebIDL::ExceptionOr<CanvasImageSourceUsability> check_usability_of_image(CanvasImageSource const&);
LibWeb: Implement CanvasRenderingContext2D.drawImage() closer to spec Also add support for HTMLCanvasElement for the image parameter, leading to replacing HTMLImageElement with the CanvasImageSource Variant type. Also stub out the 'check the usability of the image argument' and 'is not origin-clean' operations, while taking into consideration that these can throw (and require DOM::ExceptionOr).
2022-03-04 19:02:10 +01:00
bool image_is_not_origin_clean(CanvasImageSource const&);
LibWeb: Add <canvas> element and start fleshing out CRC2D This patch adds HTMLCanvasElement along with a LayoutCanvas object. The DOM and layout parts are very similar to <img> elements. The <canvas> element holds a Gfx::Bitmap which is sized according to the "width" and "height" attributes on the element. Calling .getContext("2d") on a <canvas> element gives you a context object that draws into the underlying Gfx::Bitmap of the <canvas>. The context weakly points to the <canvas> which allows it to outlive the canvas element if needed. This is really quite cool. :^)
2020-03-19 19:07:56 +01:00
}
Reference in a new issue Copy permalink