mirrors/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-01-24 02:03:06 -05:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibWeb/HTML/Window.h

265 lines
9.2 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: 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
* Copyright (c) 2020-2022, Andreas Kling <kling@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>
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
#include <AK/IDAllocator.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/NonnullRefPtrVector.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
#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>
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 <AK/URL.h>
#include <LibJS/Heap/Heap.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: 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: Stop inactive requestAnimationFrame() callbacks from running Previously requestAnimationFrame() callbacks were registered with a static global RequestAnimationFrameDriver shared between all windows. This led to callbacks still running after navigating away from a page (This could be seen with the WASM GoL demo). This commit moves the RequestAnimationFrameDriver (now AnimationFrameCallbackDriver) to be a member of the HTML::Window object, then uses the 'active document' parameter of run_animation_frame_callbacks() to run only the active callbacks.
2022-05-05 20:08:29 +01:00
#include <LibWeb/HTML/AnimationFrameCallbackDriver.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 WindowEventHandlers
2022-06-27 19:48:54 +01:00
#include <LibWeb/HTML/WindowEventHandlers.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+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
// https://html.spec.whatwg.org/#timerhandler
LibWeb: Move CallbackType from Bindings/ to WebIDL/ Let's stop putting generic types and AOs from the Web IDL spec into the Bindings namespace and directory in LibWeb, and instead follow our usual naming rules of 'directory = namespace = spec name'. The IDL namespace is already used by LibIDL, so Web::WebIDL seems like a good choice.
2022-09-24 16:02:41 +01:00
using TimerHandler = Variant<JS::Handle<WebIDL::CallbackType>, String>;
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: 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: Implement WindowEventHandlers
2022-06-27 19:48:54 +01:00
, public HTML::GlobalEventHandlers
, public HTML::WindowEventHandlers {
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);
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:
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
static JS::NonnullGCPtr<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: 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: 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
Page* page();
Page const* page() const;
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+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
HTML::BrowsingContext const* browsing_context() const;
HTML::BrowsingContext* browsing_context();
LibWeb: Implement window.length
2022-09-06 19:56:29 +02:00
JS::ThrowCompletionOr<size_t> document_tree_child_browsing_context_count() const;
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
void alert_impl(String const&);
bool confirm_impl(String const&);
String prompt_impl(String const&, String const&);
LibWeb: Move CallbackType from Bindings/ to WebIDL/ Let's stop putting generic types and AOs from the Web IDL spec into the Bindings namespace and directory in LibWeb, and instead follow our usual naming rules of 'directory = namespace = spec name'. The IDL namespace is already used by LibIDL, so Web::WebIDL seems like a good choice.
2022-09-24 16:02:41 +01:00
i32 request_animation_frame_impl(WebIDL::CallbackType& js_callback);
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
void cancel_animation_frame_impl(i32);
LibWeb: Stop inactive requestAnimationFrame() callbacks from running Previously requestAnimationFrame() callbacks were registered with a static global RequestAnimationFrameDriver shared between all windows. This led to callbacks still running after navigating away from a page (This could be seen with the WASM GoL demo). This commit moves the RequestAnimationFrameDriver (now AnimationFrameCallbackDriver) to be a member of the HTML::Window object, then uses the 'active document' parameter of run_animation_frame_callbacks() to run only the active callbacks.
2022-05-05 20:08:29 +01:00
bool has_animation_frame_callbacks() const { return m_animation_frame_callback_driver.has_callbacks(); }
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+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
i32 set_timeout_impl(TimerHandler, i32 timeout, JS::MarkedVector<JS::Value> arguments);
i32 set_interval_impl(TimerHandler, i32 timeout, JS::MarkedVector<JS::Value> arguments);
void clear_timeout_impl(i32);
void clear_interval_impl(i32);
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 CallbackType from Bindings/ to WebIDL/ Let's stop putting generic types and AOs from the Web IDL spec into the Bindings namespace and directory in LibWeb, and instead follow our usual naming rules of 'directory = namespace = spec name'. The IDL namespace is already used by LibIDL, so Web::WebIDL seems like a good choice.
2022-09-24 16:02:41 +01:00
void queue_microtask_impl(WebIDL::CallbackType& callback);
LibWeb: Implement window.queueMicrotask(callback) This API allows authors to schedule a serialized JS callback that will get invoked at the next spec-allowed opportunity.
2021-09-26 14:36:20 +02:00
LibWeb: Add Window.innerWidth and Window.innerHeight
2021-03-16 17:22:01 +01:00
int inner_width() const;
int inner_height() const;
LibWeb: Add the Web::URL namespace and move URLEncoder to it This namespace will be used for all interfaces defined in the URL specification, like URL and URLSearchParams. This has the unfortunate side-effect of requiring us to use the fully qualified AK::URL name whenever we want to refer to the AK class, so this commit also fixes all such references.
2021-09-13 00:33:23 +03:00
void did_set_location_href(Badge<Bindings::LocationObject>, AK::URL const& new_href);
LibWeb: Allow reloading the current page with location.reload()
2020-05-18 22:05:13 +02:00
void did_call_location_reload(Badge<Bindings::LocationObject>);
LibWeb: Basic support for location.replace(url) This is not entirely to spec, but gets the basic job done.
2021-10-03 23:31:52 +02:00
void did_call_location_replace(Badge<Bindings::LocationObject>, String url);
LibWeb: Allow navigating to a new URL by setting window.location.href
2020-05-18 21:52:50 +02:00
LibWeb: Move Timer from DOM directory & namespace to HTML Timers are part of the HTML spec. :^) https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers
2022-03-07 23:54:56 +01:00
void deallocate_timer_id(Badge<Timer>, i32);
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+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
HighResolutionTime::Performance& performance();
LibWeb: Implement performance.now() This patch introduces the HighResolutionTime namespace which is home to the Performance object (exposed via window.performance) performance.now() is currently the only function, and it returns the number of milliseconds since the window object was constructed. :^)
2020-09-29 18:19:18 +02:00
LibWeb: Add the Web::Crypto namespace, built-in, and getRandomValues Since we don't support IDL typedefs or unions yet, the responsibility of verifying the type of the argument is temporarily moved from the generated Wrapper to the implementation.
2021-09-30 20:02:55 +03:00
Crypto::Crypto& crypto() { return *m_crypto; }
LibWeb: Make CSS::Screen GC-allocated
2022-08-31 18:52:54 +02:00
CSS::Screen& screen();
LibWeb: Implement the Screen interface https://drafts.csswg.org/cssom-view/#the-screen-interface
2021-04-04 00:14:39 +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
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+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
CSS::CSSStyleDeclaration* get_computed_style_impl(DOM::Element&) const;
JS::NonnullGCPtr<CSS::MediaQueryList> match_media_impl(String);
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: Move window.scroll{X,Y} from wrapper into DOM::Window The less we do in WindowObject, the easier it will be to eventually auto-generate the entire thing.
2021-09-24 21:49:31 +02:00
float scroll_x() const;
float scroll_y() const;
LibWeb: Add the missing PageTransitionEvent IDL constructor
2021-10-01 19:05:28 +03: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
LibWeb: Support window.devicePixelRatio This always returns 1 for now. I've added a FIXME about returning 2 in HiDPI mode.
2021-09-27 16:34:06 +02:00
float device_pixel_ratio() const;
LibWeb: Support window.screen{X,Y,Left,Top} Some sites query these properties for whatever reason, so let's support them. (But let's always pretend the screen coordinates are (0, 0))
2021-09-29 00:15:26 +02:00
int screen_x() const;
int screen_y() const;
LibWeb: Make Storage GC-allocated
2022-09-03 19:44:37 +02:00
JS::NonnullGCPtr<HTML::Storage> local_storage();
JS::NonnullGCPtr<HTML::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: Reorganize window.parent so it looks a bit more like the spec
2022-02-26 15:55:45 +01:00
Window* parent();
LibWeb: Move ExceptionOr from DOM/ to WebIDL/ This is a concept fully defined in the Web IDL spec and doesn't belong in the DOM directory/namespace - not even DOMException, despite the name :^)
2022-09-25 17:03:42 +01:00
WebIDL::ExceptionOr<void> post_message_impl(JS::Value, String const& target_origin);
LibWeb: Add simple ad-hoc version of window.postMessage() This allows us to use the wpt.live copy of the ACID3 test, which is kept updated, unlike the acidtests.org version.
2022-02-26 17:21:40 +01:00
LibWeb: Implement window.name Right now the only functionality supported is getting/setting via JS and resetting when browsing cross origin. The HTML Specification (7.11 Browsing the web) also specifies how the name should be restored from history entries, but we don't have those yet.
2022-03-16 17:15:11 +01:00
String name() const;
void set_name(String const&);
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: Move CallbackType from Bindings/ to WebIDL/ Let's stop putting generic types and AOs from the Web IDL spec into the Bindings namespace and directory in LibWeb, and instead follow our usual naming rules of 'directory = namespace = spec name'. The IDL namespace is already used by LibIDL, so Web::WebIDL seems like a good choice.
2022-09-24 16:02:41 +01:00
u32 request_idle_callback_impl(WebIDL::CallbackType& callback);
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
void cancel_idle_callback_impl(u32);
LibWeb: Add the requestIdleCallback/cancelIdleCallback API
2022-04-01 19:46:29 +02:00
LibWeb: Stop inactive requestAnimationFrame() callbacks from running Previously requestAnimationFrame() callbacks were registered with a static global RequestAnimationFrameDriver shared between all windows. This led to callbacks still running after navigating away from a page (This could be seen with the WASM GoL demo). This commit moves the RequestAnimationFrameDriver (now AnimationFrameCallbackDriver) to be a member of the HTML::Window object, then uses the 'active document' parameter of run_animation_frame_callbacks() to run only the active callbacks.
2022-05-05 20:08:29 +01:00
AnimationFrameCallbackDriver& animation_frame_callback_driver() { return m_animation_frame_callback_driver; }
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: 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
void initialize_web_interfaces(Badge<WindowEnvironmentSettingsObject>);
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&);
virtual void initialize(JS::Realm&) override;
virtual void visit_edges(Cell::Visitor&) 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
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
LibWeb: Only make certain <body> and <frameset> events apply to Window Previously we forwarded all event handler attributes to Window from these two elements, however, we are only supposed to forward blur, error, focus, load, resize and scroll.
2022-06-27 19:20:09 +01:00
virtual 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
virtual DOM::EventTarget& window_event_handlers_to_event_target() override { return *this; }
LibWeb: Implement setTimeout/setInterval with ESO according to the spec Our setInterval implementation currently crashes on DuckDuckGo when it's invoked with a string argument. In this path, we were creating a native function to evaluate and execute that string. That evaluation was always returning a Completion, but NativeFunction expects ThrowCompletionOr. The conversion from Completion to ThrowCompletionOr would fail a VERIFY because that conversion is only valid if the Completion is an error; but we would trigger this conversion even on success. This change re-implements setTimeout & setInterval in direct accordance with the spec. So we avoid making that NativeFunction altogether, and DDG can progress past its invocation to the timer. With this change, we also have other features we did not previously support, such as passing any number of arguments to the timers. This does not implement handling of nesting levels yet.
2022-03-04 10:41:12 -05:00
enum class Repeat {
Yes,
No,
};
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
i32 run_timer_initialization_steps(TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments, Repeat repeat, Optional<i32> previous_id = {});
LibWeb: Implement setTimeout/setInterval with ESO according to the spec Our setInterval implementation currently crashes on DuckDuckGo when it's invoked with a string argument. In this path, we were creating a native function to evaluate and execute that string. That evaluation was always returning a Completion, but NativeFunction expects ThrowCompletionOr. The conversion from Completion to ThrowCompletionOr would fail a VERIFY because that conversion is only valid if the Completion is an error; but we would trigger this conversion even on success. This change re-implements setTimeout & setInterval in direct accordance with the spec. So we avoid making that NativeFunction altogether, and DDG can progress past its invocation to the timer. With this change, we also have other features we did not previously support, such as passing any number of arguments to the timers. This does not implement handling of nesting levels yet.
2022-03-04 10:41:12 -05: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: 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
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
JS::GCPtr<DOM::Document> m_associated_document;
LibWeb: Rename DOM::Window::document() => associated_document() Match the spec nomenclature.
2021-09-09 13:55:31 +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
JS::GCPtr<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
IDAllocator m_timer_id_allocator;
LibWeb: Make HTML::Timer GC-allocated These are the timers used internally by setTimeout() and setInterval().
2022-09-01 12:21:47 +02:00
HashMap<int, JS::NonnullGCPtr<Timer>> m_timers;
LibWeb: Implement performance.now() This patch introduces the HighResolutionTime namespace which is home to the Performance object (exposed via window.performance) performance.now() is currently the only function, and it returns the number of milliseconds since the window object was constructed. :^)
2020-09-29 18:19:18 +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
JS::GCPtr<HighResolutionTime::Performance> m_performance;
LibWeb: Make Crypto GC-allocated
2022-09-04 13:15:05 +02:00
JS::GCPtr<Crypto::Crypto> m_crypto;
LibWeb: Make CSS::Screen GC-allocated
2022-08-31 18:52:54 +02:00
JS::GCPtr<CSS::Screen> m_screen;
LibWeb: Re-implement HTML::Navigator using IDL Get rid of the bespoke NavigatorObject class and use the modern IDL strategies for creating platform objects to re-implement Navigator and its associcated mixin interfaces. While we're here, implement it in a way that brings WorkerNavigator up to spec :^)
2022-10-08 20:53:08 -06:00
JS::GCPtr<HTML::Navigator> m_navigator;
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: Stop inactive requestAnimationFrame() callbacks from running Previously requestAnimationFrame() callbacks were registered with a static global RequestAnimationFrameDriver shared between all windows. This led to callbacks still running after navigating away from a page (This could be seen with the WASM GoL demo). This commit moves the RequestAnimationFrameDriver (now AnimationFrameCallbackDriver) to be a member of the HTML::Window object, then uses the 'active document' parameter of run_animation_frame_callbacks() to run only the active callbacks.
2022-05-05 20:08:29 +01:00
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
NonnullRefPtrVector<IdleCallback> m_idle_request_callbacks;
// https://w3c.github.io/requestidlecallback/#dfn-list-of-runnable-idle-callbacks
NonnullRefPtrVector<IdleCallback> m_runnable_idle_callbacks;
// 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
public:
HTML::Origin origin() const;
Bindings::LocationObject* location_object() { return m_location_object; }
Bindings::LocationObject const* location_object() const { return m_location_object; }
virtual JS::ThrowCompletionOr<bool> internal_set_prototype_of(JS::Object* prototype) override;
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
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+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
private:
LibWeb: Implement window.length
2022-09-06 19:56:29 +02:00
JS_DECLARE_NATIVE_FUNCTION(length_getter);
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
JS_DECLARE_NATIVE_FUNCTION(top_getter);
JS_DECLARE_NATIVE_FUNCTION(document_getter);
LibWeb: Implement Window.frameElement
2022-09-20 11:14:23 +02:00
JS_DECLARE_NATIVE_FUNCTION(frame_element_getter);
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
JS_DECLARE_NATIVE_FUNCTION(location_getter);
JS_DECLARE_NATIVE_FUNCTION(location_setter);
JS_DECLARE_NATIVE_FUNCTION(name_getter);
JS_DECLARE_NATIVE_FUNCTION(name_setter);
JS_DECLARE_NATIVE_FUNCTION(performance_getter);
JS_DECLARE_NATIVE_FUNCTION(performance_setter);
JS_DECLARE_NATIVE_FUNCTION(history_getter);
JS_DECLARE_NATIVE_FUNCTION(screen_getter);
JS_DECLARE_NATIVE_FUNCTION(event_getter);
JS_DECLARE_NATIVE_FUNCTION(event_setter);
JS_DECLARE_NATIVE_FUNCTION(inner_width_getter);
JS_DECLARE_NATIVE_FUNCTION(inner_height_getter);
JS_DECLARE_NATIVE_FUNCTION(parent_getter);
JS_DECLARE_NATIVE_FUNCTION(device_pixel_ratio_getter);
JS_DECLARE_NATIVE_FUNCTION(scroll_x_getter);
JS_DECLARE_NATIVE_FUNCTION(scroll_y_getter);
JS_DECLARE_NATIVE_FUNCTION(scroll);
JS_DECLARE_NATIVE_FUNCTION(scroll_by);
JS_DECLARE_NATIVE_FUNCTION(screen_x_getter);
JS_DECLARE_NATIVE_FUNCTION(screen_y_getter);
JS_DECLARE_NATIVE_FUNCTION(screen_left_getter);
JS_DECLARE_NATIVE_FUNCTION(screen_top_getter);
JS_DECLARE_NATIVE_FUNCTION(post_message);
JS_DECLARE_NATIVE_FUNCTION(local_storage_getter);
JS_DECLARE_NATIVE_FUNCTION(session_storage_getter);
JS_DECLARE_NATIVE_FUNCTION(origin_getter);
JS_DECLARE_NATIVE_FUNCTION(alert);
JS_DECLARE_NATIVE_FUNCTION(confirm);
JS_DECLARE_NATIVE_FUNCTION(prompt);
JS_DECLARE_NATIVE_FUNCTION(set_interval);
JS_DECLARE_NATIVE_FUNCTION(set_timeout);
JS_DECLARE_NATIVE_FUNCTION(clear_interval);
JS_DECLARE_NATIVE_FUNCTION(clear_timeout);
JS_DECLARE_NATIVE_FUNCTION(request_animation_frame);
JS_DECLARE_NATIVE_FUNCTION(cancel_animation_frame);
JS_DECLARE_NATIVE_FUNCTION(atob);
JS_DECLARE_NATIVE_FUNCTION(btoa);
JS_DECLARE_NATIVE_FUNCTION(get_computed_style);
JS_DECLARE_NATIVE_FUNCTION(match_media);
JS_DECLARE_NATIVE_FUNCTION(get_selection);
JS_DECLARE_NATIVE_FUNCTION(queue_microtask);
JS_DECLARE_NATIVE_FUNCTION(request_idle_callback);
JS_DECLARE_NATIVE_FUNCTION(cancel_idle_callback);
JS_DECLARE_NATIVE_FUNCTION(crypto_getter);
#define __ENUMERATE(attribute, event_name) \
JS_DECLARE_NATIVE_FUNCTION(attribute##_getter); \
JS_DECLARE_NATIVE_FUNCTION(attribute##_setter);
ENUMERATE_GLOBAL_EVENT_HANDLERS(__ENUMERATE);
ENUMERATE_WINDOW_EVENT_HANDLERS(__ENUMERATE);
#undef __ENUMERATE
Bindings::LocationObject* m_location_object { nullptr };
// [[CrossOriginPropertyDescriptorMap]], https://html.spec.whatwg.org/multipage/browsers.html#crossoriginpropertydescriptormap
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
CrossOriginPropertyDescriptorMap m_cross_origin_property_descriptor_map;
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
}
Reference in a new issue Copy permalink