1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
/*
* Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/FlyString.h>
#include <AK/String.h>
#include <LibWeb/CSS/CSSStyleDeclaration.h>
#include <LibWeb/CSS/StyleComputer.h>
#include <LibWeb/DOM/Attribute.h>
#include <LibWeb/DOM/ChildNode.h>
#include <LibWeb/DOM/ExceptionOr.h>
#include <LibWeb/DOM/NamedNodeMap.h>
#include <LibWeb/DOM/NonDocumentTypeChildNode.h>
#include <LibWeb/DOM/ParentNode.h>
#include <LibWeb/DOM/QualifiedName.h>
#include <LibWeb/HTML/AttributeNames.h>
#include <LibWeb/HTML/EventLoop/Task.h>
#include <LibWeb/HTML/TagNames.h>
#include <LibWeb/Layout/Node.h>
#include <LibWeb/Layout/TreeBuilder.h>
namespace Web::DOM {
class Element
: public ParentNode
, public ChildNode<Element>
, public NonDocumentTypeChildNode<Element> {
public:
using WrapperType = Bindings::ElementWrapper;
Element(Document&, DOM::QualifiedName);
virtual ~Element() override;
const String& qualified_name() const { return m_qualified_name.as_string(); }
const String& html_uppercased_qualified_name() const { return m_html_uppercased_qualified_name; }
virtual FlyString node_name() const final { return html_uppercased_qualified_name(); }
const FlyString& local_name() const { return m_qualified_name.local_name(); }
// NOTE: This is for the JS bindings
const String& tag_name() const { return html_uppercased_qualified_name(); }
const FlyString& prefix() const { return m_qualified_name.prefix(); }
const FlyString& namespace_() const { return m_qualified_name.namespace_(); }
// NOTE: This is for the JS bindings
const FlyString& namespace_uri() const { return namespace_(); }
bool has_attribute(const FlyString& name) const;
bool has_attributes() const { return !m_attributes->is_empty(); }
String attribute(const FlyString& name) const { return get_attribute(name); }
String get_attribute(const FlyString& name) const;
ExceptionOr<void> set_attribute(const FlyString& name, const String& value);
ExceptionOr<void> set_attribute_ns(FlyString const& namespace_, FlyString const& qualified_name, String const& value);
void remove_attribute(const FlyString& name);
size_t attribute_list_size() const { return m_attributes->length(); }
NonnullRefPtr<NamedNodeMap> const& attributes() const { return m_attributes; }
Vector<String> get_attribute_names() const;
RefPtr<DOMTokenList> const& class_list();
DOM::ExceptionOr<bool> matches(StringView selectors) const;
DOM::ExceptionOr<DOM::Element const*> closest(StringView selectors) const;
int client_top() const;
int client_left() const;
int client_width() const;
int client_height() const;
template<typename Callback>
void for_each_attribute(Callback callback) const
{
for (size_t i = 0; i < m_attributes->length(); ++i) {
auto const* attribute = m_attributes->item(i);
callback(attribute->name(), attribute->value());
}
}
bool has_class(const FlyString&, CaseSensitivity = CaseSensitivity::CaseSensitive) const;
const Vector<FlyString>& class_names() const { return m_classes; }
virtual void apply_presentational_hints(CSS::StyleProperties&) const { }
virtual void parse_attribute(const FlyString& name, const String& value);
virtual void did_remove_attribute(FlyString const&) { }
void recompute_style();
Layout::NodeWithStyle* layout_node() { return static_cast<Layout::NodeWithStyle*>(Node::layout_node()); }
const Layout::NodeWithStyle* layout_node() const { return static_cast<const Layout::NodeWithStyle*>(Node::layout_node()); }
String name() const { return attribute(HTML::AttributeNames::name); }
CSS::StyleProperties const* specified_css_values() const { return m_specified_css_values.ptr(); }
void set_specified_css_values(RefPtr<CSS::StyleProperties> style) { m_specified_css_values = move(style); }
NonnullRefPtr<CSS::StyleProperties> computed_style();
const CSS::CSSStyleDeclaration* inline_style() const { return m_inline_style; }
NonnullRefPtr<CSS::CSSStyleDeclaration> style_for_bindings();
String inner_html() const;
ExceptionOr<void> set_inner_html(String const&);
bool is_focused() const;
bool is_active() const;
NonnullRefPtr<HTMLCollection> get_elements_by_class_name(FlyString const&);
ShadowRoot* shadow_root() { return m_shadow_root; }
const ShadowRoot* shadow_root() const { return m_shadow_root; }
void set_shadow_root(RefPtr<ShadowRoot>);
void set_custom_properties(HashMap<FlyString, CSS::StyleProperty> custom_properties) { m_custom_properties = move(custom_properties); }
HashMap<FlyString, CSS::StyleProperty> const& custom_properties() const { return m_custom_properties; }
void queue_an_element_task(HTML::Task::Source, Function<void()>);
bool is_void_element() const;
bool serializes_as_void() const;
NonnullRefPtr<Geometry::DOMRect> get_bounding_client_rect() const;
NonnullRefPtr<Geometry::DOMRectList> get_client_rects() const;
virtual RefPtr<Layout::Node> create_layout_node(NonnullRefPtr<CSS::StyleProperties>);
virtual void did_receive_focus() { }
virtual void did_lose_focus() { }
static RefPtr<Layout::Node> create_layout_node_for_display_type(DOM::Document&, CSS::Display const&, NonnullRefPtr<CSS::StyleProperties>, Element*);
void set_pseudo_element_node(Badge<Layout::TreeBuilder>, CSS::Selector::PseudoElement, RefPtr<Layout::Node>);
RefPtr<Layout::Node> get_pseudo_element_node(CSS::Selector::PseudoElement) const;
void clear_pseudo_element_nodes(Badge<Layout::TreeBuilder>);
void serialize_pseudo_elements_as_json(JsonArraySerializer<StringBuilder>& children_array) const;
protected:
virtual void children_changed() override;
private:
void make_html_uppercased_qualified_name();
QualifiedName m_qualified_name;
String m_html_uppercased_qualified_name;
NonnullRefPtr<NamedNodeMap> m_attributes;
RefPtr<CSS::CSSStyleDeclaration> m_inline_style;
RefPtr<CSS::StyleProperties> m_specified_css_values;
HashMap<FlyString, CSS::StyleProperty> m_custom_properties;
RefPtr<DOMTokenList> m_class_list;
Vector<FlyString> m_classes;
RefPtr<ShadowRoot> m_shadow_root;
Array<RefPtr<Layout::Node>, CSS::Selector::PseudoElementCount> m_pseudo_element_nodes;
};
template<>
inline bool Node::fast_is<Element>() const { return is_element(); }
ExceptionOr<QualifiedName> validate_and_extract(FlyString namespace_, FlyString qualified_name);
}
|
