Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-03 23:00:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/HTML/HTMLCanvasElement.h

68 lines
2.1 KiB
C
Raw Normal View History

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
/*
Meta: Update my e-mail address everywhere
2024-10-04 13:19:50 +02:00
* Copyright (c) 2020, Andreas Kling <andreas@ladybird.org>
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
*
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
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
#include <AK/ByteBuffer.h>
#include <LibGfx/Forward.h>
LibWeb+LibGfx: Use GPU backend for <canvas> This is implemented by using a GPU-accelerated surface for <canvas> when a GPU context is available. A side effect of this change is that all canvas modifications have to be performed through Gfx::Painter, and whenever its content has to be accessed, we need to take a snapshot of the corresponding GPU surface. A new DrawPaintingSurface display list command is introduced to allow cheap blitting of canvas content without having to read GPU surface content into RAM.
2024-09-25 15:44:58 +02:00
#include <LibGfx/PaintingSurface.h>
LibWeb: Move HTML object model stuff into LibWeb/HTML/ Take a hint from SVG and more all the HTML classes into HTML instead of mixing them with the DOM classes.
2020-07-26 15:08:16 +02:00
#include <LibWeb/HTML/HTMLElement.h>
LibWeb: Limit `HTMLCanvasElement` width and height to allowed values Setting the `width` or `height` properties of `HTMLCanvasElement` to a value greater than 2147483647 will now cause the property to be set to its default value.
2024-11-29 16:04:35 +00:00
#include <LibWeb/WebIDL/Types.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
LibWeb: Make all existing HTML elements "final"
2020-07-28 02:54:19 +01:00
class HTMLCanvasElement final : public HTMLElement {
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
WEB_PLATFORM_OBJECT(HTMLCanvasElement, HTMLElement);
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(HTMLCanvasElement);
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 <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:
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
using RenderingContext = Variant<GC::Root<CanvasRenderingContext2D>, GC::Root<WebGL::WebGLRenderingContext>, Empty>;
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
virtual ~HTMLCanvasElement() override;
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 bitmap_size_for_canvas(size_t minimum_width = 0, size_t minimum_height = 0) 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
LibWeb: Port HTMLCanvasElement interface from DeprecatedString to String
2023-09-03 15:58:55 +12:00
JS::ThrowCompletionOr<RenderingContext> get_context(String const& type, JS::Value options);
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
enum class HasOrCreatedContext {
No,
Yes,
};
HasOrCreatedContext create_2d_context();
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: Limit `HTMLCanvasElement` width and height to allowed values Setting the `width` or `height` properties of `HTMLCanvasElement` to a value greater than 2147483647 will now cause the property to be set to its default value.
2024-11-29 16:04:35 +00:00
WebIDL::UnsignedLong width() const;
WebIDL::UnsignedLong height() const;
LibWeb: Limit the maximum size of <canvas> bitmap buffers We will no longer create bitmap buffers for canvases that exceed a total area of (16384 * 16384) pixels. This matches what some other browser do. Thanks to @itamar8910 for finding this! :^)
2020-04-15 12:12:19 +02:00
LibWeb: Limit `HTMLCanvasElement` width and height to allowed values Setting the `width` or `height` properties of `HTMLCanvasElement` to a value greater than 2147483647 will now cause the property to be set to its default value.
2024-11-29 16:04:35 +00:00
WebIDL::ExceptionOr<void> set_width(WebIDL::UnsignedLong);
WebIDL::ExceptionOr<void> set_height(WebIDL::UnsignedLong);
LibWeb: Allow setting the width & height properties on <canvas> elements
2021-11-13 00:54:21 +01:00
LibWeb: Fix Canvas.toDataURL and Canvas.toBlob signatures Fix the function signatures of Canvas.toDataURL() and Canvas.toBlob() and make both functions accept non-numbers as the quality parameter, in which case it will just use the default quality instead of raising an exception. This makes toDataURL.arguments.1.html, toDataURL.arguments.2.html and toDataURL.jpeg.quality.notnumber.html in wpt/html/semantics/embedded-content/the-canvas-element pass :^)
2024-11-08 09:13:54 +01:00
String to_data_url(StringView type, JS::Value quality);
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
WebIDL::ExceptionOr<void> to_blob(GC::Ref<WebIDL::CallbackType> callback, StringView type, JS::Value quality);
LibWeb: Add basic support for HTMLCanvasElement.toDataURL() :^) This allows you to serialize a <canvas> element's bitmap into a data: URI. Pretty neat! :^)
2021-04-19 23:47:29 +02:00
LibWeb: Add the ability to retrieve a WebGL context from getContext
2022-06-04 04:22:42 +01:00
void present();
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
RefPtr<Gfx::PaintingSurface> surface() const;
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+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
HTMLCanvasElement(DOM::Document&, DOM::QualifiedName);
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 presentational hints to the canvas element There is only one, width/height -> aspect-ratio. This brings us very slightly closer to spec and triggers a re-layout after updating these values from JavaScript, which wasn't the case before.
2023-08-31 19:22:17 +02:00
virtual void apply_presentational_hints(CSS::StyleProperties&) const override;
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 GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
LibWeb: Compute `display: contents` as `none` for unusual elements https://drafts.csswg.org/css-display-3/#unbox-html specifies certain elements that have their `display` style computed as `none` when specified as `contents`. This fixes at least one WPT test: http://wpt.live/css/css-display/display-contents-suppression-dynamic-001.html
2024-11-08 20:14:37 +08:00
virtual void adjust_computed_style(CSS::StyleProperties&) 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: Add the ability to retrieve a WebGL context from getContext
2022-06-04 04:22:42 +01:00
JS::ThrowCompletionOr<HasOrCreatedContext> create_webgl_context(JS::Value options);
void reset_context_to_default_state();
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 notify_context_about_canvas_size_change();
LibWeb: Make 2D and 3D canvas rendering contexts GC-allocated
2022-09-02 15:53:02 +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
Variant<GC::Ref<HTML::CanvasRenderingContext2D>, GC::Ref<WebGL::WebGLRenderingContext>, Empty> m_context;
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