Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-19 15:43:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/HTML/CanvasRenderingContext2D.h

183 lines
7.4 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>
LibWeb: Add CanvasRenderingContext2D context attribute parsing Makes `context.getContextAttributes()` work.
2025-04-28 16:01:47 +02:00
* Copyright (c) 2025, Jelle Raaijmakers <jelle@ladybird.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: 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/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: Reduced number of recompiled files for CSS property headers This reduces the number of `.cpp` files that need to be recompiled when one of the below header files changes as follows: CSS/ComputedProperties.h: 1113 -> 49 CSS/ComputedValues.h: 1120 -> 209
2025-02-18 09:19:56 +01:00
#include <LibGfx/TextLayout.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+LibGfx: Implement Canvas2D filters
2024-12-18 12:26:37 +01:00
#include <LibWeb/HTML/Canvas/CanvasFilters.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: Factor out CanvasSettings mixin into separate file This refactors this mixin, that was introduced in #4506 to be the same as all other mixins, so that it can be used for #3788
2025-05-13 20:51:41 +02:00
#include <LibWeb/HTML/Canvas/CanvasSettings.h>
LibWeb: Implemented shadows support for CanvasRenderingContext2D
2024-10-18 01:56:58 +03:00
#include <LibWeb/HTML/Canvas/CanvasShadowStyles.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: 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: Implemented shadows support for CanvasRenderingContext2D
2024-10-18 01:56:58 +03:00
, public CanvasShadowStyles<CanvasRenderingContext2D>
LibWeb+LibGfx: Implement Canvas2D filters
2024-12-18 12:26:37 +01:00
, public CanvasFilters
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: Factor out CanvasSettings mixin into separate file This refactors this mixin, that was introduced in #4506 to be the same as all other mixins, so that it can be used for #3788
2025-05-13 20:51:41 +02:00
, public CanvasSettings
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>
LibWeb: Implement basics for OffscreenCanvas This implements the basic interface, classes and functions for OffscreenCanvas. Many are still stubbed out and have many FIXMEs in them, but it is a basic skeleton.
2025-03-07 00:19:45 +01:00
, public CanvasTextDrawingStyles<CanvasRenderingContext2D, HTMLCanvasElement> {
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);
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC_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:
LibWeb: Add CanvasRenderingContext2D context attribute parsing Makes `context.getContextAttributes()` work.
2025-04-28 16:01:47 +02:00
static JS::ThrowCompletionOr<GC::Ref<CanvasRenderingContext2D>> create(JS::Realm&, HTMLCanvasElement&, JS::Value options);
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: Use Utf16String in CanvasText APIs This is prep work for getting rid of UTF-8 text shaping.
2025-09-19 12:21:20 +02:00
virtual void fill_text(Utf16String const&, float x, float y, Optional<double> max_width) override;
virtual void stroke_text(Utf16String const&, 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
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
virtual WebIDL::ExceptionOr<GC::Ref<ImageData>> create_image_data(int width, int height, Optional<ImageDataSettings> const& settings = {}) const override;
virtual WebIDL::ExceptionOr<GC::Ref<ImageData>> create_image_data(ImageData const& image_data) const override;
virtual WebIDL::ExceptionOr<GC::Ptr<ImageData>> get_image_data(int x, int y, int width, int height, Optional<ImageDataSettings> const& settings = {}) const override;
LibWeb: Pass ImageData as non-const to CanvasImageData mixin methods CRC2D needs to manipulate the ImageData object in put_image_data()
2025-04-15 15:51:27 -06:00
virtual void put_image_data(ImageData&, 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
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ref<HTMLCanvasElement> canvas_for_binding() const;
LibWeb: Add CanvasRenderingContext2D.canvas
2020-05-21 00:09:31 +01:00
LibWeb: Factor out CanvasSettings mixin into separate file This refactors this mixin, that was introduced in #4506 to be the same as all other mixins, so that it can be used for #3788
2025-05-13 20:51:41 +02:00
virtual CanvasRenderingContext2DSettings get_context_attributes() const override { return m_context_attributes; }
LibWeb: Add CanvasRenderingContext2D context attribute parsing Makes `context.getContextAttributes()` work.
2025-04-28 16:01:47 +02:00
LibWeb: Use Utf16String in CanvasText APIs This is prep work for getting rid of UTF-8 text shaping.
2025-09-19 12:21:20 +02:00
virtual GC::Ref<TextMetrics> measure_text(Utf16String const&) 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 CanvasDrawPath::isPointInPath()
2024-09-18 10:52:33 +02:00
virtual bool is_point_in_path(double x, double y, StringView fill_rule) override;
virtual bool is_point_in_path(Path2D const& path, double x, double y, StringView fill_rule) override;
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/Canvas: Support `globalCompositionOperation` Canvas now supports compositing and various blending modes via the `globalCompositeOperation` attribute.
2025-01-28 18:19:30 +01:00
virtual String global_composite_operation() const override;
virtual void set_global_composite_operation(String) override;
LibWeb+LibGfx: Implement Canvas2D filters
2024-12-18 12:26:37 +01:00
virtual String filter() const override;
virtual void set_filter(String) override;
LibWeb: Implemented shadows support for CanvasRenderingContext2D
2024-10-18 01:56:58 +03:00
virtual float shadow_offset_x() const override;
virtual void set_shadow_offset_x(float) override;
virtual float shadow_offset_y() const override;
virtual void set_shadow_offset_y(float) override;
LibWeb+LibGfx: Implement shadowBlur for Canvas2D
2024-12-03 21:22:44 +01:00
virtual float shadow_blur() const override;
virtual void set_shadow_blur(float) override;
LibWeb: Implemented shadows support for CanvasRenderingContext2D
2024-10-18 01:56:58 +03:00
virtual String shadow_color() const override;
virtual void set_shadow_color(String) 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: Delegate painting surface allocation to canvas's active context This change prepares for the addition of WebGL support, where painting surface allocation process will differ from that of context2d.
2024-11-29 20:17:25 +01:00
void set_size(Gfx::IntSize const&);
RefPtr<Gfx::PaintingSurface> surface() { return m_surface; }
void allocate_painting_surface_if_needed();
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: Add CanvasRenderingContext2D context attribute parsing Makes `context.getContextAttributes()` work.
2025-04-28 16:01:47 +02:00
CanvasRenderingContext2D(JS::Realm&, HTMLCanvasElement&, CanvasRenderingContext2DSettings);
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: Make 2D canvas save/restore perform save/restore on painter This ensures that any internal state maintained by the painter gets synchronized appropriately.
2024-08-15 14:52:40 +02:00
virtual Gfx::Painter* painter_for_canvas_state() override { return painter(); }
virtual Gfx::Path& path_for_canvas_state() override { return path(); }
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 PreparedText {
LibWeb: Support per-glyph font fallbacks in canvas text measuring
2025-04-20 01:09:10 +02:00
Vector<NonnullRefPtr<Gfx::GlyphRun>> glyph_runs;
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::TextAlignment physical_alignment;
LibWeb: Support per-glyph font fallbacks in canvas text measuring
2025-04-20 01:09:10 +02:00
Gfx::FloatRect bounding_box;
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
};
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: Store FontCascadeList instead of Font in CanvasState This is required to implement per-glyph font fallbacks in the upcoming changes.
2025-04-19 18:34:53 +02:00
RefPtr<Gfx::FontCascadeList const> font_cascade_list();
LibWeb: Add Canvas Context2D basic font property support
2023-08-07 21:48:49 +02:00
LibWeb: Use Utf16String in CanvasText APIs This is prep work for getting rid of UTF-8 text shaping.
2025-09-19 12:21:20 +02:00
PreparedText prepare_text(Utf16String const&, 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);
LibWeb: Use Utf16String in CanvasText APIs This is prep work for getting rid of UTF-8 text shaping.
2025-09-19 12:21:20 +02:00
[[nodiscard]] Gfx::Path text_path(Utf16String const&, 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
LibWeb+LibGfx: Support `alpha` in CanvasRenderingContext2D This is implemented by these related changes: * The Skia alpha type 'Opaque' is selected for surfaces that were created with the intention of not having an alpha channel. Previously we were simply creating one with alpha. * Clearing now happens through Skia's `clear()` which always uses the source color's value for the result, instead of setting all values to 0. * CanvasRenderingContext2D selects a different clearing color based on the `alpha` context attribute's value.
2025-04-28 16:12:30 +02:00
Gfx::Color clear_color() const;
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: Implemented shadows support for CanvasRenderingContext2D
2024-10-18 01:56:58 +03:00
void paint_shadow_for_fill_internal(Gfx::Path const&, Gfx::WindingRule);
void paint_shadow_for_stroke_internal(Gfx::Path const&);
LibWeb: Teach CRC2D to draw Path2Ds :^)
2022-08-11 17:39:37 +01:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ref<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: Delegate painting surface allocation to canvas's active context This change prepares for the addition of WebGL support, where painting surface allocation process will differ from that of context2d.
2024-11-29 20:17:25 +01:00
Gfx::IntSize m_size;
RefPtr<Gfx::PaintingSurface> m_surface;
LibWeb: Add CanvasRenderingContext2D context attribute parsing Makes `context.getContextAttributes()` work.
2025-04-28 16:01:47 +02:00
CanvasRenderingContext2DSettings m_context_attributes;
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