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

72 lines
2.6 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 <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:
LibWeb: Add stubbed-out WebGL2RenderingContext
2024-12-05 20:56:18 -07:00
using RenderingContext = Variant<GC::Root<CanvasRenderingContext2D>, GC::Root<WebGL::WebGLRenderingContext>, GC::Root<WebGL::WebGL2RenderingContext>, 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,
};
LibWeb: Add CanvasRenderingContext2D context attribute parsing Makes `context.getContextAttributes()` work.
2025-04-28 16:01:47 +02:00
JS::ThrowCompletionOr<HasOrCreatedContext> create_2d_context(JS::Value options);
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: Notify canvas context when width or height attribute is changed
2024-12-28 15:47:58 +11:00
virtual void attribute_changed(FlyString const& local_name, Optional<String> const& old_value, Optional<String> const& value, Optional<FlyString> const& namespace_) override;
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 get_bitmap_from_surface() and use it from to_blob() This refactors out the reading part of Gfx::Bitmap from HtmlCanvasElement::surface(). We can then reuse this from WindowOrWorkerGlobalScopeMixin::create_image_bitmap_impl() when we create an ImageBitmap from a HtmlCanvasElement.
2025-07-14 21:24:22 +02:00
RefPtr<Gfx::Bitmap> get_bitmap_from_surface();
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: Avoid many style invalidations on DOM attribute mutation Many times, attribute mutation doesn't necessitate a full style invalidation on the element. However, the conditions are pretty elaborate, so this first version has a lot of false positives. We only need to invalidate style when any of these things apply: 1. The change may affect the match state of a selector somewhere. 2. The change may affect presentational hints applied to the element. For (1) in this first version, we have a fixed list of attribute names that may affect selectors. We also collect all names referenced by attribute selectors anywhere in the document. For (2), we add a new Element::is_presentational_hint() virtual that tells us whether a given attribute name is a presentational hint. This drastically reduces style work on many websites. As an example, https://cnn.com/ is once again browseable.
2024-12-23 17:51:10 +01:00
virtual bool is_presentational_hint(FlyString const&) const override;
LibWeb: Split StyleComputer work into two phases with separate outputs Before this change, StyleComputer would essentially take a DOM element, find all the CSS rules that apply to it, and resolve the computed value for each CSS property for that element. This worked great, but it meant we had to do all the work of selector matching and cascading every time. To enable new optimizations, this change introduces a break in the middle of this process where we've produced a "CascadedProperties". This object contains the result of the cascade, before we've begun turning cascaded values into computed values. The cascaded properties are now stored with each element, which will later allow us to do partial updates without re-running the full StyleComputer machine. This will be particularly valuable for re-implementing CSS inheritance, which is extremely heavy today. Note that CSS animations and CSS transitions operate entirely on the computed values, even though the cascade order would have you believe they happen earlier. I'm not confident we have the right architecture for this, but that's a separate issue.
2024-12-12 10:06:29 +01:00
virtual void apply_presentational_hints(GC::Ref<CSS::CascadedProperties>) const 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
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
virtual GC::Ptr<Layout::Node> create_layout_node(GC::Ref<CSS::ComputedProperties>) override;
LibWeb: Rename CSS::StyleProperties => CSS::ComputedProperties Now that StyleProperties is only used to hold computed properties, let's name it ComputedProperties.
2024-12-20 11:32:17 +01:00
virtual void adjust_computed_style(CSS::ComputedProperties&) 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 stubbed-out WebGL2RenderingContext
2024-12-05 20:56:18 -07:00
template<typename ContextType>
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
LibWeb: Add stubbed-out WebGL2RenderingContext
2024-12-05 20:56:18 -07:00
Variant<GC::Ref<HTML::CanvasRenderingContext2D>, GC::Ref<WebGL::WebGLRenderingContext>, GC::Ref<WebGL::WebGL2RenderingContext>, 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