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/HTMLImageElement.h

172 lines
6.4 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 09:38:21 +01:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 13:19:50 +02: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 05:48:17 +01: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 09:38:21 +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
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 09:38:21 +01: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 22:07:45 +02: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 21:41:10 +01: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 22:22:54 +02:00
#include <AK/OwnPtr.h>
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
#include <LibGC/Function.h>
LibGfx: More work on header dependency reduction
2020-02-14 23:28:42 +01: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 14:45:45 +01:00
#include <LibGfx/ImmutableBitmap.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 18:58:42 +02: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 15:15:23 +02: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 10:20:53 +02: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 19:23:36 +02: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 16:18:49 +01: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 18:55:54 -04: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 18:50:09 +00: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 19:23:36 +02: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 07:17:01 +02: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 22:07:45 +02:00
LibWeb: Move HTML classes into the Web::HTML namespace
2020-07-28 18:20:36 +02: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 20:57:18 +01: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 18:55:54 -04: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 07:17:01 +02: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 18:50:09 +00: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 10:20:53 +02: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 18:58:42 +02: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 13:42:07 +02:00
WEB_PLATFORM_OBJECT(HTMLImageElement, 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(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 18:50:09 +00: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 18:55:54 -04: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 22:07:45 +02:00
public:
virtual ~HTMLImageElement() override;
LibWeb: Include namespace parameter in `associated_attribute_changed()`
2024-12-12 19:48:32 +00:00
virtual void form_associated_element_attribute_changed(FlyString const& name, Optional<String> const& value, Optional<FlyString> const&) override;
LibHTML: Load image resource when src attribute is set
2019-10-06 23:03:51 +11:00
LibWeb: Add an alternative_text() getter This change adds an alternative_text()·getter, for use in computing accessible names.
2024-11-09 23:45:09 +09: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 19:04:45 +01: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 23:20:35 +02: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 14:45:45 +01: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 23:41:14 +02:00
LibWeb: Limit `HTMLImageElement` width and height to allowed values Setting the `width` or `height` properties of `HTMLImageElement` to a value greater than 2147483647 will now cause the property to be set to 0.
2024-11-29 15:32:37 +00:00
WebIDL::UnsignedLong width() const;
WebIDL::ExceptionOr<void> set_width(WebIDL::UnsignedLong);
LibWeb: Implement HTMLImageElement.width and HTMLImageElement.height
2022-02-25 18:42:37 +01:00
LibWeb: Limit `HTMLImageElement` width and height to allowed values Setting the `width` or `height` properties of `HTMLImageElement` to a value greater than 2147483647 will now cause the property to be set to 0.
2024-11-29 15:32:37 +00:00
WebIDL::UnsignedLong height() const;
WebIDL::ExceptionOr<void> set_height(WebIDL::UnsignedLong);
LibWeb: Implement HTMLImageElement.width and HTMLImageElement.height
2022-02-25 18:42:37 +01: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 14:54:27 +02: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-24 00:08:03 +01: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 23:15:26 +02:00
// https://html.spec.whatwg.org/multipage/embedded-content.html#dom-img-decode
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
[[nodiscard]] WebIDL::ExceptionOr<GC::Ref<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 23:15:26 +02: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 22:23:16 +00: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 17:58:13 -06: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 10:20:53 +02: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 19:23:36 +02: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 08:08:44 +02: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 19:23:36 +02: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();
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 14:06:08 +01: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 07:17:01 +02: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 20:10:37 -05: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 16:27:31 +02: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 17:33:58 -05: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 14:45:45 +01: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 07:17:01 +02:00
virtual void set_visible_in_viewport(bool) 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::Ref<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 07:17:01 +02:00
LibWeb: Make HTML::ImageRequest GC allocated
2023-08-18 12:56:21 +02: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 23:20:35 +02: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
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 14:41:33 +01: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 08:41:28 +02: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 10:20:53 +02: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 19:23:36 +02: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 18:58:42 +02:00
virtual void adopted_from(DOM::Document&) 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: Parse "width" and "height" presentation attributes on <img> These are HTML lengths that map to CSS width and height respectively.
2020-07-22 01:16:27 +02: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 21:44:11 -04: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: 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;
LibHTML: Support rendering <img src> with file:// URLs We can now show images loaded from local file:// URLs. Pretty neat :^)
2019-10-05 23:41:14 +02: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 18:58:42 +02: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 10:20:53 +02: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 16:22:27 +13: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 19:23:36 +02:00
void handle_failed_fetch();
LibWeb/HTML: Make HTMLImageRequests currentURL a String This is the same type as what is spec'd. We cannot use a URL record for this member as the spec in some scenarios will set and compare the URL string to an invalid URL value, such as the empty string. With implicit string constructors for the URL class removed explicitly using URL::Parser::basic_parse makes the code look quite silly in those places.
2025-02-22 20:16:45 +13:00
void add_callbacks_to_image_request(GC::Ref<ImageRequest>, bool maybe_omit_events, URL::URL const& url_string, String 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 19:23:36 +02: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 15:15:23 +02: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 19:23:36 +02: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
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::Ptr<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 19:23:36 +02:00
// https://html.spec.whatwg.org/multipage/images.html#pending-request
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::Ptr<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 19:23:36 +02:00
SourceSet m_source_set;
LibWeb: Implement `loading=lazy` for `<img>` elements
2023-07-07 00:00:06 +01: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 10:20:53 +02:00
CSSPixelSize m_last_seen_viewport_size;
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 22:07:45 +02:00
};
LibWeb: Move everything into the Web namespace
2020-03-07 10:27:02 +01:00
LibWeb: Add is<HTMLImageElement>()
2020-04-14 20:35:49 +02: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 14:41:33 +01:00
namespace Web::DOM {
Meta: Enforce newlines around namespaces This has come up several times during code review, so let's just enforce it using a new clang-format 20 option.
2025-05-13 07:06:33 -04: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 14:41:33 +01:00
template<>
inline bool Node::fast_is<HTML::HTMLImageElement>() const { return is_html_image_element(); }
Meta: Enforce newlines around namespaces This has come up several times during code review, so let's just enforce it using a new clang-format 20 option.
2025-05-13 07:06:33 -04: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 14:41:33 +01:00
}
Reference in a new issue Copy permalink