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

364 lines
15 KiB
C
Raw Normal View History

LibWeb+LibJS: Move DOM Window object to dedicated classes LibWeb now creates a WindowObject which inherits from GlobalObject. Allocation of the global object is moved out of the Interpreter ctor to allow for specialized construction. The existing Window interfaces are moved to WindowObject with their implementation code in the new Window class.
2020-04-01 18:53:28 +02:00
/*
LibWeb: Make requestAnimationFrame() callback IDs sequential This is required by the spec, so let's stop returning random IDs in favor of a simple sequential integer sequence.
2024-08-04 16:36:50 +02:00
* Copyright (c) 2020-2024, Andreas Kling <andreas@ladybird.org>
LibWeb: Convert the Location object to IDL This includes: - Moving it from Bindings/ to HTML/ - Renaming it from LocationObject to Location - Removing the manual definitions of the constructor and prototype - Removing special handling of the Location interface from the bindings generator - Converting the JS_DEFINE_NATIVE_FUNCTIONs to regular functions returning DeprecatedString instead of PrimitiveString - Adding missing (no-op) setters for the various attributes, which are expected to exist by the bindings generator
2023-01-18 17:41:12 +00:00
* Copyright (c) 2021-2023, Linus Groh <linusg@serenityos.org>
LibWeb+LibJS: Move DOM Window object to dedicated classes LibWeb now creates a WindowObject which inherits from GlobalObject. Allocation of the global object is moved out of the Interpreter ctor to allow for specialized construction. The existing Window interfaces are moved to WindowObject with their implementation code in the new Window class.
2020-04-01 18:53:28 +02:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
LibWeb+LibJS: Move DOM Window object to dedicated classes LibWeb now creates a WindowObject which inherits from GlobalObject. Allocation of the global object is moved out of the Interpreter ctor to allow for specialized construction. The existing Window interfaces are moved to WindowObject with their implementation code in the new Window class.
2020-04-01 18:53:28 +02:00
*/
#pragma once
#include <AK/Badge.h>
#include <AK/RefPtr.h>
LibWeb+WebContent: Add abstraction layer for event loop and timers Instead of using Core::EventLoop and Core::Timer directly, LibWeb now goes through a Web::Platform abstraction layer instead. This will allow us to plug in Qt's event loop (and QTimer) over in Ladybird, to avoid having to deal with multiple event loops.
2022-09-07 20:30:31 +02:00
#include <AK/TypeCasts.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/Heap.h>
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
#include <LibURL/URL.h>
LibWeb: Move Web prototypes and constructors to new Intrinsics object This Intrinsics object hangs off of a new HostDefined struct that takes the place of EnvironmentSettingsObject as the true [[HostDefined]] slot on JS::Realm objects created by LibWeb. This gets the intrinsics off of the GlobalObject, Window, similar to the previous refactor of LibJS to move the intrinsics into the Realm's [[Intrinics]] internal slot. A side effect of this change is that we cannot fully initialize a Window object until the [[HostDefined]] slot has been installed into the realm, which happens with the creation of the WindowEnvironmentSettingsObject. As such, any Window usage that has not been funned through a WindowESO will not have any cached Web prototyped or constructors, and will not have Window APIs available to javascript code. Currently this seems limited to usage of Window in the CSS parser, but a subsequent commit will clean those up to take Realm as well. However, this commit compiles so let's cut it off here :^).
2022-09-24 15:39:23 -06:00
#include <LibWeb/Bindings/Intrinsics.h>
LibWeb/HTML: Port Window.location to IDL
2023-03-05 20:13:00 +00:00
#include <LibWeb/Bindings/WindowGlobalMixin.h>
LibWeb: Make DOM::Window into an EventTarget This will allow us to dispatch window events.
2020-10-18 13:43:44 +02:00
#include <LibWeb/DOM/EventTarget.h>
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
#include <LibWeb/Forward.h>
LibWeb: Implement BarProp properties for Window
2025-03-04 22:51:08 +01:00
#include <LibWeb/HTML/BarProp.h>
LibWeb: Move cross-origin AOs from Bindings/ to HTML/CrossOrigin/ These are from the HTML spec and therefore belong in the HTML/ directory in LibWeb. Bindings/ has become a bit of a dumping ground, so this is a first step towards cleaning that up.
2022-09-24 14:02:47 +01:00
#include <LibWeb/HTML/CrossOrigin/CrossOriginPropertyDescriptorMap.h>
LibWeb: Expose the GlobalEventHandlers mixin on the Window object We now expose all the `onfoo` event handler attributes on the window object. This makes `window.onload = ...` actually work. :^)
2021-09-22 16:39:15 +02:00
#include <LibWeb/HTML/GlobalEventHandlers.h>
LibWeb: Implement navigator.{plugins,mimeTypes}
2023-02-28 00:23:53 +00:00
#include <LibWeb/HTML/MimeType.h>
LibWeb: Add `Window::navigable()`
2023-08-22 15:50:49 +02:00
#include <LibWeb/HTML/Navigable.h>
LibWeb: Implement navigator.{plugins,mimeTypes}
2023-02-28 00:23:53 +00:00
#include <LibWeb/HTML/Plugin.h>
LibWeb: Don't include HTML/Window.h from DOM/Element.h This required moving HTML::ScrollOptions to its own header file.
2023-05-08 07:39:05 +02:00
#include <LibWeb/HTML/ScrollOptions.h>
LibWeb: Move StructuredSerializeOptions to its own header This largely reduces the number of files needed to be compiled when we change the MessagePort header.
2024-10-17 08:46:48 -04:00
#include <LibWeb/HTML/StructuredSerializeOptions.h>
LibWeb: Wire up UniversalGlobalScopeMixin to ShadowRealmGlobalScope
2024-11-08 16:35:16 +13:00
#include <LibWeb/HTML/UniversalGlobalScope.h>
LibWeb: Implement WindowEventHandlers
2022-06-27 19:48:54 +01:00
#include <LibWeb/HTML/WindowEventHandlers.h>
LibWeb/HTML: Hook up WindowOrWorkerGlobalScopeMixin to Window This prepares us to use the shared implementations from this class.
2023-03-06 11:08:15 +00:00
#include <LibWeb/HTML/WindowOrWorkerGlobalScope.h>
LibWeb/HTML: Port Window.requestIdleCallback() to IDL
2023-03-06 23:38:44 +00:00
#include <LibWeb/RequestIdleCallback/IdleRequest.h>
LibWeb: Make requestAnimationFrame() callback IDs sequential This is required by the spec, so let's stop returning random IDs in favor of a simple sequential integer sequence.
2024-08-04 16:36:50 +02:00
#include <LibWeb/WebIDL/Types.h>
LibWeb+LibJS: Move DOM Window object to dedicated classes LibWeb now creates a WindowObject which inherits from GlobalObject. Allocation of the global object is moved out of the Interpreter ctor to allow for specialized construction. The existing Window interfaces are moved to WindowObject with their implementation code in the new Window class.
2020-04-01 18:53:28 +02:00
LibWeb: Move Window from DOM directory & namespace to HTML The Window object is part of the HTML spec. :^) https://html.spec.whatwg.org/multipage/window-object.html
2022-03-07 23:08:26 +01:00
namespace Web::HTML {
LibWeb+LibJS: Move DOM Window object to dedicated classes LibWeb now creates a WindowObject which inherits from GlobalObject. Allocation of the global object is moved out of the Interpreter ctor to allow for specialized construction. The existing Window interfaces are moved to WindowObject with their implementation code in the new Window class.
2020-04-01 18:53:28 +02:00
LibWeb: Implement the infrastructure necessary for requestIdleCallback This includes a bug fix for the event loop processing steps which has not been merged yet: https://github.com/whatwg/html/pull/7768
2022-03-31 21:55:01 +02:00
class IdleCallback;
LibWeb: Make requestAnimationFrame() work in multi-process mode Since we don't have a direct connection to WindowServer, this is slighly more naive implementation than what we were doing for single-process mode. Basically, there's a global RequestAnimationFrameDriver object that has a 16ms single-shot timer. Whenever someone registers for a RAF callback, we start the timer (if needed). This is not ideal, but it's better than nothing. :^)
2021-09-13 02:03:06 +02:00
LibWeb/HTML: Port Window.scroll() to IDL ...with various changes required due to ScrollBehavior / ScrollOptions moving from Element.idl to Window.idl.
2023-03-06 20:53:49 +00:00
// https://w3c.github.io/csswg-drafts/cssom-view/#dictdef-scrolltooptions
struct ScrollToOptions : public ScrollOptions {
Optional<double> left;
Optional<double> top;
};
LibWeb: Make Window.postMessage closer to the spec The main issues are using Structured{Serialize,Deserailize} instead of Structured{Serialize,Deserialize}WithTransfer and the temporary execution context usage for StructuredDeserialize. Allows Discord to load once again, as it uses a postMessage scheduler to render components, including the main App component. The callback checked the (previously) non-existent source attribute of the MessageEvent and returned if it was not the main window. Fixes the Twitch cookie consent banner saying "failed integrity check" for unknown reasons, but presumably related to the source and origin attributes.
2023-11-06 20:22:56 +00:00
// https://html.spec.whatwg.org/multipage/nav-history-apis.html#windowpostmessageoptions
struct WindowPostMessageOptions : public StructuredSerializeOptions {
String target_origin { "/"_string };
};
LibWeb: Implement multiple import map support
2024-12-03 20:31:14 +13:00
// https://html.spec.whatwg.org/multipage/webappapis.html#specifier-resolution-record
// A specifier resolution record is a struct. It has the following items:
struct SpecifierResolution {
// A serialized base URL
// A string-or-null that represents the base URL of the specifier, when one exists.
Optional<String> serialized_base_url;
// A specifier
// A string representing the specifier.
String specifier;
// A specifier as a URL
// A URL-or-null that represents the URL in case of a URL-like module specifier.
//
// Spec-Note: Implementations can replace specifier as a URL with a boolean that indicates
// that the specifier is either bare or URL-like that is special.
bool specifier_is_null_or_url_like_that_is_special { false };
};
LibWeb: Make DOM::Window into an EventTarget This will allow us to dispatch window events.
2020-10-18 13:43:44 +02:00
class Window final
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
: public DOM::EventTarget
LibWeb/HTML: Remove redundant namespace qualifiers from Window.{cpp,h}
2023-03-11 18:11:20 +00:00
, public GlobalEventHandlers
, public WindowEventHandlers
LibWeb/HTML: Hook up WindowOrWorkerGlobalScopeMixin to Window This prepares us to use the shared implementations from this class.
2023-03-06 11:08:15 +00:00
, public WindowOrWorkerGlobalScopeMixin
LibWeb: Wire up UniversalGlobalScopeMixin to ShadowRealmGlobalScope
2024-11-08 16:35:16 +13:00
, public UniversalGlobalScopeMixin
LibWeb: Start generating code for the Window object from IDL :^)
2023-03-05 15:52:34 +00:00
, public Bindings::WindowGlobalMixin {
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(Window, DOM::EventTarget);
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(Window);
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+LibJS: Move DOM Window object to dedicated classes LibWeb now creates a WindowObject which inherits from GlobalObject. Allocation of the global object is moved out of the Interpreter ctor to allow for specialized construction. The existing Window interfaces are moved to WindowObject with their implementation code in the new Window class.
2020-04-01 18:53:28 +02:00
public:
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
[[nodiscard]] static GC::Ref<Window> create(JS::Realm&);
LibWeb+LibJS: Move DOM Window object to dedicated classes LibWeb now creates a WindowObject which inherits from GlobalObject. Allocation of the global object is moved out of the Interpreter ctor to allow for specialized construction. The existing Window interfaces are moved to WindowObject with their implementation code in the new Window class.
2020-04-01 18:53:28 +02:00
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
~Window();
LibWeb: Make DOM::Window into an EventTarget This will allow us to dispatch window events.
2020-10-18 13:43:44 +02:00
LibWeb: Wire up UniversalGlobalScopeMixin to ShadowRealmGlobalScope
2024-11-08 16:35:16 +13:00
using UniversalGlobalScopeMixin::atob;
using UniversalGlobalScopeMixin::btoa;
using UniversalGlobalScopeMixin::queue_microtask;
using UniversalGlobalScopeMixin::structured_clone;
LibWeb: Port {set,clear}{Timeout,Interval} to IDL
2023-03-14 07:28:08 -04:00
using WindowOrWorkerGlobalScopeMixin::clear_interval;
using WindowOrWorkerGlobalScopeMixin::clear_timeout;
LibWeb: Implement HTML::ImageBitmap And the two methods of `WindowOrWorkerGlobalScope` that are used as constructors for it.
2024-04-04 21:48:58 -04:00
using WindowOrWorkerGlobalScopeMixin::create_image_bitmap;
LibWeb/HTML: Port Window.fetch() to IDL
2023-03-07 18:15:52 +00:00
using WindowOrWorkerGlobalScopeMixin::fetch;
LibWeb: Add initial implementation of global.reportError()
2024-07-04 00:28:49 +09:00
using WindowOrWorkerGlobalScopeMixin::report_error;
LibWeb: Port {set,clear}{Timeout,Interval} to IDL
2023-03-14 07:28:08 -04:00
using WindowOrWorkerGlobalScopeMixin::set_interval;
using WindowOrWorkerGlobalScopeMixin::set_timeout;
LibWeb/HTML: Port Window.btoa() to IDL
2023-03-06 11:14:45 +00:00
LibWeb/HTML: Hook up WindowOrWorkerGlobalScopeMixin to Window This prepares us to use the shared implementations from this class.
2023-03-06 11:08:15 +00:00
// ^DOM::EventTarget
LibWeb: Make DOM::Event and all its subclasses GC-allocated
2022-08-08 22:29:40 +02:00
virtual bool dispatch_event(DOM::Event&) override;
LibWeb: Make DOM::Window into an EventTarget This will allow us to dispatch window events.
2020-10-18 13:43:44 +02:00
LibWeb/HTML: Hook up WindowOrWorkerGlobalScopeMixin to Window This prepares us to use the shared implementations from this class.
2023-03-06 11:08:15 +00:00
// ^WindowOrWorkerGlobalScopeMixin
LibWeb: Ensure global objects are an event target All global objects current need to be event targets so that they can have events dispatched to them. This allows for removing of verify_cast for these global objects.
2024-12-03 02:37:33 +13:00
virtual DOM::EventTarget& this_impl() override { return *this; }
virtual DOM::EventTarget const& this_impl() const override { return *this; }
LibWeb/HTML: Hook up WindowOrWorkerGlobalScopeMixin to Window This prepares us to use the shared implementations from this class.
2023-03-06 11:08:15 +00:00
LibWeb/HTML: Consolidate duplicate public/private sections in Window.h
2023-03-11 16:44:15 +00:00
// ^JS::Object
virtual JS::ThrowCompletionOr<bool> internal_set_prototype_of(JS::Object* prototype) override;
LibWeb: Make HTML::Window::page() return a Page&
2023-12-15 20:33:16 +01:00
Page& page();
Page const& page() const;
LibWeb: Add DOM::Window::page() This helps us to get from a Window to the containing Page, without clients having to go through Document.
2021-09-09 13:45:03 +02:00
LibWeb: Add Window::browsing_context() https://html.spec.whatwg.org/multipage/window-object.html#window-bc > The Window object's browsing context is the Window object's associated > Document's browsing context. > NOTE: It is either null or a browsing context.
2022-03-05 00:13:13 +01:00
// https://html.spec.whatwg.org/multipage/window-object.html#concept-document-window
LibWeb: Move Window from DOM directory & namespace to HTML The Window object is part of the HTML spec. :^) https://html.spec.whatwg.org/multipage/window-object.html
2022-03-07 23:08:26 +01:00
DOM::Document const& associated_document() const { return *m_associated_document; }
DOM::Document& associated_document() { return *m_associated_document; }
LibWeb: Add a way to construct HTML::Window without a DOM::Document This will be used to implement the rather intricate construction order in the HTML spec.
2022-08-04 21:19:30 +02:00
void set_associated_document(DOM::Document&);
LibWeb+LibJS: Move DOM Window object to dedicated classes LibWeb now creates a WindowObject which inherits from GlobalObject. Allocation of the global object is moved out of the Interpreter ctor to allow for specialized construction. The existing Window interfaces are moved to WindowObject with their implementation code in the new Window class.
2020-04-01 18:53:28 +02:00
LibWeb: Add Window::browsing_context() https://html.spec.whatwg.org/multipage/window-object.html#window-bc > The Window object's browsing context is the Window object's associated > Document's browsing context. > NOTE: It is either null or a browsing context.
2022-03-05 00:13:13 +01:00
// https://html.spec.whatwg.org/multipage/window-object.html#window-bc
LibWeb/HTML: Remove redundant namespace qualifiers from Window.{cpp,h}
2023-03-11 18:11:20 +00:00
BrowsingContext const* browsing_context() const;
BrowsingContext* browsing_context();
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
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<Navigable> navigable() const;
LibWeb: Add `Window::navigable()`
2023-08-22 15:50:49 +02:00
LibWeb: Implement multiple import map support
2024-12-03 20:31:14 +13:00
void append_resolved_module(SpecifierResolution resolution) { m_resolved_module_set.append(move(resolution)); }
Vector<SpecifierResolution> const& resolved_module_set() const { return m_resolved_module_set; }
LibWeb: Expose an import map and import maps allowed on Window
2022-10-23 04:05:46 +02:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
WebIDL::ExceptionOr<GC::Ptr<WindowProxy>> window_open_steps(StringView url, StringView target, StringView features);
LibWeb: Break the Window open steps into two methods for internal use Some callers (namely WebDriver) will need access to the navigable opened by these steps. But if the noopener parameter is set, the returned proxy will always be null. This splits some of the Window open steps into an internal method that returns the chosen navigable.
2024-10-20 08:48:52 -04:00
struct OpenedWindow {
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<Navigable> navigable;
LibWeb: Break the Window open steps into two methods for internal use Some callers (namely WebDriver) will need access to the navigable opened by these steps. But if the noopener parameter is set, the returned proxy will always be null. This splits some of the Window open steps into an internal method that returns the chosen navigable.
2024-10-20 08:48:52 -04:00
TokenizedFeature::NoOpener no_opener { TokenizedFeature::NoOpener::No };
Navigable::WindowType window_type { Navigable::WindowType::ExistingOrNone };
};
WebIDL::ExceptionOr<OpenedWindow> window_open_steps_internal(StringView url, StringView target, StringView features);
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
DOM::Event* current_event() { return m_current_event.ptr(); }
DOM::Event const* current_event() const { return m_current_event.ptr(); }
LibWeb: Make DOM::Event and all its subclasses GC-allocated
2022-08-08 22:29:40 +02:00
void set_current_event(DOM::Event* event);
LibWeb: Make event dispatching spec-compliant Specification: https://dom.spec.whatwg.org/#concept-event-dispatch This also introduces shadow roots due to it being a requirement of the event dispatcher. However, it does not introduce the full shadow DOM, that can be left for future work. This changes some event dispatches which require certain attributes to be initialised to a value.
2020-11-21 18:32:39 +00:00
LibWeb: Use MediaFeatureIDs instead of Strings :^)
2022-03-08 16:51:33 +00:00
Optional<CSS::MediaFeatureValue> query_media_feature(CSS::MediaFeatureID) const;
LibWeb: Stub out a dummy window.getComputedStyle() This just returns an empty CSSStyleDeclaration for now. The real thing needs to be a live object that provides a view onto the computed style of a given element. This is far from that, but it's something. :^)
2021-09-11 00:33:30 +02:00
LibWeb: Port fire_a_page_transition_event() to new FlyString
2023-04-09 11:17:42 +02:00
void fire_a_page_transition_event(FlyString const& event_name, bool persisted);
LibWeb: Add the PageTransitionEvent interface and fire "pageshow" events We now fire "pageshow" events at the appropriate time during document loading (done by the parser.) Note that there are no corresponding "pagehide" events yet.
2021-09-26 12:39:27 +02:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
WebIDL::ExceptionOr<GC::Ref<Storage>> local_storage();
WebIDL::ExceptionOr<GC::Ref<Storage>> session_storage();
LibWeb: Add Storage interface and window.localStorage This is a naive-but-somewhat-functional initial implementation of HTML Storage. Note that there is no persistence yet, everything is in-process only, and one local Storage object per origin.
2022-02-08 19:38:29 +01:00
LibWeb: Implement the infrastructure necessary for requestIdleCallback This includes a bug fix for the event loop processing steps which has not been merged yet: https://github.com/whatwg/html/pull/7768
2022-03-31 21:55:01 +02:00
void start_an_idle_period();
LibWeb: Add getter for sticky activation
2024-05-25 12:34:17 +01:00
// https://html.spec.whatwg.org/multipage/interaction.html#sticky-activation
bool has_sticky_activation() const;
LibWeb: Flesh out a chunk of the HTML spec's frame navigation algorithms
2022-09-19 17:46:34 +02:00
// https://html.spec.whatwg.org/multipage/interaction.html#transient-activation
bool has_transient_activation() const;
LibWeb: Add getter for history-action activation
2024-05-25 14:24:07 +01:00
// https://html.spec.whatwg.org/multipage/interaction.html#history-action-activation
bool has_history_action_activation() const;
LibWeb+LibWebView+WebContent: Convert about:settings to a WebUI
2025-03-24 10:22:38 -04:00
WebIDL::ExceptionOr<void> initialize_web_interfaces(Badge<WindowEnvironmentSettingsObject>);
LibWeb: Move Web prototypes and constructors to new Intrinsics object This Intrinsics object hangs off of a new HostDefined struct that takes the place of EnvironmentSettingsObject as the true [[HostDefined]] slot on JS::Realm objects created by LibWeb. This gets the intrinsics off of the GlobalObject, Window, similar to the previous refactor of LibJS to move the intrinsics into the Realm's [[Intrinics]] internal slot. A side effect of this change is that we cannot fully initialize a Window object until the [[HostDefined]] slot has been installed into the realm, which happens with the creation of the WindowEnvironmentSettingsObject. As such, any Window usage that has not been funned through a WindowESO will not have any cached Web prototyped or constructors, and will not have Window APIs available to javascript code. Currently this seems limited to usage of Window in the CSS parser, but a subsequent commit will clean those up to take Realm as well. However, this commit compiles so let's cut it off here :^).
2022-09-24 15:39:23 -06:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
Vector<GC::Ref<Plugin>> pdf_viewer_plugin_objects();
Vector<GC::Ref<MimeType>> pdf_viewer_mime_type_objects();
LibWeb: Implement navigator.{plugins,mimeTypes}
2023-02-28 00:23:53 +00:00
LibWeb/HTML: Consolidate duplicate public/private sections in Window.h
2023-03-11 16:44:15 +00:00
CrossOriginPropertyDescriptorMap const& cross_origin_property_descriptor_map() const { return m_cross_origin_property_descriptor_map; }
CrossOriginPropertyDescriptorMap& cross_origin_property_descriptor_map() { return m_cross_origin_property_descriptor_map; }
LibWeb/HTML: Port Window.alert() to IDL
2023-03-05 16:02:35 +00:00
// JS API functions
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ref<WindowProxy> window() const;
GC::Ref<WindowProxy> self() const;
GC::Ref<DOM::Document const> document() const;
LibWeb/HTML: Port Window.name to IDL
2023-03-05 19:02:16 +00:00
String name() const;
void set_name(String const&);
LibWeb: Add window.status property
2023-12-04 19:52:04 +01:00
String status() const;
LibWeb: Stub out missing cross origin properties on the window object Previously, trying to access the `close`, `closed` or `blur` properties on a cross origin window would cause a crash.
2024-03-30 10:04:31 +00:00
void close();
bool closed() const;
LibWeb: Add window.status property
2023-12-04 19:52:04 +01:00
void set_status(String const&);
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]] GC::Ref<Location> location();
GC::Ref<History> history() const;
GC::Ref<Navigation> navigation();
LibWeb: Implement window.stop() Fixes a handful of timeouts on WPT.
2024-12-05 10:56:47 +01:00
void stop();
LibWeb/HTML: Port Window.focus() to IDL
2023-03-06 22:25:04 +00:00
void focus();
LibWeb: Stub out missing cross origin properties on the window object Previously, trying to access the `close`, `closed` or `blur` properties on a cross origin window would cause a crash.
2024-03-30 10:04:31 +00:00
void blur();
LibWeb/HTML: Port Window.window to IDL
2023-03-05 18:36:43 +00:00
LibWeb: Implement BarProp properties for Window
2025-03-04 22:51:08 +01:00
// For historical reasons, the Window interface had some properties that represented the visibility of certain web browser interface elements.
// For privacy and interoperability reasons, those properties now return values that represent whether the Window's browsing context's is popup property is true or false.
GC::Ref<BarProp const> locationbar();
GC::Ref<BarProp const> menubar();
GC::Ref<BarProp const> personalbar();
GC::Ref<BarProp const> scrollbars();
GC::Ref<BarProp const> statusbar();
GC::Ref<BarProp const> toolbar();
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ref<WindowProxy> frames() const;
LibWeb: Update `Window::length()` to use navigables
2023-09-03 22:50:40 +02:00
u32 length();
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<WindowProxy const> top() const;
GC::Ptr<WindowProxy const> opener() const;
LibWeb: Implement the `window.opener` attribute This returns a reference to the window that opened the current window.
2024-03-12 23:39:59 +00:00
WebIDL::ExceptionOr<void> set_opener(JS::Value);
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<WindowProxy const> parent() const;
GC::Ptr<DOM::Element const> frame_element() const;
WebIDL::ExceptionOr<GC::Ptr<WindowProxy>> open(Optional<String> const& url, Optional<String> const& target, Optional<String> const& features);
LibWeb/HTML: Port Window.frames to IDL
2023-03-05 18:48:45 +00:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
[[nodiscard]] GC::Ref<Navigator> navigator();
[[nodiscard]] GC::Ref<CloseWatcherManager> close_watcher_manager();
LibWeb/HTML: Port Window.navigator to IDL
2023-03-05 17:55:03 +00:00
LibWeb/HTML: Port Window.alert() to IDL
2023-03-05 16:02:35 +00:00
void alert(String const& message = {});
LibWeb/HTML: Port Window.confirm() to IDL
2023-03-05 17:21:24 +00:00
bool confirm(Optional<String> const& message);
LibWeb/HTML: Port Window.prompt() to IDL
2023-03-05 17:28:17 +00:00
Optional<String> prompt(Optional<String> const& message, Optional<String> const& default_);
LibWeb/HTML: Port Window.alert() to IDL
2023-03-05 16:02:35 +00:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
WebIDL::ExceptionOr<void> post_message(JS::Value message, String const&, Vector<GC::Root<JS::Object>> const&);
LibWeb: Make Window.postMessage closer to the spec The main issues are using Structured{Serialize,Deserailize} instead of Structured{Serialize,Deserialize}WithTransfer and the temporary execution context usage for StructuredDeserialize. Allows Discord to load once again, as it uses a postMessage scheduler to render components, including the main App component. The callback checked the (previously) non-existent source attribute of the MessageEvent and returned if it was not the main window. Fixes the Twitch cookie consent banner saying "failed integrity check" for unknown reasons, but presumably related to the source and origin attributes.
2023-11-06 20:22:56 +00:00
WebIDL::ExceptionOr<void> post_message(JS::Value message, WindowPostMessageOptions const&);
LibWeb/HTML: Port Window.postMessage() to IDL
2023-03-05 17:36:59 +00:00
LibWeb/Bindings: Generate undefined in a union as 'Empty' This can only ever be undefined, and no other JS value, so it makes sense to use undefined to represent this case.
2025-01-12 22:50:03 +13:00
Variant<GC::Root<DOM::Event>, Empty> event() const;
LibWeb/HTML: Port Window.event to IDL
2023-03-06 19:50:29 +00:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
[[nodiscard]] GC::Ref<CSS::CSSStyleDeclaration> get_computed_style(DOM::Element&, Optional<String> const& pseudo_element) const;
LibWeb/HTML: Port Window.getComputedStyle() to IDL
2023-03-06 22:18:29 +00:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
WebIDL::ExceptionOr<GC::Ref<CSS::MediaQueryList>> match_media(String const& query);
[[nodiscard]] GC::Ref<CSS::Screen> screen();
[[nodiscard]] GC::Ptr<CSS::VisualViewport> visual_viewport();
LibWeb/HTML: Port Window.matchMedia() to IDL
2023-03-06 19:51:05 +00:00
LibWeb/HTML: Port Window.inner{Width,Height} to IDL
2023-03-06 19:51:33 +00:00
i32 inner_width() const;
i32 inner_height() const;
LibWeb: Add various window transformation methods
2024-02-21 04:17:27 -05:00
void move_to(long, long) const;
void move_by(long, long) const;
void resize_to(long, long) const;
void resize_by(long, long) const;
LibWeb/HTML: Port Window.scroll{X,Y} / Window.page{X,Y}Offset to IDL
2023-03-06 19:51:44 +00:00
double scroll_x() const;
double scroll_y() const;
LibWeb/HTML: Port Window.scroll() to IDL ...with various changes required due to ScrollBehavior / ScrollOptions moving from Element.idl to Window.idl.
2023-03-06 20:53:49 +00:00
void scroll(ScrollToOptions const&);
void scroll(double x, double y);
LibWeb/HTML: Port Window.scrollBy() to IDL
2023-03-06 21:17:19 +00:00
void scroll_by(ScrollToOptions);
void scroll_by(double x, double y);
LibWeb/HTML: Port Window.scroll{X,Y} / Window.page{X,Y}Offset to IDL
2023-03-06 19:51:44 +00:00
LibWeb/HTML: Port Window.screen{X,Y} / Window.screen{Left,Top} to IDL
2023-03-06 21:38:09 +00:00
i32 screen_x() const;
i32 screen_y() const;
LibWeb/HTML: Port Window.outer{Width,Height} to IDL
2023-03-06 22:02:09 +00:00
i32 outer_width() const;
i32 outer_height() const;
LibWeb/HTML: Port Window.devicePixelRatio to IDL
2023-03-06 22:10:10 +00:00
double device_pixel_ratio() const;
LibWeb/HTML: Port Window.screen{X,Y} / Window.screen{Left,Top} to IDL
2023-03-06 21:38:09 +00:00
LibWeb: Allocate AnimationFrameCallbackDriver on the JS heap This avoids needing to creating root handles for each heap-allocated object captured in the animation callback. An upcoming commit would add several of these.
2024-10-30 20:13:31 -04:00
AnimationFrameCallbackDriver& animation_frame_callback_driver();
bool has_animation_frame_callbacks();
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::UnsignedLong request_animation_frame(GC::Ref<WebIDL::CallbackType>);
LibWeb: Make requestAnimationFrame() callback IDs sequential This is required by the spec, so let's stop returning random IDs in favor of a simple sequential integer sequence.
2024-08-04 16:36:50 +02:00
void cancel_animation_frame(WebIDL::UnsignedLong handle);
LibWeb/HTML: Port Window.requestAnimationFrame() to IDL
2023-03-07 18:12:58 +00:00
LibWeb/HTML: Port Window.requestIdleCallback() to IDL
2023-03-06 23:38:44 +00:00
u32 request_idle_callback(WebIDL::CallbackType&, RequestIdleCallback::IdleRequestOptions const&);
LibWeb/HTML: Port Window.cancelIdleCallback() to IDL
2023-03-06 23:43:25 +00:00
void cancel_idle_callback(u32 handle);
LibWeb/HTML: Port Window.requestIdleCallback() to IDL
2023-03-06 23:38:44 +00:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<Selection::Selection> get_selection() const;
LibWeb/HTML: Port Window.getSelection() to IDL
2023-03-06 22:34:48 +00:00
LibWeb: Add methods to Window that must do nothing This change adds the `captureEvents()` and `releaseEvents()` methods to the window object. These methods are obsolete, but are still included in the HTML specification, which says they must do nothing.
2024-04-14 07:38:10 +01:00
void capture_events();
void release_events();
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]] GC::Ref<CustomElementRegistry> custom_elements();
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
LibWeb: Remove get prefix from activation timestamp getters
2024-05-29 10:07:37 -06:00
HighResolutionTime::DOMHighResTimeStamp last_activation_timestamp() const { return m_last_activation_timestamp; }
LibWeb: Set `last activation timestamp` on the window
2023-05-31 00:13:56 +02:00
void set_last_activation_timestamp(HighResolutionTime::DOMHighResTimeStamp timestamp) { m_last_activation_timestamp = timestamp; }
LibWeb: Implement consume user activation AO
2024-05-29 10:53:55 -06:00
void consume_user_activation();
LibWeb: Remove get prefix from activation timestamp getters
2024-05-29 10:07:37 -06:00
HighResolutionTime::DOMHighResTimeStamp last_history_action_activation_timestamp() const { return m_last_history_action_activation_timestamp; }
LibWeb: Implement "consume history-action user activation"
2024-05-25 14:21:02 +01:00
void set_last_history_action_activation_timestamp(HighResolutionTime::DOMHighResTimeStamp timestamp) { m_last_history_action_activation_timestamp = timestamp; }
LibWeb: Move consume history-action user activation to Window
2024-05-29 10:14:40 -06:00
void consume_history_action_user_activation();
LibWeb: Add a simple `internals` objects only available during testing This object is available as `window.internals` (or just `internals`) and is only accessible while running in "test mode". This first version only has one API: gc(), which triggers a garbage collection immediately. In the future, we can add more APIs here to help us test parts of the engine that are hard or impossible to reach via public web APIs.
2023-07-21 11:59:49 +02:00
static void set_internals_object_exposed(bool);
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]] OrderedHashMap<FlyString, GC::Ref<Navigable>> document_tree_child_navigable_target_name_property_set();
LibWeb: Implement document-tree child navigable target name property set This AO allows accessing child navigables by their name as named properties on the WindowProxy object.
2023-09-18 21:56:11 -06:00
LibWeb: Delete LegacyPlatformObject and move behavior to PlatformObject We have two known PlatformObjects that need to implement some of the behavior of LegacyPlatformObjects to date: Window, and HTMLFormElement. To make this not require double (or virtual) inheritance of PlatformObject, move the behavior of LegacyPlatformObject into PlatformObject. The selection of LegacyPlatformObject behavior is done with a new bitfield of feature flags instead of a dozen virtual functions that return bool. This change simplifies every class involved in the diff with the notable exception of Window, which now needs some ugly const casts to implement named property access.
2024-01-09 16:05:03 -07:00
[[nodiscard]] Vector<FlyString> supported_property_names() const override;
Bindings: Remove exception handling for named_item_value
2024-07-25 17:36:10 +12:00
[[nodiscard]] JS::Value named_item_value(FlyString const&) const override;
LibWeb: Insert WindowProperties object into Window's prototype chain And implement WindowProperties, the "named properties object" for Window according to the spec. This involves moving an AO out of LegacyPlatformObject and into a common place that the WindowProperties class can access. This doesn't implement the AOs on Window that actually name lookup for the unenumerable named properties on the window yet, just the scaffolding.
2023-09-19 13:32:13 -06:00
LibWeb: Implement a minimal version of `Window.find()` This is a non-standard API that other browsers implement, which highlights matching text in the current window. This is just a thin wrapper around our find in page functionality, the main motivation for adding this API is that it allows us to write tests for our find in page implementation.
2024-06-25 22:52:01 +01:00
bool find(String const& string);
LibWeb+LibJS: Move DOM Window object to dedicated classes LibWeb now creates a WindowObject which inherits from GlobalObject. Allocation of the global object is moved out of the Interpreter ctor to allow for specialized construction. The existing Window interfaces are moved to WindowObject with their implementation code in the new Window class.
2020-04-01 18:53:28 +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
explicit Window(JS::Realm&);
LibWeb: Avoid dynamic_cast in EventTarget initialization Let's use a virtual to tell if something uses the WindowOrWorkerGlobalScope mixin instead.
2025-04-18 10:21:36 +02:00
virtual bool is_window_or_worker_global_scope_mixin() const final { return true; }
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
virtual void visit_edges(Cell::Visitor&) override;
LibWeb: Stop timers when finalizing a Window or WorkerGlobalScope This avoids an assertion that timers are not active when destroyed.
2024-01-03 10:10:47 +01:00
virtual void finalize() override;
LibWeb+LibJS: Move DOM Window object to dedicated classes LibWeb now creates a WindowObject which inherits from GlobalObject. Allocation of the global object is moved out of the Interpreter ctor to allow for specialized construction. The existing Window interfaces are moved to WindowObject with their implementation code in the new Window class.
2020-04-01 18:53:28 +02:00
LibJS+LibWeb: Add JS::Object::fast_is<T> helpers for some LibWeb types These are slightly unfortunate as we're crossing the library boundary, but there's precedent with Object::is_dom_node(), and these are just knocking down a few more items that were showing up in profiles.
2025-04-18 10:31:28 +02:00
virtual bool is_html_window() const override { return true; }
LibWeb: Expose the GlobalEventHandlers mixin on the Window object We now expose all the `onfoo` event handler attributes on the window object. This makes `window.onload = ...` actually work. :^)
2021-09-22 16:39:15 +02:00
// ^HTML::GlobalEventHandlers
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
virtual GC::Ptr<DOM::EventTarget> global_event_handlers_to_event_target(FlyString const&) override { return *this; }
LibWeb: Expose the GlobalEventHandlers mixin on the Window object We now expose all the `onfoo` event handler attributes on the window object. This makes `window.onload = ...` actually work. :^)
2021-09-22 16:39:15 +02:00
LibWeb: Implement WindowEventHandlers
2022-06-27 19:48:54 +01:00
// ^HTML::WindowEventHandlers
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
virtual GC::Ptr<DOM::EventTarget> window_event_handlers_to_event_target() override { return *this; }
LibWeb: Implement WindowEventHandlers
2022-06-27 19:48:54 +01:00
LibWeb: Implement the infrastructure necessary for requestIdleCallback This includes a bug fix for the event loop processing steps which has not been merged yet: https://github.com/whatwg/html/pull/7768
2022-03-31 21:55:01 +02:00
void invoke_idle_callbacks();
LibWeb: Implement named property access AOs on Window These allow accessing embeds, forms, images and objects with a given name attribute, and any element with a given id attribute, as top level properties on the global object. It also allows accessing NavigableContainers by target name as top level properties on the global object. The current implementation feels very expensive. It's likely that these values will need smarter caching in the future.
2023-09-19 16:40:42 -06:00
struct [[nodiscard]] NamedObjects {
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
Vector<GC::Ref<Navigable>> navigables;
Vector<GC::Ref<DOM::Element>> elements;
LibWeb: Implement named property access AOs on Window These allow accessing embeds, forms, images and objects with a given name attribute, and any element with a given id attribute, as top level properties on the global object. It also allows accessing NavigableContainers by target name as top level properties on the global object. The current implementation feels very expensive. It's likely that these values will need smarter caching in the future.
2023-09-19 16:40:42 -06:00
};
NamedObjects named_objects(StringView name);
LibWeb: Make Window.postMessage closer to the spec The main issues are using Structured{Serialize,Deserailize} instead of Structured{Serialize,Deserialize}WithTransfer and the temporary execution context usage for StructuredDeserialize. Allows Discord to load once again, as it uses a postMessage scheduler to render components, including the main App component. The callback checked the (previously) non-existent source attribute of the MessageEvent and returned if it was not the main window. Fixes the Twitch cookie consent banner saying "failed integrity check" for unknown reasons, but presumably related to the source and origin attributes.
2023-11-06 20:22:56 +00:00
WebIDL::ExceptionOr<void> window_post_message_steps(JS::Value, WindowPostMessageOptions const&);
LibWeb: Rename DOM::Window::document() => associated_document() Match the spec nomenclature.
2021-09-09 13:55:31 +02:00
// https://html.spec.whatwg.org/multipage/window-object.html#concept-document-window
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<DOM::Document> m_associated_document;
LibWeb: Rename DOM::Window::document() => associated_document() Match the spec nomenclature.
2021-09-09 13:55:31 +02:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<DOM::Event> m_current_event;
LibWeb: Make DOM timers cancellable and stop leaking them This patch adds a Web::Timer object that represents a single timer registration made with window.setTimeout() or window.setInterval(). All live timers are owned by the DOM Window object. The timers can be stopped via clearTimeout() or clearInterval(). Note that those API's are actually interchangeable, but we have to support both.
2020-06-27 18:30:29 +02:00
LibWeb: Implement multiple import map support
2024-12-03 20:31:14 +13:00
// https://html.spec.whatwg.org/multipage/webappapis.html#resolved-module-set
// A global object has a resolved module set, a set of specifier resolution records, initially empty.
//
// Spec-Note: The resolved module set ensures that module specifier resolution returns the same result when called
// multiple times with the same (referrer, specifier) pair. It does that by ensuring that import map rules
// that impact the specifier in its referrer's scope cannot be defined after its initial resolution. For
// now, only Window global objects have their module set data structures modified from the initial empty one.
Vector<SpecifierResolution> m_resolved_module_set;
LibWeb: Expose an import map and import maps allowed on Window
2022-10-23 04:05:46 +02:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<CSS::Screen> m_screen;
GC::Ptr<Navigator> m_navigator;
GC::Ptr<Location> m_location;
GC::Ptr<CloseWatcherManager> m_close_watcher_manager;
LibWeb: Make requestAnimationFrame() work in multi-process mode Since we don't have a direct connection to WindowServer, this is slighly more naive implementation than what we were doing for single-process mode. Basically, there's a global RequestAnimationFrameDriver object that has a 16ms single-shot timer. Whenever someone registers for a RAF callback, we start the timer (if needed). This is not ideal, but it's better than nothing. :^)
2021-09-13 02:03:06 +02:00
LibWeb: Add window.navigation property
2023-08-23 10:58:09 -06:00
// https://html.spec.whatwg.org/multipage/nav-history-apis.html#window-navigation-api
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<Navigation> m_navigation;
LibWeb: Add window.navigation property
2023-08-23 10:58:09 -06:00
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
// https://html.spec.whatwg.org/multipage/custom-elements.html#custom-elements-api
LibWeb: Match spec changes for "custom element registry" concept Corresponds to https://github.com/whatwg/html/pull/10845 and https://github.com/whatwg/html/pull/10865
2024-12-18 15:58:36 +00:00
// Each Window object has an associated custom element registry (a CustomElementRegistry object).
// It is set to a new CustomElementRegistry object when the Window object is created.
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<CustomElementRegistry> m_custom_element_registry;
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<AnimationFrameCallbackDriver> m_animation_frame_callback_driver;
LibWeb: Implement the infrastructure necessary for requestIdleCallback This includes a bug fix for the event loop processing steps which has not been merged yet: https://github.com/whatwg/html/pull/7768
2022-03-31 21:55:01 +02:00
// https://w3c.github.io/requestidlecallback/#dfn-list-of-idle-request-callbacks
Everywhere: Stop using NonnullRefPtrVector This class had slightly confusing semantics and the added weirdness doesn't seem worth it just so we can say "." instead of "->" when iterating over a vector of NNRPs. This patch replaces NonnullRefPtrVector<T> with Vector<NNRP<T>>.
2023-03-06 14:17:01 +01:00
Vector<NonnullRefPtr<IdleCallback>> m_idle_request_callbacks;
LibWeb: Implement the infrastructure necessary for requestIdleCallback This includes a bug fix for the event loop processing steps which has not been merged yet: https://github.com/whatwg/html/pull/7768
2022-03-31 21:55:01 +02:00
// https://w3c.github.io/requestidlecallback/#dfn-list-of-runnable-idle-callbacks
Everywhere: Stop using NonnullRefPtrVector This class had slightly confusing semantics and the added weirdness doesn't seem worth it just so we can say "." instead of "->" when iterating over a vector of NNRPs. This patch replaces NonnullRefPtrVector<T> with Vector<NNRP<T>>.
2023-03-06 14:17:01 +01:00
Vector<NonnullRefPtr<IdleCallback>> m_runnable_idle_callbacks;
LibWeb: Implement the infrastructure necessary for requestIdleCallback This includes a bug fix for the event loop processing steps which has not been merged yet: https://github.com/whatwg/html/pull/7768
2022-03-31 21:55:01 +02:00
// https://w3c.github.io/requestidlecallback/#dfn-idle-callback-identifier
u32 m_idle_callback_identifier = 0;
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: Implement navigator.{plugins,mimeTypes}
2023-02-28 00:23:53 +00:00
// https://html.spec.whatwg.org/multipage/system-state.html#pdf-viewer-plugin-objects
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
Vector<GC::Ref<Plugin>> m_pdf_viewer_plugin_objects;
LibWeb: Implement navigator.{plugins,mimeTypes}
2023-02-28 00:23:53 +00:00
// https://html.spec.whatwg.org/multipage/system-state.html#pdf-viewer-mime-type-objects
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
Vector<GC::Ref<MimeType>> m_pdf_viewer_mime_type_objects;
LibWeb: Implement navigator.{plugins,mimeTypes}
2023-02-28 00:23:53 +00:00
LibWeb/HTML: Consolidate duplicate public/private sections in Window.h
2023-03-11 16:44:15 +00:00
// [[CrossOriginPropertyDescriptorMap]], https://html.spec.whatwg.org/multipage/browsers.html#crossoriginpropertydescriptormap
CrossOriginPropertyDescriptorMap m_cross_origin_property_descriptor_map;
LibWeb: Set `last activation timestamp` on the window
2023-05-31 00:13:56 +02:00
// https://html.spec.whatwg.org/multipage/interaction.html#user-activation-data-model
LibWeb: Use Infinity<double> for infinity Co-authored-by: Matthew Olsson <matthewcolsson@gmail.com>
2024-05-25 16:39:18 +01:00
HighResolutionTime::DOMHighResTimeStamp m_last_activation_timestamp { AK::Infinity<double> };
LibWeb: Implement size attribute of CountQueuingStrategy Co-authored-by: Matthew Olsson <mattco@serenityos.org>
2023-06-23 08:46:46 +12:00
LibWeb: Implement "consume history-action user activation"
2024-05-25 14:21:02 +01:00
// https://html.spec.whatwg.org/multipage/interaction.html#last-history-action-activation-timestamp
HighResolutionTime::DOMHighResTimeStamp m_last_history_action_activation_timestamp { AK::Infinity<double> };
LibWeb: Add window.status property
2023-12-04 19:52:04 +01:00
// https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-window-status
// When the Window object is created, the attribute must be set to the empty string. It does not do anything else.
String m_status;
LibWeb: Implement BarProp properties for Window
2025-03-04 22:51:08 +01:00
GC::Ptr<BarProp const> m_locationbar;
GC::Ptr<BarProp const> m_menubar;
GC::Ptr<BarProp const> m_personalbar;
GC::Ptr<BarProp const> m_scrollbars;
GC::Ptr<BarProp const> m_statusbar;
GC::Ptr<BarProp const> m_toolbar;
LibWeb+LibJS: Move DOM Window object to dedicated classes LibWeb now creates a WindowObject which inherits from GlobalObject. Allocation of the global object is moved out of the Interpreter ctor to allow for specialized construction. The existing Window interfaces are moved to WindowObject with their implementation code in the new Window class.
2020-04-01 18:53:28 +02:00
};
LibWeb: Let HTML::EventLoop drive animation frame callbacks
2021-10-03 16:28:14 +02:00
void run_animation_frame_callbacks(DOM::Document&, double now);
LibWeb+LibJS: Move DOM Window object to dedicated classes LibWeb now creates a WindowObject which inherits from GlobalObject. Allocation of the global object is moved out of the Interpreter ctor to allow for specialized construction. The existing Window interfaces are moved to WindowObject with their implementation code in the new Window class.
2020-04-01 18:53:28 +02:00
}
LibJS+LibWeb: Add JS::Object::fast_is<T> helpers for some LibWeb types These are slightly unfortunate as we're crossing the library boundary, but there's precedent with Object::is_dom_node(), and these are just knocking down a few more items that were showing up in profiles.
2025-04-18 10:31:28 +02:00
template<>
inline bool JS::Object::fast_is<Web::HTML::Window>() const { return is_html_window(); }
Reference in a new issue Copy permalink