LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-09-21 02:08:12 +03:00
Code Issues Packages Projects Releases Wiki Activity
3df9861814
ladybird/Userland/Libraries/LibWeb/DOM/Document.h

502 lines
19 KiB
C
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 11:38:21 +03:00
/*
LibWeb: Implement "NodeIterator pre-removing steps" These steps run when a node is about to be removed from its parent, and adjust the position of any live NodeIterators so that they don't point at a now-removed node. Note that while this commit implements what's in the DOM specification, the specification doesn't fully match what other browsers do. Spec bug: https://github.com/whatwg/dom/issues/907
2022-03-09 18:38:44 +03:00
* Copyright (c) 2018-2022, Andreas Kling <kling@serenityos.org>
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 11:38:21 +03:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 11:24:48 +03:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 11:38:21 +03:00
*/
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 19:55:47 +03:00
#pragma once
LibWeb: Use FlyString for Element tag names This makes selector matching a lot more efficient, and also reduces the number of strings on the heap.
2020-03-22 21:10:43 +03:00
#include <AK/FlyString.h>
LibHTML: Add function for invalidating the document layout This allows any external actor to signal that the document layout may be stale. This can be used when loading resources, changing the size or placement of an element, adding/removing nodes, or really any time.
2019-10-06 14:58:18 +03:00
#include <AK/Function.h>
LibWeb: Give each Node a unique ID We maintain a directory of ID -> Node. Nodes add themselves to this directory when they are created, receiving a random ID. When a Node is destroyed, it removes itself from this directory. Anyone can request a Node from the directory by its ID using `Node::from_id()`. We reserve the `0` ID to mean "none". These IDs allow different processes to communicate about a given Node over IPC, for example the DOM Inspector.
2021-08-30 17:52:08 +03:00
#include <AK/HashMap.h>
LibHTML: Refactor to go from DOM -> styled tree -> layout tree. Frame::layout() drives everything now, it takes the DOM contained in the frame and puts it through the tree transformations.
2019-06-29 22:42:07 +03:00
#include <AK/NonnullRefPtrVector.h>
#include <AK/OwnPtr.h>
LibHTML: Add a way to get a Document's title You can now query Document::title() to get a String containing whatever is inside the document's <title> tag. In support of this, this patch adds the <html>, <head> and <title> elements.
2019-09-29 17:24:57 +03:00
#include <AK/String.h>
LibHTML: Add load(URL) and reload() functions to HtmlView You can now pass a file:/// URL to HtmlView and it will take care of the loading logic for you. Each Document remembers the URL it was loaded from, which allows us to also have reload(). This patch also adds a very simple function for resolving relative URL's into absolute ones.
2019-10-05 11:16:27 +03:00
#include <AK/URL.h>
LibWeb: Add stubs for document.write and document.writeln ACID3 test page throws exception about document.write. Let's at least get rid of it by defining these stubs. I added document.writeln too because it is similar.
2022-02-15 19:36:27 +03:00
#include <AK/Vector.h>
LibHTML: Add a Frame class and use it for document layout width Each HtmlView now has a main_frame(), which represents the main frame of the web page. Frame inherits from TreeNode<Frame>, which will allow us to someday implement a Frame tree (to support the <frame> element.)
2019-10-04 16:50:04 +03:00
#include <AK/WeakPtr.h>
LibGfx: Replace manual forward declarations with <LibGfx/Forward.h>
2020-02-15 02:10:34 +03:00
#include <LibCore/Forward.h>
LibWeb: Parse <script> elements and run any JavaScript found inside This patch begins integrating LibJS into LibWeb. Document holds the JS::Interpreter for now, and it is created on demand when you first call Document::interpreter(). We also add a simple "alert()" function to the global object.
2020-03-14 14:41:51 +03:00
#include <LibJS/Forward.h>
LibWeb: Split CSS::StyleSheet into StyleSheet and CSSStyleSheet This is a little convoluted but matches the CSSOM specification.
2021-03-07 18:14:04 +03:00
#include <LibWeb/CSS/CSSStyleSheet.h>
LibWeb: Rename CSS::StyleResolver => StyleComputer Resolved style is a spec concept that refers to the weird mix of computed style and used style reflected by getComputedStyle(). The purpose of this class is to produce the *computed* style for a given element, so let's call it StyleComputer.
2021-09-24 14:49:57 +03:00
#include <LibWeb/CSS/StyleComputer.h>
LibWeb: Process style sheets in document order Until now we would simply apply stylesheets in the order they finished loading. This patch adds a StyleSheetList object that hangs off of each Document and contains all the style sheets in document order. There's still a lot of work to do for a proper cascade, but at least this makes us consistently wrong every time. :^)
2020-06-04 17:06:32 +03:00
#include <LibWeb/CSS/StyleSheetList.h>
Browser+LibWeb+WebContent: Track the source of document.cookie requests To implement the HttpOnly attribute, the CookieJar needs to know where a request originated from. Namely, it needs to distinguish between HTTP / non-HTTP (i.e. JavaScript) requests. When the HttpOnly attribute is set, requests from JavaScript are to be blocked.
2021-04-14 00:30:41 +03:00
#include <LibWeb/Cookie/Cookie.h>
LibWeb: Use DOMException in Document::set_body()
2021-02-20 02:42:25 +03:00
#include <LibWeb/DOM/ExceptionOr.h>
LibWeb: Move get_element_by_id() to a NonElementParentNode mixin class This matches the current version of the DOM spec. And since C++ doesn't have mixins this is actually a CRTP class.
2020-03-28 11:12:13 +03:00
#include <LibWeb/DOM/NonElementParentNode.h>
LibWeb: Rename directory LibHTML => LibWeb Let's rename this to LibWeb since it aims to provide more parts of the web platform than just HTML. :^)
2020-03-07 12:32:51 +03:00
#include <LibWeb/DOM/ParentNode.h>
LibWeb: Bring browsing context creation closer to spec This patch implements the "create a new browsing context" function from the HTML spec and replaces our existing logic with it. The big difference is that browsing contexts now initially navigate to "about:blank" instead of starting out in a strange "empty" state. This makes it possible for websites to create a new iframe and start scripting inside it right away, without having to load an URL into it.
2022-08-05 11:55:47 +03:00
#include <LibWeb/HTML/CrossOrigin/CrossOriginOpenerPolicy.h>
LibWeb: Store HTML document ready state as an enum
2021-09-26 13:08:50 +03:00
#include <LibWeb/HTML/DocumentReadyState.h>
LibWeb: Flesh out prepare_script and execute_script This fills in a bunch of the FIXMEs that was in prepare_script. execute_script is almost finished, it's just missing the module side. As an aside, let's not assert when inserting a script element with innerHTML.
2021-01-28 23:31:20 +03:00
#include <LibWeb/HTML/HTMLScriptElement.h>
LibWeb: Add the History object and stub pushState and replaceState The spec allows us to optionally return from these for any reason. Our reason is that we don't have all the infrastructure in place yet to implement them.
2021-09-12 01:43:34 +03:00
#include <LibWeb/HTML/History.h>
LibWeb: Move Origin into the HTML namespace Origin is defined in the HTML Standard, and therefore belongs into the HTML directory and namespace in LibWeb. https://html.spec.whatwg.org/multipage/origin.html#origin
2022-07-12 22:37:43 +03:00
#include <LibWeb/HTML/Origin.h>
LibWeb: Introduce the Environment Settings Object The environment settings object is effectively the context a piece of script is running under, for example, it contains the origin, responsible document, realm, global object and event loop for the current context. This effectively replaces ScriptExecutionContext, but it cannot be removed in this commit as EventTarget still depends on it. https://html.spec.whatwg.org/multipage/webappapis.html#environment-settings-object
2021-10-14 18:12:53 +03:00
#include <LibWeb/HTML/Scripting/Environments.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 14:42:07 +03:00
#include <LibWeb/HTML/Window.h>
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 19:55:47 +03:00
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 20:37:56 +03:00
namespace Web::DOM {
LibWeb: Move everything into the Web namespace
2020-03-07 12:27:02 +03:00
LibWeb: Implement quirks mode detection This allows us to determine which mode to render the page in. Exposes "doctype" and "compatMode" on Document. Exposes "name", "publicId" and "systemId" on DocumentType.
2020-07-18 23:17:17 +03:00
enum class QuirksMode {
No,
Limited,
Yes
};
LibWeb: Move get_element_by_id() to a NonElementParentNode mixin class This matches the current version of the DOM spec. And since C++ doesn't have mixins this is actually a CRTP class.
2020-03-28 11:12:13 +03:00
class Document
: public ParentNode
LibWeb: Add Bindings::ScriptExecutionContext This will be inherited by documents and workers, to provide a common abstraction for script execution. (We don't have workers yet, but we might as well make this little space for them now to simplify things down the road.)
2020-09-20 20:22:44 +03:00
, public NonElementParentNode<Document>
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 20:03:08 +03:00
, public HTML::GlobalEventHandlers {
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 14:42:07 +03:00
WEB_PLATFORM_OBJECT(Document, ParentNode);
LibWeb: Start implementing basic JavaScript DOM bindings This patch introduces the Wrapper and Wrappable classes. Node now inherits from Wrappable, and can be wrapped in a GC-allocated Bindings::NodeWrapper object. The only property we expose right now is the very simple nodeName property. When a Document's JS::Interpreter is first instantiated, we add a "document" property with a DocumentWrapper object to the global object. This is pretty cool! :^)
2020-03-14 15:15:11 +03: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 14:42:07 +03:00
public:
LibWeb: Add the type field to DOM::Document This patch adds the document type concept to documents and sets it in various places.
2022-07-03 22:44:00 +03:00
enum class Type {
XML,
HTML
};
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 14:42:07 +03:00
static JS::NonnullGCPtr<Document> create_and_initialize(Type, String content_type, HTML::NavigationParams);
LibWeb: Start implementing "create and initialize a Document" from HTML The way we've been creating DOM::Document has been pretty far from what the spec tells us to do, and this is a first big step towards getting us closer to spec. The new Document::create_and_initialize() is called by FrameLoader after loading a "text/html" resource. We create the JS Realm and the Window object when creating the Document (previously, we'd do it on first access to Document::interpreter().) The realm execution context is owned by the Environment Settings Object.
2022-08-04 22:30:33 +03: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 14:42:07 +03:00
static JS::NonnullGCPtr<Document> create(HTML::Window&, AK::URL const& url = "about:blank"sv);
static JS::NonnullGCPtr<Document> create_with_global_object(HTML::Window&);
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 19:55:47 +03:00
virtual ~Document() override;
LibWeb: Stop putting the FormattingState nodes in a slow hash map Instead, put them in a Vector<OwnPtr<NodeState>>. Each layout node has a unique index into the vector. It's a simple serial ID assigned during layout tree construction. Every new layout restarts the sequence at 0 for the next ICB. This is a huge layout speed improvement on all content.
2022-07-11 18:12:58 +03:00
size_t next_layout_node_serial_id(Badge<Layout::Node>) { return m_next_layout_node_serial_id++; }
size_t layout_node_count() const { return m_next_layout_node_serial_id; }
Browser+LibWeb+WebContent: Track the source of document.cookie requests To implement the HttpOnly attribute, the CookieJar needs to know where a request originated from. Namely, it needs to distinguish between HTTP / non-HTTP (i.e. JavaScript) requests. When the HttpOnly attribute is set, requests from JavaScript are to be blocked.
2021-04-14 00:30:41 +03:00
String cookie(Cookie::Source = Cookie::Source::NonHttp);
LibWeb: Pass cookie string by reference in Document::set_cookie This string is only taken by const reference internally, so there's no point in forcing the callers to copy the string.
2022-02-12 16:45:39 +03:00
void set_cookie(String const&, Cookie::Source = Cookie::Source::NonHttp);
LibWeb: Stub out Document.cookie We don't get/set anything, but at least scripts that access document cookies can now progress further. :^)
2021-03-14 18:35:28 +03:00
LibWeb: Add naive support for the Document.referrer attribute It always returns the empty string for now.
2021-09-11 13:29:06 +03:00
String referrer() const;
LibWeb: Add API for setting a document's referrer
2022-08-05 11:55:01 +03:00
void set_referrer(String);
LibWeb: Add naive support for the Document.referrer attribute It always returns the empty string for now.
2021-09-11 13:29:06 +03:00
LibWeb: Add hack to disable StyleInvalidator while parsing document Running a StyleInvalidator for every attribute set in a new document was making it impossible to load larger sites. :^)
2020-12-15 20:53:35 +03:00
bool should_invalidate_styles_on_attribute_changes() const { return m_should_invalidate_styles_on_attribute_changes; }
void set_should_invalidate_styles_on_attribute_changes(bool b) { m_should_invalidate_styles_on_attribute_changes = b; }
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 set_url(const AK::URL& url) { m_url = url; }
AK::URL url() const { return m_url; }
LibWeb: Add support for the <base> element changing the base URL Used by Google seemingly almost all around account sign in and management. The modern sign in page has this near the beginning: ```html <base href="https://accounts.google.com"> ``` All of the XHRs performed by sign in are relative URLs to this base URL. Previously we ignored this and did it relative to the current URL, causing the XHRs to 404 and sign in to fall apart. I presume they do this because you can access the sign in page from multiple endpoints, such as `/ServiceLogin` and `/o/oauth2/auth/identifier`
2022-06-19 18:02:48 +03:00
AK::URL fallback_base_url() const;
AK::URL base_url() 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 14:42:07 +03:00
JS::GCPtr<HTML::HTMLBaseElement> first_base_element_with_href_in_tree_order() const;
LibHTML: Add load(URL) and reload() functions to HtmlView You can now pass a file:/// URL to HtmlView and it will take care of the loading logic for you. Each Document remembers the URL it was loaded from, which allows us to also have reload(). This patch also adds a very simple function for resolving relative URL's into absolute ones.
2019-10-05 11:16:27 +03:00
LibWeb: Bring Document closer to spec
2022-04-12 19:19:35 +03:00
String url_string() const { return m_url.to_string(); }
String document_uri() const { return m_url.to_string(); }
LibWeb: Move Origin into the HTML namespace Origin is defined in the HTML Standard, and therefore belongs into the HTML directory and namespace in LibWeb. https://html.spec.whatwg.org/multipage/origin.html#origin
2022-07-12 22:37:43 +03:00
HTML::Origin origin() const;
void set_origin(HTML::Origin const& origin);
LibWeb: Add Origin concept (protocol, host, port tuple) Every Document now has an Origin, found via Document::origin(). It's based on the URL of the document. This will be used to implement things like the same-origin policy.
2020-04-07 23:56:13 +03:00
LibWeb: Bring browsing context creation closer to spec This patch implements the "create a new browsing context" function from the HTML spec and replaces our existing logic with it. The big difference is that browsing contexts now initially navigate to "about:blank" instead of starting out in a strange "empty" state. This makes it possible for websites to create a new iframe and start scripting inside it right away, without having to load an URL into it.
2022-08-05 11:55:47 +03:00
HTML::CrossOriginOpenerPolicy const& cross_origin_opener_policy() const { return m_cross_origin_opener_policy; }
void set_cross_origin_opener_policy(HTML::CrossOriginOpenerPolicy policy) { m_cross_origin_opener_policy = move(policy); }
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
AK::URL parse_url(String const&) const;
LibHTML: Add load(URL) and reload() functions to HtmlView You can now pass a file:/// URL to HtmlView and it will take care of the loading logic for you. Each Document remembers the URL it was loaded from, which allows us to also have reload(). This patch also adds a very simple function for resolving relative URL's into absolute ones.
2019-10-05 11:16:27 +03:00
LibWeb: Rename CSS::StyleResolver => StyleComputer Resolved style is a spec concept that refers to the weird mix of computed style and used style reflected by getComputedStyle(). The purpose of this class is to produce the *computed* style for a given element, so let's call it StyleComputer.
2021-09-24 14:49:57 +03:00
CSS::StyleComputer& style_computer() { return *m_style_computer; }
const CSS::StyleComputer& style_computer() const { return *m_style_computer; }
LibHTML: Start fleshing out a basic layout tree.
2019-06-15 23:49:44 +03: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 14:42:07 +03:00
CSS::StyleSheetList& style_sheets();
CSS::StyleSheetList const& style_sheets() const;
LibHTML: Start fleshing out a basic layout tree.
2019-06-15 23:49:44 +03: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 14:42:07 +03:00
CSS::StyleSheetList* style_sheets_for_bindings() { return &style_sheets(); }
LibWeb: Start exposing CSS style sheets to JavaScript :^) This patch adds bindings for the following objects: - StyleSheet - StyleSheetList - CSSStyleSheet You can get to a document's style sheets via Document.styleSheets and iterate through them using StyleSheetList's item() and length(). That's it in terms of functionality at this point, but still neat. :^)
2021-03-08 13:22:18 +03:00
LibWeb: Make Element::tag_name() return a const FlyString& The more generic virtual variant is renamed to node_name() and now only Element has tag_name(). This removes a huge amount of String ctor/dtor churn in selector matching.
2020-06-16 20:09:14 +03:00
virtual FlyString node_name() const override { return "#document"; }
LibHTML: Add virtual Node::tag_name() This is analogous to the DOM's Node.tagName and makes it easy to ask "hey, what kinda thing is this Node?"
2019-09-28 23:59:16 +03:00
LibHTML: Implement basic :hover pseudo-class support This is currently very aggressive. Whenever the Document's hovered node changes, we invalidate all style and do a full relayout. It does look cool though. So cool that I'm adding it to the default stylesheet. :^)
2019-10-14 18:54:17 +03:00
void set_hovered_node(Node*);
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 14:42:07 +03:00
Node* hovered_node() { return m_hovered_node.ptr(); }
Node const* hovered_node() const { return m_hovered_node.ptr(); }
LibHTML: Have Document track its hovered Node This gets set from HtmlView::mousemove_event() at the moment.
2019-09-29 12:50:35 +03:00
LibHTML: Paint a magenta rectangle around the currently inspected node Document now tracks one "inspected" node, set by set_inspected_node() which is called by Browser's DOM inspector view on_selection callback.
2019-11-09 13:58:50 +03:00
void set_inspected_node(Node*);
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 14:42:07 +03:00
Node* inspected_node() { return m_inspected_node.ptr(); }
Node const* inspected_node() const { return m_inspected_node.ptr(); }
LibHTML: Paint a magenta rectangle around the currently inspected node Document now tracks one "inspected" node, set by set_inspected_node() which is called by Browser's DOM inspector view on_selection callback.
2019-11-09 13:58:50 +03:00
LibWeb: Support assigning to document.body when it is null
2021-02-22 16:00:47 +03:00
Element* document_element();
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Element const* document_element() const;
LibWeb: Support assigning to document.body when it is null
2021-02-22 16:00:47 +03:00
LibWeb: Add non-const variants of Document::{html_element,body,head}()
2021-05-07 02:53:22 +03:00
HTML::HTMLHtmlElement* html_element();
HTML::HTMLHeadElement* head();
HTML::HTMLElement* body();
const HTML::HTMLHtmlElement* html_element() const
{
return const_cast<Document*>(this)->html_element();
}
const HTML::HTMLHeadElement* head() const
{
return const_cast<Document*>(this)->head();
}
const HTML::HTMLElement* body() const
{
return const_cast<Document*>(this)->body();
}
LibWeb: Make WrapperGenerator generate nullable wrapper types Previously it was not doing so, and some code relied on this not being the case. In particular, set_caption, set_t_head and set_t_foot in HTMLTableElement relied on this. This commit is not here to fix this, so I added an assertion to make it equivalent to a reference for now.
2021-07-05 07:45:20 +03:00
ExceptionOr<void> set_body(HTML::HTMLElement* new_body);
LibHTML: Add a way to get a Document's title You can now query Document::title() to get a String containing whatever is inside the document's <title> tag. In support of this, this patch adds the <html>, <head> and <title> elements.
2019-09-29 17:24:57 +03:00
String title() const;
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void set_title(String const&);
LibHTML: Add a way to get a Document's title You can now query Document::title() to get a String containing whatever is inside the document's <title> tag. In support of this, this patch adds the <html>, <head> and <title> elements.
2019-09-29 17:24:57 +03:00
LibWeb: Move BrowsingContext into HTML/ Browsing contexts are defined by the HTML specification, so let's move them into the HTML directory. :^)
2021-11-18 17:01:28 +03:00
void attach_to_browsing_context(Badge<HTML::BrowsingContext>, HTML::BrowsingContext&);
void detach_from_browsing_context(Badge<HTML::BrowsingContext>, HTML::BrowsingContext&);
LibHTML: Add a Frame class and use it for document layout width Each HtmlView now has a main_frame(), which represents the main frame of the web page. Frame inherits from TreeNode<Frame>, which will allow us to someday implement a Frame tree (to support the <frame> element.)
2019-10-04 16:50:04 +03:00
LibWeb: Move BrowsingContext into HTML/ Browsing contexts are defined by the HTML specification, so let's move them into the HTML directory. :^)
2021-11-18 17:01:28 +03:00
HTML::BrowsingContext* browsing_context() { return m_browsing_context.ptr(); }
HTML::BrowsingContext const* browsing_context() const { return m_browsing_context.ptr(); }
LibHTML: Add a Frame class and use it for document layout width Each HtmlView now has a main_frame(), which represents the main frame of the web page. Frame inherits from TreeNode<Frame>, which will allow us to someday implement a Frame tree (to support the <frame> element.)
2019-10-04 16:50:04 +03:00
LibWeb: Make Frame point weakly to Page This patch makes Page weakable and allows page-less frames to exist. Page is single-owner, and Frame is multiple-owner, so it's not sound for Frame to assume its containing Page will stick around for its own entire lifetime. Fixes #3976.
2020-11-12 20:23:05 +03:00
Page* page();
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Page const* page() const;
LibWeb: Make Frame point weakly to Page This patch makes Page weakable and allows page-less frames to exist. Page is single-owner, and Frame is multiple-owner, so it's not sound for Frame to assume its containing Page will stick around for its own entire lifetime. Fixes #3976.
2020-11-12 20:23:05 +03:00
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Color background_color(Gfx::Palette const&) const;
LibWeb: Store background layers in ComputedValues Instead of storing these as individual `background-foo` properties, we combine them together into layers, since that is how they will be painted. It also makes it more convenient to pass them around.
2021-11-12 15:11:01 +03:00
Vector<CSS::BackgroundLayerData> const* background_layers() const;
LibHTML: Add support for <body bgcolor="#rrggbb" text="#rrggbb"> This patch implements basic support for presentational hints, which are old-school HTML attributes that affect style. You add support for a presentational hint attribute by overriding Element::apply_presentational_hints(StyleProperties&) and setting all of the corresponding CSS properties as appropriate. To make the background color fill the entire document, not just the bounds of the <body> element's LayoutNode, we special-case it in the HtmlView::paint_event() code for now. I'm not entirely sure what the nicest solution would be, but I'm sure we'll discover it eventually.
2019-10-04 22:05:52 +03:00
LibDraw+LibHTML: Make link colors themeable Add "Link", "ActiveLink" and "VisitedLink" colors to the system theme definition, and implement support for them in LibHTML. Note that <body link="foo" alink="bar" vlink="baz"> takes precedence over the system colors. Author style also takes precedence, since we only fetch the system color in case the CSS color is -libhtml-link.
2020-01-13 22:33:15 +03:00
Color link_color() const;
LibHTML: Parse link, alink and vlink in <body> and pass to Document This patch adds HTMLBodyElement::parse_attribute() where we extract the link colors and stash them away on Document.
2019-10-06 11:11:54 +03:00
void set_link_color(Color);
LibDraw+LibHTML: Make link colors themeable Add "Link", "ActiveLink" and "VisitedLink" colors to the system theme definition, and implement support for them in LibHTML. Note that <body link="foo" alink="bar" vlink="baz"> takes precedence over the system colors. Author style also takes precedence, since we only fetch the system color in case the CSS color is -libhtml-link.
2020-01-13 22:33:15 +03:00
Color active_link_color() const;
LibHTML: Parse link, alink and vlink in <body> and pass to Document This patch adds HTMLBodyElement::parse_attribute() where we extract the link colors and stash them away on Document.
2019-10-06 11:11:54 +03:00
void set_active_link_color(Color);
LibDraw+LibHTML: Make link colors themeable Add "Link", "ActiveLink" and "VisitedLink" colors to the system theme definition, and implement support for them in LibHTML. Note that <body link="foo" alink="bar" vlink="baz"> takes precedence over the system colors. Author style also takes precedence, since we only fetch the system color in case the CSS color is -libhtml-link.
2020-01-13 22:33:15 +03:00
Color visited_link_color() const;
LibHTML: Parse link, alink and vlink in <body> and pass to Document This patch adds HTMLBodyElement::parse_attribute() where we extract the link colors and stash them away on Document.
2019-10-06 11:11:54 +03:00
void set_visited_link_color(Color);
LibHTML: Add Document::force_layout() ..for when you really need a layout to happen right now. Also, automatically repaint the layout root after layout.
2019-10-28 22:51:45 +03:00
void force_layout();
LibHTML: Move layout root from HtmlView to Document The layout root is now kept alive via Document::m_layout_root. This will allow us to do more layout-related things inside the inner layer of LibHTML without reaching out to the HtmlView. I'd like to keep HtmlView at a slightly higher level, to prevent it from getting too complex. This patch also fixes accidental disconnection of the layout tree from the DOM after doing a layout tree rebuild. ~LayoutNode() now only unsets the DOM node's layout_node() if it's itself.
2019-10-13 13:34:25 +03:00
LibHTML: Rename Document's invalidate_{style,layout}() to update_foo()
2019-10-14 18:56:19 +03:00
void update_style();
void update_layout();
LibHTML: Add function for invalidating the document layout This allows any external actor to signal that the document layout may be stale. This can be used when loading resources, changing the size or placement of an element, adding/removing nodes, or really any time.
2019-10-06 14:58:18 +03:00
LibWeb: Make CSS layout lazier Instead of doing layout synchronously whenever something changes, we now use a basic event loop timer to defer and coalesce relayouts. If you did something that requires a relayout of the page, make sure to call Document::set_needs_layout() and it will get coalesced with all the other layout updates. There's lots of room for improvement here, but this already makes many web pages significantly snappier. :^) Also, note that this exposes a number of layout bugs where we have been relying on multiple relayouts to calculate the correct dimensions for things. Now that we only do a single layout in many cases, these kind of problems are much more noticeable. That should also make them easier to figure out and fix. :^)
2021-10-05 23:30:53 +03:00
void set_needs_layout();
LibWeb: Always relayout document on element style change Let's get this right before trying to make it fast. This patch removes the code that tried to do less work when an element's style changes, and instead simply invalidates the entire document. Note that invalidations are still coalesced, and will not be synchronized until update_style() and/or update_layout() is used.
2022-03-09 19:57:45 +03:00
void invalidate_layout();
LibWeb: Only invalidate stacking context tree for opacity/z-index change I came across some websites that change an elements CSS "opacity" in their :hover selectors. That caused us to relayout on hover, which we'd like to avoid. With this patch, we now check if a property only affects the stacking context tree, and if nothing layout-affecting has changed, we only invalidate the stacking context tree, causing it to be rebuilt on next paint or hit test. This makes :hover { opacity: ... } rules much faster. :^)
2022-03-21 12:58:51 +03:00
void invalidate_stacking_context_tree();
LibWeb: Always relayout document on element style change Let's get this right before trying to make it fast. This patch removes the code that tried to do less work when an element's style changes, and instead simply invalidates the entire document. Note that invalidations are still coalesced, and will not be synchronized until update_style() and/or update_layout() is used.
2022-03-09 19:57:45 +03:00
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
virtual bool is_child_allowed(Node const&) const override;
LibHTML: Add Comment and CharacterData nodes and improve HTML parsing This patch adds the CharacterData subclass of Node, which is now the parent class of Text and a new Comment class. A Comment node is one of these in HTML: <!--hello friends--> Since these occur somewhat frequently on the web, we need to be able to parse them. This patch also adds a child rejection mechanism to the DOM tree. Nodes can now override is_child_allowed(Node) and return false if they don't want a particular Node to become a child of theirs. This is used to prevent Document from taking on unwanted children.
2019-10-13 00:26:47 +03:00
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Layout::InitialContainingBlock const* layout_node() const;
LibWeb: Rename InitialContainingBlockBox => InitialContainingBlock The "Box" suffix added nothing here.
2021-09-08 12:27:46 +03:00
Layout::InitialContainingBlock* layout_node();
LibHTML: Move layout root from HtmlView to Document The layout root is now kept alive via Document::m_layout_root. This will allow us to do more layout-related things inside the inner layer of LibHTML without reaching out to the HtmlView. I'd like to keep HtmlView at a slightly higher level, to prevent it from getting too complex. This patch also fixes accidental disconnection of the layout tree from the DOM after doing a layout tree rebuild. ~LayoutNode() now only unsets the DOM node's layout_node() if it's itself.
2019-10-13 13:34:25 +03:00
LibHTML: Batch style updates and make them start from the root Use a zero-timer to schedule a style update after invalidating style on any node. Nodes now have a needs_style_update flag which helps us batch and coalesce the work. We also start style updates at the root and work our way through the document, updating any node that has the needs_style_update flag set. This is slower than what we were doing before, but far more correct. There is a ton of room for improvement here. :^)
2019-10-19 19:57:02 +03:00
void schedule_style_update();
LibWeb: Make CSS layout lazier Instead of doing layout synchronously whenever something changes, we now use a basic event loop timer to defer and coalesce relayouts. If you did something that requires a relayout of the page, make sure to call Document::set_needs_layout() and it will get coalesced with all the other layout updates. There's lots of room for improvement here, but this already makes many web pages significantly snappier. :^) Also, note that this exposes a number of layout bugs where we have been relying on multiple relayouts to calculate the correct dimensions for things. Now that we only do a single layout in many cases, these kind of problems are much more noticeable. That should also make them easier to figure out and fix. :^)
2021-10-05 23:30:53 +03:00
void schedule_layout_update();
LibHTML: Batch style updates and make them start from the root Use a zero-timer to schedule a style update after invalidating style on any node. Nodes now have a needs_style_update flag which helps us batch and coalesce the work. We also start style updates at the root and work our way through the document, updating any node that has the needs_style_update flag set. This is slower than what we were doing before, but far more correct. There is a ton of room for improvement here. :^)
2019-10-19 19:57:02 +03:00
LibWeb: Make HTMLCollection and subclasses GC-allocated
2022-09-01 21:50:16 +03:00
JS::NonnullGCPtr<HTMLCollection> get_elements_by_name(String const&);
JS::NonnullGCPtr<HTMLCollection> get_elements_by_class_name(FlyString const&);
JS::NonnullGCPtr<HTMLCollection> applets();
JS::NonnullGCPtr<HTMLCollection> anchors();
JS::NonnullGCPtr<HTMLCollection> images();
JS::NonnullGCPtr<HTMLCollection> embeds();
JS::NonnullGCPtr<HTMLCollection> plugins();
JS::NonnullGCPtr<HTMLCollection> links();
JS::NonnullGCPtr<HTMLCollection> forms();
JS::NonnullGCPtr<HTMLCollection> scripts();
LibWeb: Implement document.applets This is a legacy interface that returns an always-empty HTMLCollection.
2021-04-22 23:11:42 +03:00
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
String const& source() const { return m_source; }
void set_source(String const& source) { m_source = source; }
LibHTML: Store the HTML parser input along with the created Document This will allow us to "view source" later on, long after parsing has finished and turned it into a DOM.
2019-11-25 02:27:41 +03:00
LibWeb: Introduce the Environment Settings Object The environment settings object is effectively the context a piece of script is running under, for example, it contains the origin, responsible document, realm, global object and event loop for the current context. This effectively replaces ScriptExecutionContext, but it cannot be removed in this commit as EventTarget still depends on it. https://html.spec.whatwg.org/multipage/webappapis.html#environment-settings-object
2021-10-14 18:12:53 +03:00
HTML::EnvironmentSettingsObject& relevant_settings_object();
LibWeb: Parse <script> elements and run any JavaScript found inside This patch begins integrating LibJS into LibWeb. Document holds the JS::Interpreter for now, and it is created on demand when you first call Document::interpreter(). We also add a simple "alert()" function to the global object.
2020-03-14 14:41:51 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
JS::Value run_javascript(StringView source, StringView filename = "(unknown)"sv);
LibWeb: Handle javascript: URLs inside LibWeb :^) This patch makes it possible to execute JavaScript by clicking on an anchor element with href="javascript:your_script_here()".
2020-04-04 23:12:37 +03:00
LibWeb: Make Document.createElement() lowercase HTML local names Bring createElement() a little bit closer to spec-compliance.
2022-09-17 15:58:39 +03:00
ExceptionOr<JS::NonnullGCPtr<Element>> create_element(FlyString const& local_name);
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 14:42:07 +03:00
ExceptionOr<JS::NonnullGCPtr<Element>> create_element_ns(String const& namespace_, String const& qualified_name);
JS::NonnullGCPtr<DocumentFragment> create_document_fragment();
JS::NonnullGCPtr<Text> create_text_node(String const& data);
JS::NonnullGCPtr<Comment> create_comment(String const& data);
LibWeb: Make DOM::Event and all its subclasses GC-allocated
2022-08-08 23:29:40 +03:00
ExceptionOr<JS::NonnullGCPtr<Event>> create_event(String const& interface);
LibWeb: Make AbstractRange and subclasses GC-allocated
2022-08-09 02:06:47 +03:00
JS::NonnullGCPtr<Range> create_range();
LibWeb: Add Document create_element() and create_text_node() helpers
2020-05-10 21:43:54 +03:00
LibWeb: Move HTML classes into the Web::HTML namespace
2020-07-28 19:20:36 +03:00
void set_pending_parsing_blocking_script(Badge<HTML::HTMLScriptElement>, HTML::HTMLScriptElement*);
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 14:42:07 +03:00
HTML::HTMLScriptElement* pending_parsing_blocking_script() { return m_pending_parsing_blocking_script.ptr(); }
JS::NonnullGCPtr<HTML::HTMLScriptElement> take_pending_parsing_blocking_script(Badge<HTML::HTMLParser>);
LibWeb: A whole bunch of work towards spec-compliant <script> elements This is still very unfinished, but there's at least a skeleton of code.
2020-05-24 23:00:46 +03:00
LibWeb: Move HTML classes into the Web::HTML namespace
2020-07-28 19:20:36 +03:00
void add_script_to_execute_when_parsing_has_finished(Badge<HTML::HTMLScriptElement>, HTML::HTMLScriptElement&);
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 14:42:07 +03:00
Vector<JS::Handle<HTML::HTMLScriptElement>> take_scripts_to_execute_when_parsing_has_finished(Badge<HTML::HTMLParser>);
Vector<JS::Handle<HTML::HTMLScriptElement>>& scripts_to_execute_when_parsing_has_finished() { return m_scripts_to_execute_when_parsing_has_finished; }
LibWeb: Handle two kinds of deferred script executions This patch adds two script lists to Document: - Scripts to execute when parsing has finished - Scripts to execute as soon as possible Since we don't actually load scripts asynchronously yet (we just do a synchronous load when parsing the <script> element for simplicity), these are already loaded by the time we get to "The end" of parsing.
2020-05-30 13:26:15 +03:00
LibWeb: Move HTML classes into the Web::HTML namespace
2020-07-28 19:20:36 +03:00
void add_script_to_execute_as_soon_as_possible(Badge<HTML::HTMLScriptElement>, HTML::HTMLScriptElement&);
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 14:42:07 +03:00
Vector<JS::Handle<HTML::HTMLScriptElement>> take_scripts_to_execute_as_soon_as_possible(Badge<HTML::HTMLParser>);
Vector<JS::Handle<HTML::HTMLScriptElement>>& scripts_to_execute_as_soon_as_possible() { return m_scripts_to_execute_as_soon_as_possible; }
LibWeb: Handle two kinds of deferred script executions This patch adds two script lists to Document: - Scripts to execute when parsing has finished - Scripts to execute as soon as possible Since we don't actually load scripts asynchronously yet (we just do a synchronous load when parsing the <script> element for simplicity), these are already loaded by the time we get to "The end" of parsing.
2020-05-30 13:26:15 +03:00
LibWeb: Add "scripts to execute in order as soon as possible" Previously, we had accidentally conflated this set with the similar-but-distinct "scripts to execute as soon as possible".
2022-09-17 18:36:47 +03:00
void add_script_to_execute_in_order_as_soon_as_possible(Badge<HTML::HTMLScriptElement>, HTML::HTMLScriptElement&);
Vector<JS::Handle<HTML::HTMLScriptElement>> take_scripts_to_execute_in_order_as_soon_as_possible(Badge<HTML::HTMLParser>);
Vector<JS::Handle<HTML::HTMLScriptElement>>& scripts_to_execute_in_order_as_soon_as_possible() { return m_scripts_to_execute_in_order_as_soon_as_possible; }
LibWeb: Implement quirks mode detection This allows us to determine which mode to render the page in. Exposes "doctype" and "compatMode" on Document. Exposes "name", "publicId" and "systemId" on DocumentType.
2020-07-18 23:17:17 +03:00
QuirksMode mode() const { return m_quirks_mode; }
bool in_quirks_mode() const { return m_quirks_mode == QuirksMode::Yes; }
void set_quirks_mode(QuirksMode mode) { m_quirks_mode = mode; }
LibWeb: Add a "quirks mode" flag to Document This doesn't do anything yet, but it will sooner or later. :^)
2020-05-28 01:20:36 +03:00
LibWeb: Add the type field to DOM::Document This patch adds the document type concept to documents and sets it in various places.
2022-07-03 22:44:00 +03:00
Type document_type() const { return m_type; }
void set_document_type(Type type) { m_type = type; }
// https://dom.spec.whatwg.org/#xml-document
bool is_xml_document() const { return m_type == Type::XML; }
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 14:42:07 +03:00
ExceptionOr<JS::NonnullGCPtr<Node>> import_node(JS::NonnullGCPtr<Node> node, bool deep);
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-26 00:42:08 +03:00
void adopt_node(Node&);
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 14:42:07 +03:00
ExceptionOr<JS::NonnullGCPtr<Node>> adopt_node_binding(JS::NonnullGCPtr<Node>);
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-26 00:42:08 +03:00
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
DocumentType const* doctype() const;
String const& compat_mode() const;
LibWeb: Implement quirks mode detection This allows us to determine which mode to render the page in. Exposes "doctype" and "compatMode" on Document. Exposes "name", "publicId" and "systemId" on DocumentType.
2020-07-18 23:17:17 +03:00
LibWeb: Only allow editing of elements with contenteditable="true" We now respect the contenteditable HTML attribute and only let you edit content inside explicitly editable elements.
2020-08-02 17:05:59 +03:00
void set_editable(bool editable) { m_editable = editable; }
virtual bool is_editable() const 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 14:42:07 +03:00
Element* focused_element() { return m_focused_element.ptr(); }
Element const* focused_element() const { return m_focused_element.ptr(); }
LibWeb: Allow focusing individual (focusable) elements with Tab key You can now cycle through focusable elements (currently only hyperlinks are focusable) with the Tab key. The focus outline is rendered in a new FocusOutline paint phase.
2020-08-14 20:40:37 +03:00
void set_focused_element(Element*);
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 14:42:07 +03:00
Element const* active_element() const { return m_active_element.ptr(); }
LibWeb: Support :active pseudo-class for hyperlinks, :focus possibly Adds support for the :active pseudo-class for hyperlinks (<a> tags only). Also, since it was very similar to :focus and an element having a focused state was already implemented, I went ahead and implemented that pseudo-class too, although I cannot come up with a working example to validate it.
2021-06-19 01:42:34 +03:00
void set_active_element(Element*);
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-20 00:30:33 +03:00
bool created_for_appropriate_template_contents() const { return m_created_for_appropriate_template_contents; }
void set_created_for_appropriate_template_contents(bool value) { m_created_for_appropriate_template_contents = value; }
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 14:42:07 +03:00
Document* associated_inert_template_document() { return m_associated_inert_template_document.ptr(); }
Document const* associated_inert_template_document() const { return m_associated_inert_template_document.ptr(); }
void set_associated_inert_template_document(Document& document) { m_associated_inert_template_document = &document; }
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-20 00:30:33 +03:00
LibWeb: Store HTML document ready state as an enum
2021-09-26 13:08:50 +03:00
String ready_state() const;
LibWeb: Implement "update the current document readiness" from spec The only difference from what we were already doing is that setting the same ready state twice no longer fires a "readystatechange" event. I don't think that could happen in practice though.
2021-09-26 13:22:16 +03:00
void update_readiness(HTML::DocumentReadyState);
LibWeb: Implement document ready state
2020-08-31 15:56:16 +03: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 14:42:07 +03:00
HTML::Window& window() const { return const_cast<HTML::Window&>(*m_window); }
LibWeb: Dispatch "load" on document and window These happen right after "DOMContentLoaded" for now, which is incorrect since they should really wait until subresources have loaded. However, this makes a bunch of things work already so let's do it.
2020-10-18 14:45:28 +03:00
LibWeb: Bring browsing context creation closer to spec This patch implements the "create a new browsing context" function from the HTML spec and replaces our existing logic with it. The big difference is that browsing contexts now initially navigate to "about:blank" instead of starting out in a strange "empty" state. This makes it possible for websites to create a new iframe and start scripting inside it right away, without having to load an URL into it.
2022-08-05 11:55:47 +03:00
void set_window(Badge<HTML::BrowsingContext>, HTML::Window&);
LibWeb: Add basic support for dynamic markup insertion This implements basic support for dynamic markup insertion, adding * Document::open() * Document::write(Vector<String> const&) * Document::writeln(Vector<String> const&) * Document::close() The HTMLParser is modified to make it possible to create a script-created parser which initially only contains a HTMLTokenizer without any data. Aditionally the HTMLParser::run method gains an overload which does not modify the Document and does not run HTMLParser::the_end() so that we can reenter the parser at a later time. Furthermore all FIXMEs that consern the insertion point are implemented wich is defined in the HTMLTokenizer. Additionally the following member-variables of the HTMLParser are now exposed by getter funcions: * m_tokenizer * m_aborted * m_script_nesting_level The HTMLTokenizer is modified so that it contains an insertion point which keeps track of where the next input from the Document::write functions will be inserted. The insertion point is implemented as the charakter offset into m_decoded_input and a boolean describing if the insertion point is defined. Functions to update, check and {re}store the insertion point are also added. The function HTMLTokenizer::insert_eof is added to tell a script-created parser that document::close was called and HTMLParser::the_end() should be called. Lastly an explicit default constructor is added to HTMLTokenizer to create a empty HTMLTokenizer into which data can be inserted.
2022-02-19 17:58:21 +03:00
ExceptionOr<void> write(Vector<String> const& strings);
ExceptionOr<void> writeln(Vector<String> const& strings);
ExceptionOr<Document*> open(String const& = "", String const& = "");
ExceptionOr<void> close();
LibWeb: Add stubs for document.write and document.writeln ACID3 test page throws exception about document.write. Let's at least get rid of it by defining these stubs. I added document.writeln too because it is similar.
2022-02-15 19:36:27 +03: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 14:42:07 +03:00
HTML::Window* default_view() { return m_window.ptr(); }
LibWeb: Expose the Window object as Document.defaultView This should really be a WindowProxy? but since we don't have anything representing that concept yet, let's just expose the Window object directly so document.defaultView.foo works. :^)
2021-02-21 23:24:11 +03:00
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
String const& content_type() const { return m_content_type; }
void set_content_type(String const& content_type) { m_content_type = content_type; }
LibWeb: Add contentType attribute to Document
2020-11-13 08:02:15 +03:00
LibWeb: Change Document's m_encoding to Optional<String> This modifies the Document class to use Optional<String> for the encoding. If the encoding is unknown, the Optional will not have a value. It also implements the has_encoding() and encoding_or_default() instance methods, the latter of which will return "UTF-8" as a fallback if no encoding is present. The usage of Optional<String> instead of the null string is part of an effort to explicitly indicate that a string could not have a value. This also modifies the former callers of encoding() to use encoding_or_default(). Furthermore, the encoding will now only be set if it is actually known, rather than just guessed by earlier code.
2021-05-12 11:32:41 +03:00
bool has_encoding() const { return m_encoding.has_value(); }
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Optional<String> const& encoding() const { return m_encoding; }
LibWeb: Change Document's m_encoding to Optional<String> This modifies the Document class to use Optional<String> for the encoding. If the encoding is unknown, the Optional will not have a value. It also implements the has_encoding() and encoding_or_default() instance methods, the latter of which will return "UTF-8" as a fallback if no encoding is present. The usage of Optional<String> instead of the null string is part of an effort to explicitly indicate that a string could not have a value. This also modifies the former callers of encoding() to use encoding_or_default(). Furthermore, the encoding will now only be set if it is actually known, rather than just guessed by earlier code.
2021-05-12 11:32:41 +03:00
String encoding_or_default() const { return m_encoding.value_or("UTF-8"); }
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void set_encoding(Optional<String> const& encoding) { m_encoding = encoding; }
LibWeb: Use standardized encoding names, add encoding attribute to document
2020-11-13 14:16:28 +03:00
// NOTE: These are intended for the JS bindings
LibWeb: Change Document's m_encoding to Optional<String> This modifies the Document class to use Optional<String> for the encoding. If the encoding is unknown, the Optional will not have a value. It also implements the has_encoding() and encoding_or_default() instance methods, the latter of which will return "UTF-8" as a fallback if no encoding is present. The usage of Optional<String> instead of the null string is part of an effort to explicitly indicate that a string could not have a value. This also modifies the former callers of encoding() to use encoding_or_default(). Furthermore, the encoding will now only be set if it is actually known, rather than just guessed by earlier code.
2021-05-12 11:32:41 +03:00
String character_set() const { return encoding_or_default(); }
String charset() const { return encoding_or_default(); }
String input_encoding() const { return encoding_or_default(); }
LibWeb: Use standardized encoding names, add encoding attribute to document
2020-11-13 14:16:28 +03:00
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 21:32:39 +03:00
bool ready_for_post_load_tasks() const { return m_ready_for_post_load_tasks; }
void set_ready_for_post_load_tasks(bool ready) { m_ready_for_post_load_tasks = ready; }
void completely_finish_loading();
LibWeb: Make DOMImplementation GC-allocated
2022-08-08 16:52:48 +03:00
DOMImplementation* implementation();
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 21:32:39 +03: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 14:42:07 +03:00
JS::GCPtr<HTML::HTMLScriptElement> current_script() const { return m_current_script.ptr(); }
void set_current_script(Badge<HTML::HTMLScriptElement>, JS::GCPtr<HTML::HTMLScriptElement> script) { m_current_script = move(script); }
LibWeb: Flesh out prepare_script and execute_script This fills in a bunch of the FIXMEs that was in prepare_script. execute_script is almost finished, it's just missing the module side. As an aside, let's not assert when inserting a script element with innerHTML.
2021-01-28 23:31:20 +03:00
u32 ignore_destructive_writes_counter() const { return m_ignore_destructive_writes_counter; }
void increment_ignore_destructive_writes_counter() { m_ignore_destructive_writes_counter++; }
void decrement_ignore_destructive_writes_counter() { m_ignore_destructive_writes_counter--; }
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
virtual EventTarget* get_parent(Event const&) override;
LibWeb: Add initial implementation of document.implementation
2020-11-13 09:08:06 +03:00
LibWeb: Add JSON serialization method to DOM::Node This method builds a JSON object representing the full state of the DOM tree. The JSON that is built will be used for building the DOM Inspector widget for the OutOfProcessWebView.
2021-06-07 18:32:24 +03:00
String dump_dom_tree_as_json() const;
LibWeb: Implement "Document has a style sheet that is blocking scripts" This will be used by the HTML parser to determine whether it's okay to start running a script. Note that we don't actually count the script-blocking style sheets yet. This patch only adds a the checking mechanism for the parser.
2021-09-09 03:11:11 +03:00
bool has_a_style_sheet_that_is_blocking_scripts() const;
LibWeb: Add Document::is_fully_active This is used in a bunch of places in the HTML spec. The current use case for this is History.
2021-09-12 01:28:41 +03:00
bool is_fully_active() const;
LibWeb: Add DOM::Document::is_active() This is a spec concept that means a document is the associated document of its browsing context's active window.
2021-09-19 13:28:22 +03:00
bool is_active() const;
LibWeb: Add Document::is_fully_active This is used in a bunch of places in the HTML spec. The current use case for this is History.
2021-09-12 01:28:41 +03:00
LibWeb: Make History GC-allocated
2022-09-02 14:50:24 +03:00
JS::NonnullGCPtr<HTML::History> history();
LibWeb: Add the History object and stub pushState and replaceState The spec allows us to optionally return from these for any reason. Our reason is that we don't have all the infrastructure in place yet to implement them.
2021-09-12 01:43:34 +03:00
LibWeb: Expose the location object via Document.location Both Window.location and Document.location use the same instance of the Location object. Some sites use it via Window, some via Document.
2021-09-12 16:59:49 +03:00
Bindings::LocationObject* location();
LibWeb: Allow HTML parser to delay delivery of the document "load" event We will now spin in "the end" until there are no more "things delaying the load event". Of course, nothing actually uses this yet, and there are a lot of things that need to.
2021-09-26 02:03:42 +03:00
size_t number_of_things_delaying_the_load_event() { return m_number_of_things_delaying_the_load_event; }
Browser: Show currently loading host and remaining resource count
2022-02-21 01:03:39 +03:00
void increment_number_of_things_delaying_the_load_event(Badge<DocumentLoadEventDelayer>);
void decrement_number_of_things_delaying_the_load_event(Badge<DocumentLoadEventDelayer>);
LibWeb: Allow HTML parser to delay delivery of the document "load" event We will now spin in "the end" until there are no more "things delaying the load event". Of course, nothing actually uses this yet, and there are a lot of things that need to.
2021-09-26 02:03:42 +03:00
LibWeb: Add a "page showing" flag to documents This will be used to determine whether "pageshow" and "pagehide" events are appropriate. We won't actually make use of it until we implement more of history traversal and document unloading.
2021-09-26 13:26:39 +03:00
bool page_showing() const { return m_page_showing; }
void set_page_showing(bool value) { m_page_showing = value; }
LibWeb: Support Document.hidden and Document.visibilityState These just act as if the document is always visible for now.
2021-09-27 17:02:13 +03:00
bool hidden() const;
String visibility_state() const;
LibWeb: Let HTML::EventLoop drive the firing of `resize` events
2021-10-03 17:42:03 +03:00
void run_the_resize_steps();
LibWeb: Implement basic "scroll" events at the document level
2022-09-17 18:40:26 +03:00
void run_the_scroll_steps();
LibWeb: Let HTML::EventLoop drive the firing of `resize` events
2021-10-03 17:42:03 +03:00
LibWeb: Fire MediaQueryListEvents when an MQL's match-state changes The HTML event loop does a check for MQL match-state changes and dispatches the events. This requires us to keep a list of MQLs on the Document.
2021-10-04 19:41:35 +03:00
void evaluate_media_queries_and_report_changes();
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 14:42:07 +03:00
void add_media_query_list(JS::NonnullGCPtr<CSS::MediaQueryList>);
LibWeb: Fire MediaQueryListEvents when an MQL's match-state changes The HTML event loop does a check for MQL match-state changes and dispatches the events. This requires us to keep a list of MQLs on the Document.
2021-10-04 19:41:35 +03:00
LibWeb: Add Document.hasFocus() stub This always returns true for now. A proper implementation needs to check if the document is in the focused widget within an active window.
2022-02-03 22:06:54 +03:00
bool has_focus() const;
LibWeb: Make document.write() work while document is parsing This necessitated making HTMLParser ref-counted, and having it register itself with Document when created. That makes it possible for scripts to add new input at the current parser insertion point. There is now a reference cycle between Document and HTMLParser. This cycle is explicitly broken by calling Document::detach_parser() at the end of HTMLParser::run(). This is a huge progression on ACID3, from 31% to 49%! :^)
2022-02-21 23:54:21 +03:00
void set_parser(Badge<HTML::HTMLParser>, HTML::HTMLParser&);
void detach_parser(Badge<HTML::HTMLParser>);
LibWeb: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 12:00:49 +03:00
static bool is_valid_name(String const&);
LibWeb: Validate the qualified name in createDocumentType() 1% progression on ACID3. :^)
2022-02-26 19:26:37 +03:00
struct PrefixAndTagName {
FlyString prefix;
FlyString tag_name;
};
LibWeb: Make DOMException GC-allocated
2022-09-04 17:56:15 +03:00
static ExceptionOr<PrefixAndTagName> validate_qualified_name(JS::Object& global_object, String const& qualified_name);
LibWeb: Validate the qualified name in createDocumentType() 1% progression on ACID3. :^)
2022-02-26 19:26:37 +03:00
LibWeb: Make NodeIterator GC-allocated
2022-08-08 23:56:19 +03:00
JS::NonnullGCPtr<NodeIterator> create_node_iterator(Node& root, unsigned what_to_show, JS::GCPtr<NodeFilter>);
LibWeb: Make TreeWalker GC-allocated
2022-08-09 00:03:27 +03:00
JS::NonnullGCPtr<TreeWalker> create_tree_walker(Node& root, unsigned what_to_show, JS::GCPtr<NodeFilter>);
LibWeb: Add basic support for DOM's NodeIterator and NodeFilter This patch adds NodeIterator (created via Document.createNodeIterator()) which allows you to iterate through all the nodes in a subtree while filtering with a provided NodeFilter callback along the way. This first cut implements the full API, but does not yet handle nodes being removed from the document while referenced by the iterator. That will be done in a subsequent patch.
2022-03-09 16:34:32 +03:00
LibWeb: Implement "NodeIterator pre-removing steps" These steps run when a node is about to be removed from its parent, and adjust the position of any live NodeIterators so that they don't point at a now-removed node. Note that while this commit implements what's in the DOM specification, the specification doesn't fully match what other browsers do. Spec bug: https://github.com/whatwg/dom/issues/907
2022-03-09 18:38:44 +03:00
void register_node_iterator(Badge<NodeIterator>, NodeIterator&);
void unregister_node_iterator(Badge<NodeIterator>, NodeIterator&);
template<typename Callback>
void for_each_node_iterator(Callback 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 14:42:07 +03:00
for (auto& node_iterator : m_node_iterators)
LibWeb: Implement "NodeIterator pre-removing steps" These steps run when a node is about to be removed from its parent, and adjust the position of any live NodeIterators so that they don't point at a now-removed node. Note that while this commit implements what's in the DOM specification, the specification doesn't fully match what other browsers do. Spec bug: https://github.com/whatwg/dom/issues/907
2022-03-09 18:38:44 +03:00
callback(*node_iterator);
}
LibWeb: Make document-level style invalidation fast Add a flag to DOM::Document that means the whole document needs a style update. This saves us the trouble of traversing the entire DOM to mark all nodes as needing a style update.
2022-03-19 20:10:59 +03:00
bool needs_full_style_update() const { return m_needs_full_style_update; }
void set_needs_full_style_update(bool b) { m_needs_full_style_update = b; }
LibWeb: Show correct favicon when default favicon is loaded Block the replacement of the favicon by the default favicon loader when a favicon that is loaded through a link tag is already active. This way, the favicon in the link tags will be prioritized against the default favicons from `/favicon.ico` or the seranity default icon.
2022-04-03 20:56:15 +03:00
bool has_active_favicon() const { return m_active_favicon; }
LibWeb: Update displayed favicon when a favicon is loaded When a favicon has been loaded, trigger a favicon update on document level. Of all the link tags in the header, the last favicon that is load should be shown. When the favicon could not be loaded, load the next icon in reverse tree order.
2022-04-03 20:49:38 +03:00
void check_favicon_after_loading_link_resource();
LibWeb: Add the "is initial about:blank" flag to DOM::Document
2022-08-01 17:19:55 +03:00
// https://html.spec.whatwg.org/multipage/dom.html#is-initial-about:blank
bool is_initial_about_blank() const { return m_is_initial_about_blank; }
void set_is_initial_about_blank(bool b) { m_is_initial_about_blank = b; }
LibWeb: Implement document.domain getter The document.domain setter is currently stubbed as that is a doozy to implement, given how much restrictions there are in place to try and prevent use of it and potential multi-process implications. This was the only thing preventing us from being able to start displaying ads delivered via Google Syndication.
2022-09-14 17:50:47 +03:00
String domain() const;
void set_domain(String const& domain);
LibWeb: Implement basic "scroll" events at the document level
2022-09-17 18:40:26 +03:00
auto& pending_scroll_event_targets() { return m_pending_scroll_event_targets; }
auto& pending_scrollend_event_targets() { return m_pending_scrollend_event_targets; }
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 14:42:07 +03:00
protected:
virtual void visit_edges(Cell::Visitor&) override;
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 19:55:47 +03:00
private:
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 14:42:07 +03:00
Document(HTML::Window&, AK::URL const&);
LibWeb: Fix Document construction mishap in <template> element Ref-counted objects must not be stack allocated. Make DOM::Document's constructor private to avoid this issue. (I wish we could mark classes as heap-only..)
2020-10-23 09:31:26 +03:00
LibWeb: Basic implementation of global event handlers :^) Document and HTMLElement now inherit from HTML::GlobalEventHandlers which allows them to support "onfoo" event handler attributes. These are assignable both via IDL attributes and content attributes. Event listeners constructed this way get a special "attribute" flag on them so we know which one to replace if you reassign them. This also allows them to coexist with EventTarget.addEventListener(). This is all a bit sloppy, but it works decently for a first cut. The Window object should also inherit GlobalEventHandlers, but since we don't generate it from IDL, I haven't taken that step here. Also this would be a lot nicer if we supported IDL mixins.
2021-02-04 00:47:50 +03: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 21:20:09 +03:00
virtual EventTarget& global_event_handlers_to_event_target(FlyString const&) final { return *this; }
LibWeb: Basic implementation of global event handlers :^) Document and HTMLElement now inherit from HTML::GlobalEventHandlers which allows them to support "onfoo" event handler attributes. These are assignable both via IDL attributes and content attributes. Event listeners constructed this way get a special "attribute" flag on them so we know which one to replace if you reassign them. This also allows them to coexist with EventTarget.addEventListener(). This is all a bit sloppy, but it works decently for a first cut. The Window object should also inherit GlobalEventHandlers, but since we don't generate it from IDL, I haven't taken that step here. Also this would be a lot nicer if we supported IDL mixins.
2021-02-04 00:47:50 +03:00
LibWeb: Tear down layout trees properly Instead of just ripping out the root of the layout tree from its RefPtr in Document, actually go through the DOM and gather up all the layout nodes. Then destroy them all in one swoop. Also, make sure to do this when detaching Document from Frame, to enforce the invariant that layout only occurs in framed documents.
2020-10-20 18:43:13 +03:00
void tear_down_layout_tree();
LibWeb: Evaluate @media CSS rules when updating style In case we have new @media rules, we need to make sure we've evaluated them before actually recomputing styles for the document.
2022-03-20 18:18:43 +03:00
void evaluate_media_rules();
LibWeb: Append only one line feed character in Document.writeln There were a couple issues here: 1. The line feed should only be appended once, rather than one per string. 2. The new_strings list of strings was unused (we were creating the new list, then passing the old list to Document.write).
2022-02-22 00:34:54 +03:00
ExceptionOr<void> run_the_document_write_steps(String);
LibWeb: Stop putting the FormattingState nodes in a slow hash map Instead, put them in a Vector<OwnPtr<NodeState>>. Each layout node has a unique index into the vector. It's a simple serial ID assigned during layout tree construction. Every new layout restarts the sequence at 0 for the next ICB. This is a huge layout speed improvement on all content.
2022-07-11 18:12:58 +03:00
size_t m_next_layout_node_serial_id { 0 };
LibWeb: Rename CSS::StyleResolver => StyleComputer Resolved style is a spec concept that refers to the weird mix of computed style and used style reflected by getComputedStyle(). The purpose of this class is to produce the *computed* style for a given element, so let's call it StyleComputer.
2021-09-24 14:49:57 +03:00
OwnPtr<CSS::StyleComputer> m_style_computer;
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 14:42:07 +03:00
JS::GCPtr<CSS::StyleSheetList> m_style_sheets;
JS::GCPtr<Node> m_hovered_node;
JS::GCPtr<Node> m_inspected_node;
JS::GCPtr<Node> m_active_favicon;
LibWeb: Move BrowsingContext into HTML/ Browsing contexts are defined by the HTML specification, so let's move them into the HTML directory. :^)
2021-11-18 17:01:28 +03:00
WeakPtr<HTML::BrowsingContext> m_browsing_context;
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
AK::URL m_url;
LibHTML: Parse link, alink and vlink in <body> and pass to Document This patch adds HTMLBodyElement::parse_attribute() where we extract the link colors and stash them away on Document.
2019-10-06 11:11:54 +03: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 14:42:07 +03:00
JS::GCPtr<HTML::Window> m_window;
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 19:53:28 +03:00
LibWeb: Rename InitialContainingBlockBox => InitialContainingBlock The "Box" suffix added nothing here.
2021-09-08 12:27:46 +03:00
RefPtr<Layout::InitialContainingBlock> m_layout_root;
LibHTML: Move layout root from HtmlView to Document The layout root is now kept alive via Document::m_layout_root. This will allow us to do more layout-related things inside the inner layer of LibHTML without reaching out to the HtmlView. I'd like to keep HtmlView at a slightly higher level, to prevent it from getting too complex. This patch also fixes accidental disconnection of the layout tree from the DOM after doing a layout tree rebuild. ~LayoutNode() now only unsets the DOM node's layout_node() if it's itself.
2019-10-13 13:34:25 +03:00
LibDraw+LibHTML: Make link colors themeable Add "Link", "ActiveLink" and "VisitedLink" colors to the system theme definition, and implement support for them in LibHTML. Note that <body link="foo" alink="bar" vlink="baz"> takes precedence over the system colors. Author style also takes precedence, since we only fetch the system color in case the CSS color is -libhtml-link.
2020-01-13 22:33:15 +03:00
Optional<Color> m_link_color;
Optional<Color> m_active_link_color;
Optional<Color> m_visited_link_color;
LibHTML: Batch style updates and make them start from the root Use a zero-timer to schedule a style update after invalidating style on any node. Nodes now have a needs_style_update flag which helps us batch and coalesce the work. We also start style updates at the root and work our way through the document, updating any node that has the needs_style_update flag set. This is slower than what we were doing before, but far more correct. There is a ton of room for improvement here. :^)
2019-10-19 19:57:02 +03:00
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 21:30:31 +03:00
RefPtr<Platform::Timer> m_style_update_timer;
RefPtr<Platform::Timer> m_layout_update_timer;
LibHTML: Store the HTML parser input along with the created Document This will allow us to "view source" later on, long after parsing has finished and turned it into a DOM.
2019-11-25 02:27:41 +03:00
LibWeb: Make document.write() work while document is parsing This necessitated making HTMLParser ref-counted, and having it register itself with Document when created. That makes it possible for scripts to add new input at the current parser insertion point. There is now a reference cycle between Document and HTMLParser. This cycle is explicitly broken by calling Document::detach_parser() at the end of HTMLParser::run(). This is a huge progression on ACID3, from 31% to 49%! :^)
2022-02-21 23:54:21 +03:00
RefPtr<HTML::HTMLParser> m_parser;
LibWeb: Add basic support for dynamic markup insertion This implements basic support for dynamic markup insertion, adding * Document::open() * Document::write(Vector<String> const&) * Document::writeln(Vector<String> const&) * Document::close() The HTMLParser is modified to make it possible to create a script-created parser which initially only contains a HTMLTokenizer without any data. Aditionally the HTMLParser::run method gains an overload which does not modify the Document and does not run HTMLParser::the_end() so that we can reenter the parser at a later time. Furthermore all FIXMEs that consern the insertion point are implemented wich is defined in the HTMLTokenizer. Additionally the following member-variables of the HTMLParser are now exposed by getter funcions: * m_tokenizer * m_aborted * m_script_nesting_level The HTMLTokenizer is modified so that it contains an insertion point which keeps track of where the next input from the Document::write functions will be inserted. The insertion point is implemented as the charakter offset into m_decoded_input and a boolean describing if the insertion point is defined. Functions to update, check and {re}store the insertion point are also added. The function HTMLTokenizer::insert_eof is added to tell a script-created parser that document::close was called and HTMLParser::the_end() should be called. Lastly an explicit default constructor is added to HTMLTokenizer to create a empty HTMLTokenizer into which data can be inserted.
2022-02-19 17:58:21 +03:00
bool m_active_parser_was_aborted { false };
LibHTML: Store the HTML parser input along with the created Document This will allow us to "view source" later on, long after parsing has finished and turned it into a DOM.
2019-11-25 02:27:41 +03:00
String m_source;
LibWeb: Parse <script> elements and run any JavaScript found inside This patch begins integrating LibJS into LibWeb. Document holds the JS::Interpreter for now, and it is created on demand when you first call Document::interpreter(). We also add a simple "alert()" function to the global object.
2020-03-14 14:41:51 +03: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 14:42:07 +03:00
JS::GCPtr<HTML::HTMLScriptElement> m_pending_parsing_blocking_script;
LibWeb: Add "scripts to execute in order as soon as possible" Previously, we had accidentally conflated this set with the similar-but-distinct "scripts to execute as soon as possible".
2022-09-17 18:36:47 +03: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 14:42:07 +03:00
Vector<JS::Handle<HTML::HTMLScriptElement>> m_scripts_to_execute_when_parsing_has_finished;
LibWeb: Add "scripts to execute in order as soon as possible" Previously, we had accidentally conflated this set with the similar-but-distinct "scripts to execute as soon as possible".
2022-09-17 18:36:47 +03:00
// https://html.spec.whatwg.org/multipage/scripting.html#list-of-scripts-that-will-execute-in-order-as-soon-as-possible
Vector<JS::Handle<HTML::HTMLScriptElement>> m_scripts_to_execute_in_order_as_soon_as_possible;
// https://html.spec.whatwg.org/multipage/scripting.html#set-of-scripts-that-will-execute-as-soon-as-possible
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 14:42:07 +03:00
Vector<JS::Handle<HTML::HTMLScriptElement>> m_scripts_to_execute_as_soon_as_possible;
LibWeb: Add a "quirks mode" flag to Document This doesn't do anything yet, but it will sooner or later. :^)
2020-05-28 01:20:36 +03:00
LibWeb: Implement quirks mode detection This allows us to determine which mode to render the page in. Exposes "doctype" and "compatMode" on Document. Exposes "name", "publicId" and "systemId" on DocumentType.
2020-07-18 23:17:17 +03:00
QuirksMode m_quirks_mode { QuirksMode::No };
LibWeb: Add the type field to DOM::Document This patch adds the document type concept to documents and sets it in various places.
2022-07-03 22:44:00 +03:00
// https://dom.spec.whatwg.org/#concept-document-type
Type m_type { Type::HTML };
LibWeb: Only allow editing of elements with contenteditable="true" We now respect the contenteditable HTML attribute and only let you edit content inside explicitly editable elements.
2020-08-02 17:05:59 +03:00
bool m_editable { false };
LibWeb: Allow focusing individual (focusable) elements with Tab key You can now cycle through focusable elements (currently only hyperlinks are focusable) with the Tab key. The focus outline is rendered in a new FocusOutline paint phase.
2020-08-14 20:40:37 +03: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 14:42:07 +03:00
JS::GCPtr<Element> m_focused_element;
JS::GCPtr<Element> m_active_element;
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-20 00:30:33 +03:00
bool m_created_for_appropriate_template_contents { false };
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 14:42:07 +03:00
JS::GCPtr<Document> m_associated_inert_template_document;
LibWeb: Implement document ready state
2020-08-31 15:56:16 +03:00
LibWeb: Implement "update the current document readiness" from spec The only difference from what we were already doing is that setting the same ready state twice no longer fires a "readystatechange" event. I don't think that could happen in practice though.
2021-09-26 13:22:16 +03:00
HTML::DocumentReadyState m_readiness { HTML::DocumentReadyState::Loading };
LibWeb: Add default values of URL and content type in document As per this line in the specification: Unless stated otherwise, a document’s encoding is the utf-8 encoding, content type is "application/xml", URL is "about:blank", origin is an opaque origin, type is "xml", and its mode is "no-quirks". https://dom.spec.whatwg.org/#document
2020-11-13 11:34:40 +03:00
String m_content_type { "application/xml" };
LibWeb: Change Document's m_encoding to Optional<String> This modifies the Document class to use Optional<String> for the encoding. If the encoding is unknown, the Optional will not have a value. It also implements the has_encoding() and encoding_or_default() instance methods, the latter of which will return "UTF-8" as a fallback if no encoding is present. The usage of Optional<String> instead of the null string is part of an effort to explicitly indicate that a string could not have a value. This also modifies the former callers of encoding() to use encoding_or_default(). Furthermore, the encoding will now only be set if it is actually known, rather than just guessed by earlier code.
2021-05-12 11:32:41 +03:00
Optional<String> m_encoding;
LibWeb: Add initial implementation of document.implementation
2020-11-13 09:08:06 +03:00
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 21:32:39 +03:00
bool m_ready_for_post_load_tasks { false };
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 14:42:07 +03:00
JS::GCPtr<DOMImplementation> m_implementation;
JS::GCPtr<HTML::HTMLScriptElement> m_current_script;
LibWeb: Add hack to disable StyleInvalidator while parsing document Running a StyleInvalidator for every attribute set in a new document was making it impossible to load larger sites. :^)
2020-12-15 20:53:35 +03:00
bool m_should_invalidate_styles_on_attribute_changes { true };
LibWeb: Flesh out prepare_script and execute_script This fills in a bunch of the FIXMEs that was in prepare_script. execute_script is almost finished, it's just missing the module side. As an aside, let's not assert when inserting a script element with innerHTML.
2021-01-28 23:31:20 +03:00
u32 m_ignore_destructive_writes_counter { 0 };
LibWeb: Implement "Document has a style sheet that is blocking scripts" This will be used by the HTML parser to determine whether it's okay to start running a script. Note that we don't actually count the script-blocking style sheets yet. This patch only adds a the checking mechanism for the parser.
2021-09-09 03:11:11 +03:00
LibWeb: Add basic support for dynamic markup insertion This implements basic support for dynamic markup insertion, adding * Document::open() * Document::write(Vector<String> const&) * Document::writeln(Vector<String> const&) * Document::close() The HTMLParser is modified to make it possible to create a script-created parser which initially only contains a HTMLTokenizer without any data. Aditionally the HTMLParser::run method gains an overload which does not modify the Document and does not run HTMLParser::the_end() so that we can reenter the parser at a later time. Furthermore all FIXMEs that consern the insertion point are implemented wich is defined in the HTMLTokenizer. Additionally the following member-variables of the HTMLParser are now exposed by getter funcions: * m_tokenizer * m_aborted * m_script_nesting_level The HTMLTokenizer is modified so that it contains an insertion point which keeps track of where the next input from the Document::write functions will be inserted. The insertion point is implemented as the charakter offset into m_decoded_input and a boolean describing if the insertion point is defined. Functions to update, check and {re}store the insertion point are also added. The function HTMLTokenizer::insert_eof is added to tell a script-created parser that document::close was called and HTMLParser::the_end() should be called. Lastly an explicit default constructor is added to HTMLTokenizer to create a empty HTMLTokenizer into which data can be inserted.
2022-02-19 17:58:21 +03:00
// https://html.spec.whatwg.org/multipage/browsing-the-web.html#unload-counter
u32 m_unload_counter { 0 };
// https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#throw-on-dynamic-markup-insertion-counter
u32 m_throw_on_dynamic_markup_insertion_counter { 0 };
LibWeb: Implement "Document has a style sheet that is blocking scripts" This will be used by the HTML parser to determine whether it's okay to start running a script. Note that we don't actually count the script-blocking style sheets yet. This patch only adds a the checking mechanism for the parser.
2021-09-09 03:11:11 +03:00
// https://html.spec.whatwg.org/multipage/semantics.html#script-blocking-style-sheet-counter
u32 m_script_blocking_style_sheet_counter { 0 };
LibWeb: Add the History object and stub pushState and replaceState The spec allows us to optionally return from these for any reason. Our reason is that we don't have all the infrastructure in place yet to implement them.
2021-09-12 01:43:34 +03:00
LibWeb: Make History GC-allocated
2022-09-02 14:50:24 +03:00
JS::GCPtr<HTML::History> m_history;
LibWeb: Allow HTML parser to delay delivery of the document "load" event We will now spin in "the end" until there are no more "things delaying the load event". Of course, nothing actually uses this yet, and there are a lot of things that need to.
2021-09-26 02:03:42 +03:00
size_t m_number_of_things_delaying_the_load_event { 0 };
LibWeb: Add a "page showing" flag to documents This will be used to determine whether "pageshow" and "pagehide" events are appropriate. We won't actually make use of it until we implement more of history traversal and document unloading.
2021-09-26 13:26:39 +03:00
// https://html.spec.whatwg.org/#page-showing
bool m_page_showing { false };
LibWeb: Let HTML::EventLoop drive the firing of `resize` events
2021-10-03 17:42:03 +03:00
// Used by run_the_resize_steps().
Gfx::IntSize m_last_viewport_size;
LibWeb: Fire MediaQueryListEvents when an MQL's match-state changes The HTML event loop does a check for MQL match-state changes and dispatches the events. This requires us to keep a list of MQLs on the Document.
2021-10-04 19:41:35 +03:00
LibWeb: Implement basic "scroll" events at the document level
2022-09-17 18:40:26 +03:00
// https://w3c.github.io/csswg-drafts/cssom-view-1/#document-pending-scroll-event-targets
Vector<JS::NonnullGCPtr<EventTarget>> m_pending_scroll_event_targets;
// https://w3c.github.io/csswg-drafts/cssom-view-1/#document-pending-scrollend-event-targets
Vector<JS::NonnullGCPtr<EventTarget>> m_pending_scrollend_event_targets;
LibWeb: Fire MediaQueryListEvents when an MQL's match-state changes The HTML event loop does a check for MQL match-state changes and dispatches the events. This requires us to keep a list of MQLs on the Document.
2021-10-04 19:41:35 +03:00
// Used by evaluate_media_queries_and_report_changes().
Vector<WeakPtr<CSS::MediaQueryList>> m_media_query_lists;
LibWeb: Make CSS layout lazier Instead of doing layout synchronously whenever something changes, we now use a basic event loop timer to defer and coalesce relayouts. If you did something that requires a relayout of the page, make sure to call Document::set_needs_layout() and it will get coalesced with all the other layout updates. There's lots of room for improvement here, but this already makes many web pages significantly snappier. :^) Also, note that this exposes a number of layout bugs where we have been relying on multiple relayouts to calculate the correct dimensions for things. Now that we only do a single layout in many cases, these kind of problems are much more noticeable. That should also make them easier to figure out and fix. :^)
2021-10-05 23:30:53 +03:00
bool m_needs_layout { false };
LibWeb: Implement "NodeIterator pre-removing steps" These steps run when a node is about to be removed from its parent, and adjust the position of any live NodeIterators so that they don't point at a now-removed node. Note that while this commit implements what's in the DOM specification, the specification doesn't fully match what other browsers do. Spec bug: https://github.com/whatwg/dom/issues/907
2022-03-09 18:38:44 +03:00
LibWeb: Make document-level style invalidation fast Add a flag to DOM::Document that means the whole document needs a style update. This saves us the trouble of traversing the entire DOM to mark all nodes as needing a style update.
2022-03-19 20:10:59 +03:00
bool m_needs_full_style_update { false };
LibWeb: Implement "NodeIterator pre-removing steps" These steps run when a node is about to be removed from its parent, and adjust the position of any live NodeIterators so that they don't point at a now-removed node. Note that while this commit implements what's in the DOM specification, the specification doesn't fully match what other browsers do. Spec bug: https://github.com/whatwg/dom/issues/907
2022-03-09 18:38:44 +03:00
HashTable<NodeIterator*> m_node_iterators;
LibWeb: Add the "is initial about:blank" flag to DOM::Document
2022-08-01 17:19:55 +03:00
// https://html.spec.whatwg.org/multipage/dom.html#is-initial-about:blank
bool m_is_initial_about_blank { false };
LibWeb: Store document origin as a HTML::Origin object This will allow us to remember an arbitrary origin instead of deriving it from the document's URL.
2022-08-05 11:54:01 +03:00
LibWeb: Bring browsing context creation closer to spec This patch implements the "create a new browsing context" function from the HTML spec and replaces our existing logic with it. The big difference is that browsing contexts now initially navigate to "about:blank" instead of starting out in a strange "empty" state. This makes it possible for websites to create a new iframe and start scripting inside it right away, without having to load an URL into it.
2022-08-05 11:55:47 +03:00
// https://html.spec.whatwg.org/multipage/dom.html#concept-document-coop
HTML::CrossOriginOpenerPolicy m_cross_origin_opener_policy;
LibWeb: Add API for setting a document's referrer
2022-08-05 11:55:01 +03:00
// https://html.spec.whatwg.org/multipage/dom.html#the-document's-referrer
String m_referrer { "" };
LibWeb: Store document origin as a HTML::Origin object This will allow us to remember an arbitrary origin instead of deriving it from the document's URL.
2022-08-05 11:54:01 +03:00
// https://dom.spec.whatwg.org/#concept-document-origin
HTML::Origin m_origin;
LibWeb: Make Document vend the same HTMLCollections every time
2022-09-18 03:02:52 +03:00
JS::GCPtr<HTMLCollection> m_applets;
JS::GCPtr<HTMLCollection> m_anchors;
JS::GCPtr<HTMLCollection> m_images;
JS::GCPtr<HTMLCollection> m_embeds;
JS::GCPtr<HTMLCollection> m_links;
JS::GCPtr<HTMLCollection> m_forms;
JS::GCPtr<HTMLCollection> m_scripts;
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 19:55:47 +03:00
};
LibWeb: Implement "NodeIterator pre-removing steps" These steps run when a node is about to be removed from its parent, and adjust the position of any live NodeIterators so that they don't point at a now-removed node. Note that while this commit implements what's in the DOM specification, the specification doesn't fully match what other browsers do. Spec bug: https://github.com/whatwg/dom/issues/907
2022-03-09 18:38:44 +03:00
LibHTML: Add is<ElementType> and to<ElementType> helper functions These will help us write node-type-aware template functions.
2019-10-06 21:37:39 +03: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 14:42:07 +03:00
WRAPPER_HACK(Document, Web::DOM)
Reference in New Issue Copy Permalink