dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/Libraries/LibWeb/HTML/HTMLImageElement.h

182 lines
6.6 KiB
C
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 05:38:21 -03:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 08:19:50 -03:00
* Copyright (c) 2018-2023, Andreas Kling <andreas@ladybird.org>
LibGfx+LibWeb: Cache SkImage in ImmutableBitmap By caching the SkImage that is reused across repaints, we allow Skia t optimize GPU texture caching. ImmutableBitmap is chosen to own the SkImage because it guarantees that the underlying pixels cannot be modified. This is not the case for Gfx::Bitmap, where invalidating the SkImage would be challenging since it exposes pointers to underlying data through methods like scanline().
2024-11-09 01:48:17 -03:00
* Copyright (c) 2024, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 05:38:21 -03: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 05:24:48 -03:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 05:38:21 -03:00
*/
LibHTML: Flesh out <img> element with LayoutImage and LayoutReplaced This patch adds parsing of <img> into HTMLImageElement objects. It also adds LayoutImage and its parent class LayoutReplaced, which is going to represent CSS "replaced elements."
2019-10-05 17:07:45 -03:00
#pragma once
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 17:41:10 -03:00
#include <AK/ByteBuffer.h>
LibWeb: Split out image loading logic from HTMLImageElement Since more DOM nodes are going to want to load images (<object>, ...) this patch splits out the image loading logic into an ImageLoader class and then HTMLImageElement simply has an ImageLoader. LayoutImage is then given a const ImageLoader& at construction and can then provide layout and rendering for many kinds of DOM nodes.
2020-06-13 17:22:54 -03:00
#include <AK/OwnPtr.h>
LibGfx: More work on header dependency reduction
2020-02-14 19:28:42 -03:00
#include <LibGfx/Forward.h>
LibGfx+LibWeb: Add ImmutableBitmap for images bitmap caching in painter Before this change, we used Gfx::Bitmap to represent both decoded images that are not going to be mutated and bitmaps corresponding to canvases that could be mutated. This change introduces a wrapper for bitmaps that are not going to be mutated, so the painter could do caching: texture caching in the case of GPU painter and potentially scaled bitmap caching in the case of CPU painter.
2023-11-24 10:45:45 -03:00
#include <LibGfx/ImmutableBitmap.h>
LibWeb: Use JS::HeapFunction for resumption steps in HTMLImageElement
2023-09-25 13:47:34 -03:00
#include <LibJS/Heap/HeapFunction.h>
LibWeb: Move viewport subscriptions from BrowsingContext to Document With this change, elements that want to receive viewport rect updates will need to register on document instead of the browsing context. This change solves the problem where a browsing context for a document is guaranteed to exist only while the document is active so browsing context might not exit by the time DOM node that want to register is constructed. This is a part of preparation work before switching to navigables where this issue becomes more visible.
2023-08-23 13:58:42 -03:00
#include <LibWeb/DOM/Document.h>
LibWeb: Make HTMLImageElement loads delay the document load event This is something we're supposed to do according to the HTML spec. Note that image loading is currently completely ad-hoc, and this just adds a simple DocumentLoadEventDelayer to the existing implementation. This will allow us to use images in layout tests, which rely on the document load event firing at a predictable time.
2023-04-01 10:15:23 -03:00
#include <LibWeb/DOM/DocumentLoadEventDelayer.h>
LibWeb: Make responsive images react to changes in size viewport This patch implements "react to changes in the environment" from the HTML spec and hooks HTMLImageElement up with viewport rect change notifications (from the browsing context). This fixes the issue where we'd load a low-resolution image and not switch to a high-resolution image after resizing the window.
2023-07-29 05:20:53 -03:00
#include <LibWeb/HTML/BrowsingContext.h>
LibWeb: Implement enough of "update the image data" to load images This first pass is enough to get us: - Image loading via fetch - Source selection via srcset and sizes attributes
2023-05-11 14:23:36 -03:00
#include <LibWeb/HTML/CORSSettingAttribute.h>
LibWeb: Make FormAssociatedElement inherit from HTMLElement The new event target implementation requires us to downcast an EventTarget to a FormAssociatedElement to check if the current Element EventTarget has a form owner to setup a with scope for the form owner. This also makes all form associated elements inherit from FormAssociatedElement where it was previously missing. https://html.spec.whatwg.org/#form-associated-element
2021-10-14 12:18:49 -03:00
#include <LibWeb/HTML/FormAssociatedElement.h>
LibWeb: Remove inheritance of FormAssociatedElement from HTMLElement HTMLObjectElement will need to be both a FormAssociatedElement and a BrowsingContextContainer. Currently, both of these classes inherit from HTMLElement. This can work in C++, but is generally frowned upon, and doesn't play particularly well with the rest of LibWeb. Instead, we can essentially revert commit 3bb5c62 to remove HTMLElement from FormAssociatedElement's hierarchy. This means that objects such as HTMLObjectElement individually inherit from FormAssociatedElement and HTMLElement now. Some caveats are: * FormAssociatedElement still needs to know when the HTMLElement is inserted into and removed from the DOM. This hook is automatically injected via a macro now, while still allowing classes like HTMLInputElement to also know when the element is inserted. * Casting from a DOM::Element to a FormAssociatedElement is now a sideways cast, rather than directly following an inheritance chain. This means static_cast cannot be used here; but we can safely use dynamic_cast since the only 2 instances of this already use RTTI to verify the cast.
2022-03-23 19:55:54 -03:00
#include <LibWeb/HTML/HTMLElement.h>
LibWeb: Extract shared lazy-loading behavior into a base class `<iframe>` and `<img>` tags share the same spec for several aspects of lazy-loading: how the `loading` attribute works, the "will lazy load element" steps, and a member for storing the lazy-load resumption steps. So let's share the implementation by using a base class. This mostly involves moving things around. However, we also change the `start_intersection_observing_a_lazy_loading_element()` method to take a LazyLoadingElement, and operate on one, instead of always casting to HTMLImageElement. We do unfortunately have to do some shenanigans to make the cast work, by adding a virtual function stub in DOM::Element.
2023-11-21 15:50:09 -03:00
#include <LibWeb/HTML/LazyLoadingElement.h>
LibWeb: Implement enough of "update the image data" to load images This first pass is enough to get us: - Image loading via fetch - Source selection via srcset and sizes attributes
2023-05-11 14:23:36 -03:00
#include <LibWeb/HTML/SourceSet.h>
LibWeb: Don't force HTMLImageElement to have a legacy ImageLoader We achieve this by adding a new Layout::ImageProvider class and having both HTMLImageElement and HTMLObjectElement inherit from it. The HTML spec is vague on how object image loading should work, which is why this first pass is focusing on image elements.
2023-05-12 02:17:01 -03:00
#include <LibWeb/Layout/ImageProvider.h>
LibHTML: Flesh out <img> element with LayoutImage and LayoutReplaced This patch adds parsing of <img> into HTMLImageElement objects. It also adds LayoutImage and its parent class LayoutReplaced, which is going to represent CSS "replaced elements."
2019-10-05 17:07:45 -03:00
LibWeb: Move HTML classes into the Web::HTML namespace
2020-07-28 13:20:36 -03:00
namespace Web::HTML {
LibHTML: Mark image bitmaps outside the visible viewport as volatile When the visible viewport rect changes, we walk the layout tree and check where each LayoutImage is in relation to the viewport rect. Images outside have their bitmaps marked as volatile. Note that the bitmaps are managed by ImageDecoder objects. If a bitmap is purged by the kernel while volatile, we construct a new ImageDecoder next time we need pixels for the image.
2019-12-18 16:57:18 -03:00
LibWeb: Remove inheritance of FormAssociatedElement from HTMLElement HTMLObjectElement will need to be both a FormAssociatedElement and a BrowsingContextContainer. Currently, both of these classes inherit from HTMLElement. This can work in C++, but is generally frowned upon, and doesn't play particularly well with the rest of LibWeb. Instead, we can essentially revert commit 3bb5c62 to remove HTMLElement from FormAssociatedElement's hierarchy. This means that objects such as HTMLObjectElement individually inherit from FormAssociatedElement and HTMLElement now. Some caveats are: * FormAssociatedElement still needs to know when the HTMLElement is inserted into and removed from the DOM. This hook is automatically injected via a macro now, while still allowing classes like HTMLInputElement to also know when the element is inserted. * Casting from a DOM::Element to a FormAssociatedElement is now a sideways cast, rather than directly following an inheritance chain. This means static_cast cannot be used here; but we can safely use dynamic_cast since the only 2 instances of this already use RTTI to verify the cast.
2022-03-23 19:55:54 -03:00
class HTMLImageElement final
: public HTMLElement
LibWeb: Don't force HTMLImageElement to have a legacy ImageLoader We achieve this by adding a new Layout::ImageProvider class and having both HTMLImageElement and HTMLObjectElement inherit from it. The HTML spec is vague on how object image loading should work, which is why this first pass is focusing on image elements.
2023-05-12 02:17:01 -03:00
, public FormAssociatedElement
LibWeb: Extract shared lazy-loading behavior into a base class `<iframe>` and `<img>` tags share the same spec for several aspects of lazy-loading: how the `loading` attribute works, the "will lazy load element" steps, and a member for storing the lazy-load resumption steps. So let's share the implementation by using a base class. This mostly involves moving things around. However, we also change the `start_intersection_observing_a_lazy_loading_element()` method to take a LazyLoadingElement, and operate on one, instead of always casting to HTMLImageElement. We do unfortunately have to do some shenanigans to make the cast work, by adding a virtual function stub in DOM::Element.
2023-11-21 15:50:09 -03:00
, public LazyLoadingElement<HTMLImageElement>
LibWeb: Make responsive images react to changes in size viewport This patch implements "react to changes in the environment" from the HTML spec and hooks HTMLImageElement up with viewport rect change notifications (from the browsing context). This fixes the issue where we'd load a low-resolution image and not switch to a high-resolution image after resizing the window.
2023-07-29 05:20:53 -03:00
, public Layout::ImageProvider
LibWeb: Move viewport subscriptions from BrowsingContext to Document With this change, elements that want to receive viewport rect updates will need to register on document instead of the browsing context. This change solves the problem where a browsing context for a document is guaranteed to exist only while the document is active so browsing context might not exit by the time DOM node that want to register is constructed. This is a part of preparation work before switching to navigables where this issue becomes more visible.
2023-08-23 13:58:42 -03:00
, public DOM::Document::ViewportClient {
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 08:42:07 -03:00
WEB_PLATFORM_OBJECT(HTMLImageElement, HTMLElement);
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 15:47:52 -03:00
JS_DECLARE_ALLOCATOR(HTMLImageElement);
LibWeb: Extract shared lazy-loading behavior into a base class `<iframe>` and `<img>` tags share the same spec for several aspects of lazy-loading: how the `loading` attribute works, the "will lazy load element" steps, and a member for storing the lazy-load resumption steps. So let's share the implementation by using a base class. This mostly involves moving things around. However, we also change the `start_intersection_observing_a_lazy_loading_element()` method to take a LazyLoadingElement, and operate on one, instead of always casting to HTMLImageElement. We do unfortunately have to do some shenanigans to make the cast work, by adding a virtual function stub in DOM::Element.
2023-11-21 15:50:09 -03:00
FORM_ASSOCIATED_ELEMENT(HTMLElement, HTMLImageElement);
LAZY_LOADING_ELEMENT(HTMLImageElement);
LibWeb: Remove inheritance of FormAssociatedElement from HTMLElement HTMLObjectElement will need to be both a FormAssociatedElement and a BrowsingContextContainer. Currently, both of these classes inherit from HTMLElement. This can work in C++, but is generally frowned upon, and doesn't play particularly well with the rest of LibWeb. Instead, we can essentially revert commit 3bb5c62 to remove HTMLElement from FormAssociatedElement's hierarchy. This means that objects such as HTMLObjectElement individually inherit from FormAssociatedElement and HTMLElement now. Some caveats are: * FormAssociatedElement still needs to know when the HTMLElement is inserted into and removed from the DOM. This hook is automatically injected via a macro now, while still allowing classes like HTMLInputElement to also know when the element is inserted. * Casting from a DOM::Element to a FormAssociatedElement is now a sideways cast, rather than directly following an inheritance chain. This means static_cast cannot be used here; but we can safely use dynamic_cast since the only 2 instances of this already use RTTI to verify the cast.
2022-03-23 19:55:54 -03:00
LibHTML: Flesh out <img> element with LayoutImage and LayoutReplaced This patch adds parsing of <img> into HTMLImageElement objects. It also adds LayoutImage and its parent class LayoutReplaced, which is going to represent CSS "replaced elements."
2019-10-05 17:07:45 -03:00
public:
virtual ~HTMLImageElement() override;
LibWeb: Reset form association when the element's form attribute changes
2024-02-03 11:33:33 -03:00
virtual void form_associated_element_attribute_changed(FlyString const& name, Optional<String> const& value) override;
LibHTML: Load image resource when src attribute is set
2019-10-06 09:03:51 -03:00
LibWeb: Add an alternative_text() getter This change adds an alternative_text()·getter, for use in computing accessible names.
2024-11-09 11:45:09 -03:00
Optional<String> alternative_text() const override
{
if (auto alt = get_attribute(HTML::AttributeNames::alt); alt.has_value())
return alt.release_value();
return {};
}
LibWeb: Remove DOM element deprecated_get_attribute()
2024-01-16 15:04:45 -03:00
String alt() const { return get_attribute_value(HTML::AttributeNames::alt); }
String src() const { return get_attribute_value(HTML::AttributeNames::src); }
LibHTML: Implement basic layout for inline <img alt> LayoutReplaced objects can now participate in inline layout. It's very hackish, but basically LayoutReplaced will just add itself to the last line in the containing block. This patch gets rid of the idea that only LayoutInline subclasses can be split into lines, by moving the split_into_lines() virtual up to LayoutNode and overriding it in LayoutReplaced.
2019-10-05 18:20:35 -03:00
LibGfx+LibWeb: Add ImmutableBitmap for images bitmap caching in painter Before this change, we used Gfx::Bitmap to represent both decoded images that are not going to be mutated and bitmaps corresponding to canvases that could be mutated. This change introduces a wrapper for bitmaps that are not going to be mutated, so the painter could do caching: texture caching in the case of GPU painter and potentially scaled bitmap caching in the case of CPU painter.
2023-11-24 10:45:45 -03:00
RefPtr<Gfx::ImmutableBitmap> immutable_bitmap() const;
LibHTML: Support rendering <img src> with file:// URLs We can now show images loaded from local file:// URLs. Pretty neat :^)
2019-10-05 18:41:14 -03:00
LibWeb: Implement HTMLImageElement.width and HTMLImageElement.height
2022-02-25 14:42:37 -03:00
unsigned width() const;
LibWeb: Return DOMException instead of crashing when setting attributes
2023-05-25 16:37:57 -03:00
WebIDL::ExceptionOr<void> set_width(unsigned);
LibWeb: Implement HTMLImageElement.width and HTMLImageElement.height
2022-02-25 14:42:37 -03:00
unsigned height() const;
LibWeb: Return DOMException instead of crashing when setting attributes
2023-05-25 16:37:57 -03:00
WebIDL::ExceptionOr<void> set_height(unsigned);
LibWeb: Implement HTMLImageElement.width and HTMLImageElement.height
2022-02-25 14:42:37 -03:00
LibWeb: Bring HTMLImageElement closer to spec
2022-04-12 13:20:43 -03:00
unsigned natural_width() const;
unsigned natural_height() const;
LibWeb: Implement HTMLImageElement.complete This was fairly straightforward, although a small part had to be ad-hoc since we don't yet load images through Fetch. With this, we can now see annotation labels on deskto.ps :^)
2022-10-03 09:54:27 -03:00
// https://html.spec.whatwg.org/multipage/embedded-content.html#dom-img-complete
bool complete() const;
LibWeb: Implement HTMLImageElement.currentSrc Removes some console noise from lner.co.uk :)
2024-05-23 20:08:03 -03:00
// https://html.spec.whatwg.org/multipage/embedded-content.html#dom-img-currentsrc
String current_src() const;
LibWeb: Implement HTMLImageElement::decode with a few FIXMEs Implements enough of HTMLImageElement::decode for it to not break websites and actually load an image :)
2024-06-05 18:15:26 -03:00
// https://html.spec.whatwg.org/multipage/embedded-content.html#dom-img-decode
LibWeb: Move JS::Promise <-> WebIDL conversion into IDL This change also removes as much direct use of JS::Promise in LibWeb as possible. When specs refer to `Promise<T>` they should be assumed to be referring to the WebIDL Promise type, not the JS::Promise type. The one exception is the HostPromiseRejectionTracker hook on the JS VM. This facility and its associated sets and events are intended to expose the exact opaque object handles that were rejected to author code. This is not possible with the WebIDL Promise type, so we have to use JS::Promise or JS::Object to hold onto the promises. It also exposes which specs need some updates in the area of promises. WebDriver stands out in this regard. WebAudio could use some more cross-references to WebIDL as well to clarify things.
2024-10-25 15:38:19 -03:00
[[nodiscard]] WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> decode() const;
LibWeb: Implement HTMLImageElement::decode with a few FIXMEs Implements enough of HTMLImageElement::decode for it to not break websites and actually load an image :)
2024-06-05 18:15:26 -03:00
LibWeb: Move ARIA-related code into the Web::ARIA namespace ARIA has its own spec and is not part of the DOM spec, which is what the Web::DOM namespace is for (https://www.w3.org/TR/wai-aria-1.2/). This allows us to stay closer to the spec with function names and don't have to add the word "ARIA" to identifiers constantly - the namespace now provides that clarity.
2023-01-28 19:23:16 -03:00
virtual Optional<ARIA::Role> default_role() const override;
LibWeb: Add Support for the ARIA Element Properties Element now supports getting and setting ARIA properties from JS and HTML.
2022-11-28 20:58:13 -03:00
LibWeb: Make responsive images react to changes in size viewport This patch implements "react to changes in the environment" from the HTML spec and hooks HTMLImageElement up with viewport rect change notifications (from the browsing context). This fixes the issue where we'd load a low-resolution image and not switch to a high-resolution image after resizing the window.
2023-07-29 05:20:53 -03:00
// https://html.spec.whatwg.org/multipage/images.html#img-environment-changes
void react_to_changes_in_the_environment();
LibWeb: Implement enough of "update the image data" to load images This first pass is enough to get us: - Image loading via fetch - Source selection via srcset and sizes attributes
2023-05-11 14:23:36 -03:00
// https://html.spec.whatwg.org/multipage/images.html#update-the-image-data
LibWeb: Update HTML image loading algorithm for recent spec changes Changes: https://github.com/whatwg/html/commit/8a2375aac23f88137922c820cf12650364b72715 Note that we don't support the full lazy loading machinery yet, so this isn't actually hooked up.
2023-06-11 03:08:44 -03:00
ErrorOr<void> update_the_image_data(bool restart_the_animations = false, bool maybe_omit_events = false);
LibWeb: Implement enough of "update the image data" to load images This first pass is enough to get us: - Image loading via fetch - Source selection via srcset and sizes attributes
2023-05-11 14:23:36 -03:00
// https://html.spec.whatwg.org/multipage/images.html#use-srcset-or-picture
[[nodiscard]] bool uses_srcset_or_picture() const;
// https://html.spec.whatwg.org/multipage/rendering.html#restart-the-animation
void restart_the_animation();
// https://html.spec.whatwg.org/multipage/images.html#select-an-image-source
[[nodiscard]] Optional<ImageSourceAndPixelDensity> select_an_image_source();
HTMLImageElement: Improve decoding stub Add an enum and warn when setting to sync/async.
2024-09-02 08:46:27 -03:00
StringView decoding() const;
void set_decoding(String);
LibWeb: Implement enough of "update the image data" to load images This first pass is enough to get us: - Image loading via fetch - Source selection via srcset and sizes attributes
2023-05-11 14:23:36 -03:00
void set_source_set(SourceSet);
ImageRequest& current_request() { return *m_current_request; }
ImageRequest const& current_request() const { return *m_current_request; }
size_t current_frame_index() const { return m_current_frame_index; }
// https://html.spec.whatwg.org/multipage/images.html#upgrade-the-pending-request-to-the-current-request
void upgrade_pending_request_to_current_request();
LibWeb/HTML: Implement HTMLImageElement::allows_auto_sizes()
2024-09-11 10:06:08 -03:00
// https://html.spec.whatwg.org/multipage/embedded-content.html#allows-auto-sizes
bool allows_auto_sizes() const;
LibWeb: Don't force HTMLImageElement to have a legacy ImageLoader We achieve this by adding a new Layout::ImageProvider class and having both HTMLImageElement and HTMLObjectElement inherit from it. The HTML spec is vague on how object image loading should work, which is why this first pass is focusing on image elements.
2023-05-12 02:17:01 -03:00
// ^Layout::ImageProvider
LibWeb: Generalize ImageBox and ImagePaintable for any ImageProvider They currently assume the DOM node is an HTMLImageElement with respect to handling the alt attribute. The HTMLInputElement will require the same behavior.
2024-02-18 22:10:37 -03:00
virtual bool is_image_available() const override;
LibWeb: Make ImageBox ask ImageProvider for intrinsic size and ratio This paves the way for ImageProvider to have something vector-based underneath. :^)
2023-05-20 11:27:31 -03:00
virtual Optional<CSSPixels> intrinsic_width() const override;
virtual Optional<CSSPixels> intrinsic_height() const override;
LibWeb: Use `CSSPixelFraction` to represent aspect ratios This allows us to retain perfect precision for aspect ratios derived from either the intrinsic sizes of replaced elements, or the `aspect-ratio` CSS property.
2023-09-03 19:33:58 -03:00
virtual Optional<CSSPixelFraction> intrinsic_aspect_ratio() const override;
LibGfx+LibWeb: Add ImmutableBitmap for images bitmap caching in painter Before this change, we used Gfx::Bitmap to represent both decoded images that are not going to be mutated and bitmaps corresponding to canvases that could be mutated. This change introduces a wrapper for bitmaps that are not going to be mutated, so the painter could do caching: texture caching in the case of GPU painter and potentially scaled bitmap caching in the case of CPU painter.
2023-11-24 10:45:45 -03:00
virtual RefPtr<Gfx::ImmutableBitmap> current_image_bitmap(Gfx::IntSize = {}) const override;
LibWeb: Don't force HTMLImageElement to have a legacy ImageLoader We achieve this by adding a new Layout::ImageProvider class and having both HTMLImageElement and HTMLObjectElement inherit from it. The HTML spec is vague on how object image loading should work, which is why this first pass is focusing on image elements.
2023-05-12 02:17:01 -03:00
virtual void set_visible_in_viewport(bool) override;
LibWeb: Visit ImageProvider from Layout::ImageBox Adds missing visit of HTMLElement that serves as image provider of image layout node.
2024-02-26 13:36:48 -03:00
virtual JS::NonnullGCPtr<DOM::Element const> to_html_element() const override { return *this; }
LibWeb: Don't force HTMLImageElement to have a legacy ImageLoader We achieve this by adding a new Layout::ImageProvider class and having both HTMLImageElement and HTMLObjectElement inherit from it. The HTML spec is vague on how object image loading should work, which is why this first pass is focusing on image elements.
2023-05-12 02:17:01 -03:00
LibWeb: Make HTML::ImageRequest GC allocated
2023-08-18 07:56:21 -03:00
virtual void visit_edges(Cell::Visitor&) override;
LibHTML: Implement basic layout for inline <img alt> LayoutReplaced objects can now participate in inline layout. It's very hackish, but basically LayoutReplaced will just add itself to the last line in the containing block. This patch gets rid of the idea that only LayoutInline subclasses can be split into lines, by moving the split_into_lines() virtual up to LayoutNode and overriding it in LayoutReplaced.
2019-10-05 18:20:35 -03: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 08:42:07 -03:00
HTMLImageElement(DOM::Document&, DOM::QualifiedName);
LibWeb: Add fast_is<T> for form, embed, image, and object elements These are used by Window::supported_property_names(), which can get very hot.
2023-12-24 10:41:33 -03:00
virtual bool is_html_image_element() const override { return true; }
LibJS: Make Cell::initialize() return void Stop worrying about tiny OOMs. Work towards #20405
2023-08-07 03:41:28 -03:00
virtual void initialize(JS::Realm&) override;
LibWeb: Make responsive images react to changes in size viewport This patch implements "react to changes in the environment" from the HTML spec and hooks HTMLImageElement up with viewport rect change notifications (from the browsing context). This fixes the issue where we'd load a low-resolution image and not switch to a high-resolution image after resizing the window.
2023-07-29 05:20:53 -03:00
virtual void finalize() override;
LibWeb: Implement enough of "update the image data" to load images This first pass is enough to get us: - Image loading via fetch - Source selection via srcset and sizes attributes
2023-05-11 14:23:36 -03:00
LibWeb: Move viewport subscriptions from BrowsingContext to Document With this change, elements that want to receive viewport rect updates will need to register on document instead of the browsing context. This change solves the problem where a browsing context for a document is guaranteed to exist only while the document is active so browsing context might not exit by the time DOM node that want to register is constructed. This is a part of preparation work before switching to navigables where this issue becomes more visible.
2023-08-23 13:58:42 -03:00
virtual void adopted_from(DOM::Document&) override;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 15:01:35 -03:00
virtual void apply_presentational_hints(CSS::StyleProperties&) const override;
LibWeb: Parse "width" and "height" presentation attributes on <img> These are HTML lengths that map to CSS width and height respectively.
2020-07-21 20:16:27 -03:00
LibWeb: Generalize support for dimension attributes Rather than each element which supports dimension attributes needing to implement parsing the attributes and setting the appropriate style, we can generalize this functionality. This will also make each element more closely resemble the spec text, as we will be effectively declaring, for example, "The img element supports dimension attributes" in code.
2024-04-10 22:44:11 -03:00
// https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element:dimension-attributes
virtual bool supports_dimension_attributes() const override { return true; }
LibWeb: Remove reference counting for `CSS::StyleProperties` `AK::CopyOnWrite` already does reference counting, so there is no need to do it again.
2024-10-26 12:42:27 -03:00
virtual JS::GCPtr<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 09:14:37 -03:00
virtual void adjust_computed_style(CSS::StyleProperties&) override;
LibHTML: Support rendering <img src> with file:// URLs We can now show images loaded from local file:// URLs. Pretty neat :^)
2019-10-05 18:41:14 -03:00
LibWeb: Move viewport subscriptions from BrowsingContext to Document With this change, elements that want to receive viewport rect updates will need to register on document instead of the browsing context. This change solves the problem where a browsing context for a document is guaranteed to exist only while the document is active so browsing context might not exit by the time DOM node that want to register is constructed. This is a part of preparation work before switching to navigables where this issue becomes more visible.
2023-08-23 13:58:42 -03:00
virtual void did_set_viewport_rect(CSSPixelRect const&) override;
LibWeb: Make responsive images react to changes in size viewport This patch implements "react to changes in the environment" from the HTML spec and hooks HTMLImageElement up with viewport rect change notifications (from the browsing context). This fixes the issue where we'd load a low-resolution image and not switch to a high-resolution image after resizing the window.
2023-07-29 05:20:53 -03:00
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 00:22:27 -03:00
void handle_successful_fetch(URL::URL const&, StringView mime_type, ImageRequest&, ByteBuffer, bool maybe_omit_events, URL::URL const& previous_url);
LibWeb: Implement enough of "update the image data" to load images This first pass is enough to get us: - Image loading via fetch - Source selection via srcset and sizes attributes
2023-05-11 14:23:36 -03:00
void handle_failed_fetch();
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 00:22:27 -03:00
void add_callbacks_to_image_request(JS::NonnullGCPtr<ImageRequest>, bool maybe_omit_events, URL::URL const& url_string, URL::URL const& previous_url);
LibWeb: Implement enough of "update the image data" to load images This first pass is enough to get us: - Image loading via fetch - Source selection via srcset and sizes attributes
2023-05-11 14:23:36 -03:00
void animate();
RefPtr<Core::Timer> m_animation_timer;
size_t m_current_frame_index { 0 };
size_t m_loops_completed { 0 };
LibWeb: Make HTMLImageElement loads delay the document load event This is something we're supposed to do according to the HTML spec. Note that image loading is currently completely ad-hoc, and this just adds a simple DocumentLoadEventDelayer to the existing implementation. This will allow us to use images in layout tests, which rely on the document load event firing at a predictable time.
2023-04-01 10:15:23 -03:00
Optional<DOM::DocumentLoadEventDelayer> m_load_event_delayer;
LibWeb: Implement enough of "update the image data" to load images This first pass is enough to get us: - Image loading via fetch - Source selection via srcset and sizes attributes
2023-05-11 14:23:36 -03:00
CORSSettingAttribute m_cors_setting { CORSSettingAttribute::NoCORS };
// https://html.spec.whatwg.org/multipage/images.html#last-selected-source
// Each img element has a last selected source, which must initially be null.
Optional<String> m_last_selected_source;
// https://html.spec.whatwg.org/multipage/images.html#current-request
LibWeb: Make HTML::ImageRequest GC allocated
2023-08-18 07:56:21 -03:00
JS::GCPtr<ImageRequest> m_current_request;
LibWeb: Implement enough of "update the image data" to load images This first pass is enough to get us: - Image loading via fetch - Source selection via srcset and sizes attributes
2023-05-11 14:23:36 -03:00
// https://html.spec.whatwg.org/multipage/images.html#pending-request
LibWeb: Make HTML::ImageRequest GC allocated
2023-08-18 07:56:21 -03:00
JS::GCPtr<ImageRequest> m_pending_request;
LibWeb: Implement enough of "update the image data" to load images This first pass is enough to get us: - Image loading via fetch - Source selection via srcset and sizes attributes
2023-05-11 14:23:36 -03:00
SourceSet m_source_set;
LibWeb: Implement `loading=lazy` for `<img>` elements
2023-07-06 20:00:06 -03:00
LibWeb: Make responsive images react to changes in size viewport This patch implements "react to changes in the environment" from the HTML spec and hooks HTMLImageElement up with viewport rect change notifications (from the browsing context). This fixes the issue where we'd load a low-resolution image and not switch to a high-resolution image after resizing the window.
2023-07-29 05:20:53 -03:00
CSSPixelSize m_last_seen_viewport_size;
HTMLImageElement: Improve decoding stub Add an enum and warn when setting to sync/async.
2024-09-02 08:46:27 -03:00
// https://html.spec.whatwg.org/multipage/images.html#image-decoding-hint
enum class ImageDecodingHint {
Auto,
Sync,
Async
};
ImageDecodingHint m_decoding_hint = ImageDecodingHint::Auto;
LibHTML: Flesh out <img> element with LayoutImage and LayoutReplaced This patch adds parsing of <img> into HTMLImageElement objects. It also adds LayoutImage and its parent class LayoutReplaced, which is going to represent CSS "replaced elements."
2019-10-05 17:07:45 -03:00
};
LibWeb: Move everything into the Web namespace
2020-03-07 06:27:02 -03:00
LibWeb: Add is<HTMLImageElement>()
2020-04-14 15:35:49 -03:00
}
LibWeb: Add fast_is<T> for form, embed, image, and object elements These are used by Window::supported_property_names(), which can get very hot.
2023-12-24 10:41:33 -03:00
namespace Web::DOM {
template<>
inline bool Node::fast_is<HTML::HTMLImageElement>() const { return is_html_image_element(); }
}
Reference in a new issue Copy permalink