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

149 lines
5 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+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/RefCounted.h>
#include <AK/RefPtr.h>
LibWeb: Weakly store a reference to the Window object in timer tasks This prevents a crash when refreshing or navigating away from the Acid3 test page while it is actively running.
2022-03-24 16:09:09 -04:00
#include <AK/Weakable.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 <LibWeb/Bindings/WindowObject.h>
#include <LibWeb/Bindings/Wrappable.h>
LibWeb: Implement window.matchMedia()
2021-09-12 17:10:27 +01:00
#include <LibWeb/CSS/MediaQueryList.h>
LibWeb: Implement the Screen interface https://drafts.csswg.org/cssom-view/#the-screen-interface
2021-04-04 00:14:39 +02:00
#include <LibWeb/CSS/Screen.h>
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
#include <LibWeb/DOM/Document.h>
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
#include <LibWeb/DOM/Event.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: 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
#include <LibWeb/HTML/BrowsingContext.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+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: 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
class RequestAnimationFrameCallback;
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
: public RefCounted<Window>
LibWeb: Weakly store a reference to the Window object in timer tasks This prevents a crash when refreshing or navigating away from the Acid3 test page while it is actively running.
2022-03-24 16:09:09 -04:00
, public Weakable<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
, public DOM::EventTarget
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
, public HTML::GlobalEventHandlers {
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: 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
static NonnullRefPtr<Window> create_with_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
~Window();
LibWeb: Make DOM::Window into an EventTarget This will allow us to dispatch window events.
2020-10-18 13:43:44 +02:00
using RefCounted::ref;
using RefCounted::unref;
virtual void ref_event_target() override { RefCounted::ref(); }
virtual void unref_event_target() override { RefCounted::unref(); }
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
virtual bool dispatch_event(NonnullRefPtr<DOM::Event>) override;
LibWeb: Make the Window object "inherit" from EventTarget :^) Since Web::Bindings::WindowObject inherits from JS::GlobalObject, it cannot also inherit from Web::Bindings::EventTargetWrapper. However, that's not actually necessary. Instead, we simply set the Window object's prototype to the EventTargetPrototype, and add a little extra branch in the impl_from() function that turns the JS "this" value into a DOM::EventTarget*. With this, you can now call window.addEventListener()! Very cool :^) Fixes #4758.
2021-01-18 12:15:02 +01:00
virtual JS::Object* create_wrapper(JS::GlobalObject&) 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+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
HTML::BrowsingContext const* browsing_context() const { return m_associated_document->browsing_context(); }
HTML::BrowsingContext* browsing_context() { return m_associated_document->browsing_context(); }
LibWeb: Convert DOM::Window to east-const style
2021-09-09 13:50:06 +02:00
void alert(String const&);
bool confirm(String const&);
String prompt(String const&, String const&);
LibWeb: Rewrite EventTarget to more closely match the spec This isn't perfect (especially the global object situation in activate_event_handler), but I believe it's in a much more complete state now :^) This fixes the issue of crashing in prepare_for_ordinary_call with the `i < m_size` crash, as it now uses the IDL callback functions which requires the Environment Settings Object. The environment settings object for the callback is fetched at the time the callback is created, for example, WrapperGenerator gets the incumbent settings object for the callback at the time of wrapping. This allows us to remove passing in ScriptExecutionContext into EventTarget's constructor. With this, we can now drop ScriptExecutionContext.
2021-10-14 18:03:08 +01:00
i32 request_animation_frame(NonnullOwnPtr<Bindings::CallbackType> js_callback);
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
void cancel_animation_frame(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: 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
i32 set_timeout(Bindings::TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments);
i32 set_interval(Bindings::TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments);
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
void clear_timeout(i32);
void clear_interval(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: Rewrite EventTarget to more closely match the spec This isn't perfect (especially the global object situation in activate_event_handler), but I believe it's in a much more complete state now :^) This fixes the issue of crashing in prepare_for_ordinary_call with the `i < m_size` crash, as it now uses the IDL callback functions which requires the Environment Settings Object. The environment settings object for the callback is fetched at the time the callback is created, for example, WrapperGenerator gets the incumbent settings object for the callback at the time of wrapping. This allows us to remove passing in ScriptExecutionContext into EventTarget's constructor. With this, we can now drop ScriptExecutionContext.
2021-10-14 18:03:08 +01:00
void queue_microtask(NonnullOwnPtr<Bindings::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: Give the DOM Window object a (weak) pointer to its JS wrapper
2020-06-20 17:45:27 +02:00
Bindings::WindowObject* wrapper() { return m_wrapper; }
LibWeb: Convert DOM::Window to east-const style
2021-09-09 13:50:06 +02:00
Bindings::WindowObject const* wrapper() const { return m_wrapper; }
LibWeb: Give the DOM Window object a (weak) pointer to its JS wrapper
2020-06-20 17:45:27 +02:00
void set_wrapper(Badge<Bindings::WindowObject>, Bindings::WindowObject&);
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: 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
HighResolutionTime::Performance& performance() { return *m_performance; }
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: Implement the Screen interface https://drafts.csswg.org/cssom-view/#the-screen-interface
2021-04-04 00:14:39 +02:00
CSS::Screen& screen() { return *m_screen; }
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::Event const* current_event() const { return m_current_event; }
void set_current_event(DOM::Event* event) { m_current_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: 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
NonnullRefPtr<CSS::CSSStyleDeclaration> get_computed_style(DOM::Element&) const;
LibWeb: Implement window.matchMedia()
2021-09-12 17:10:27 +01:00
NonnullRefPtr<CSS::MediaQueryList> match_media(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: Stub out a basic Selection interface This patch establishes scaffolding for the Selection API.
2021-10-10 19:12:32 +02:00
Selection::Selection* get_selection();
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
RefPtr<HTML::Storage> local_storage();
LibWeb: Add window.sessionStorage
2022-03-08 04:39:44 +13:00
RefPtr<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: 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
DOM::ExceptionOr<void> post_message(JS::Value, String const& target_origin);
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+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: 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
explicit Window(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: 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
virtual DOM::EventTarget& global_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,
};
i32 run_timer_initialization_steps(Bindings::TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments, Repeat repeat, Optional<i32> previous_id = {});
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: 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
WeakPtr<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: Give the DOM Window object a (weak) pointer to its JS wrapper
2020-06-20 17:45:27 +02:00
WeakPtr<Bindings::WindowObject> m_wrapper;
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: 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
HashMap<int, NonnullRefPtr<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
NonnullOwnPtr<HighResolutionTime::Performance> m_performance;
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
NonnullRefPtr<Crypto::Crypto> m_crypto;
LibWeb: Make CSS::Screen forward its ref count to DOM::Window
2021-12-09 15:47:48 +01:00
NonnullOwnPtr<CSS::Screen> m_screen;
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
RefPtr<DOM::Event> m_current_event;
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
HashMap<i32, NonnullRefPtr<RequestAnimationFrameCallback>> m_request_animation_frame_callbacks;
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