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

624 lines
26 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 09:38:21 +01:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
LibWeb: Create base class CSSRule for all CSS rules This is a foundation for handling other ("at") CSS rules.
2021-02-21 13:45:26 +02:00
* Copyright (c) 2021, the SerenityOS developers.
LibWeb: Convert StyleResolver.{h,cpp} to east const
2021-07-14 16:56:11 +01:00
* Copyright (c) 2021, Sam Atkins <atkinssj@gmail.com>
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 09:38:21 +01:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
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 09:38:21 +01:00
*/
LibWeb: Apply style rules in order of specificity (kinda) We now sort the matched rules by the specificity of the first selector in them. This is not perfect, since a rule can have multiple selectors, but it is a nice chin-related progression on ACID2. :^)
2020-06-10 16:41:30 +02:00
#include <AK/QuickSort.h>
LibWeb: Rename StyleRule => CSSStyleRule This matches the CSSOM specification.
2021-03-07 15:00:02 +01:00
#include <LibWeb/CSS/CSSStyleRule.h>
LibWeb: Handle ValueListStyleValues in StyleResolver This implements a lot of cases, but not all of them. The following need more infrastructure first: - Flex - FlexFlow - Background - BackgroundImage - BackgroundRepeat - ListStyle and parts - Font Also, colors are not parsed correctly. This will be handled next.
2021-07-14 19:57:02 +01:00
#include <LibWeb/CSS/Parser/Parser.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 10:32:51 +01:00
#include <LibWeb/CSS/SelectorEngine.h>
#include <LibWeb/CSS/StyleResolver.h>
#include <LibWeb/CSS/StyleSheet.h>
#include <LibWeb/DOM/Document.h>
#include <LibWeb/DOM/Element.h>
#include <LibWeb/Dump.h>
LibHTML: Implement the "margin" shorthand property This is a very bulky way of doing this, and doesn't seem sustainable to implement every shorthand property this way, but it's a place to start. The "margin" CSS property now expands into its four longhands as far as my understanding of the specs. Note that shorthand expansion happens when we *resolve* style, not when we parse CSS. I'm not sure this is correct anymore, I think other UA's may actually expand shorthands into the declaration directly at parse these days. If so, we should do this at parsing as well.
2019-11-18 11:49:19 +01:00
#include <ctype.h>
LibHTML: Implement some very simple selector matching. We walk the entire DOM and check all selectors against all elements. Only id, class and tag name are checked right now. There's no ancestor stack or compound selectors. All in good time :^)
2019-06-27 20:40:21 +02:00
#include <stdio.h>
LibHTML: Start fleshing out a StyleResolver class. This will be responsible for matching selectors and creating LayoutStyle objects for the document and its elements.
2019-06-27 17:47:59 +02:00
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 20:01:35 +02:00
namespace Web::CSS {
LibWeb: Move everything into the Web namespace
2020-03-07 10:27:02 +01: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 19:37:56 +02:00
StyleResolver::StyleResolver(DOM::Document& document)
LibHTML: Start fleshing out a StyleResolver class. This will be responsible for matching selectors and creating LayoutStyle objects for the document and its elements.
2019-06-27 17:47:59 +02:00
: m_document(document)
{
}
StyleResolver::~StyleResolver()
{
}
LibHTML: Make StyleResolver responsible for loading the default style Instead of HtmlView clients having to worry about parsing and loading the default CSS, just take care of it inside StyleResolver. The default style is automatically inserted into the stylesheet list, at the very start, so everyone else gets a chance to override it.
2019-10-05 09:01:12 +02:00
static StyleSheet& default_stylesheet()
{
static StyleSheet* sheet;
if (!sheet) {
LibWeb: Convert StyleResolver.{h,cpp} to east const
2021-07-14 16:56:11 +01:00
extern char const default_stylesheet_source[];
LibHTML: Make StyleResolver responsible for loading the default style Instead of HtmlView clients having to worry about parsing and loading the default CSS, just take care of it inside StyleResolver. The default style is automatically inserted into the stylesheet list, at the very start, so everyone else gets a chance to override it.
2019-10-05 09:01:12 +02:00
String css = default_stylesheet_source;
LibWeb: Switch to new CSS Parser :^) Change all the places that were including the deprecated parser, to include the new one instead, and then delete the old parser code. `ParentNode::query_selector[_all]()` now treat their input as a comma-separated list of selectors, instead of just one, and return elements that match any of the selectors in that list. This is according to these specs: - querySelector/querySelectorAll: https://dom.spec.whatwg.org/#ref-for-dom-parentnode-queryselector%E2%91%A0 - selector matching algorithm: https://www.w3.org/TR/selectors-4/#match-against-tree
2021-07-30 19:31:46 +01:00
sheet = parse_css(CSS::ParsingContext(), css).leak_ref();
LibHTML: Make StyleResolver responsible for loading the default style Instead of HtmlView clients having to worry about parsing and loading the default CSS, just take care of it inside StyleResolver. The default style is automatically inserted into the stylesheet list, at the very start, so everyone else gets a chance to override it.
2019-10-05 09:01:12 +02:00
}
return *sheet;
}
LibWeb: Add a separate UA style sheet for documents in quirks mode We need to make some additional tweaks to the default UA style when displaying documents in quirks mode.
2020-09-24 10:33:33 +02:00
static StyleSheet& quirks_mode_stylesheet()
{
static StyleSheet* sheet;
if (!sheet) {
LibWeb: Convert StyleResolver.{h,cpp} to east const
2021-07-14 16:56:11 +01:00
extern char const quirks_mode_stylesheet_source[];
LibWeb: Add a separate UA style sheet for documents in quirks mode We need to make some additional tweaks to the default UA style when displaying documents in quirks mode.
2020-09-24 10:33:33 +02:00
String css = quirks_mode_stylesheet_source;
LibWeb: Switch to new CSS Parser :^) Change all the places that were including the deprecated parser, to include the new one instead, and then delete the old parser code. `ParentNode::query_selector[_all]()` now treat their input as a comma-separated list of selectors, instead of just one, and return elements that match any of the selectors in that list. This is according to these specs: - querySelector/querySelectorAll: https://dom.spec.whatwg.org/#ref-for-dom-parentnode-queryselector%E2%91%A0 - selector matching algorithm: https://www.w3.org/TR/selectors-4/#match-against-tree
2021-07-30 19:31:46 +01:00
sheet = parse_css(CSS::ParsingContext(), css).leak_ref();
LibWeb: Add a separate UA style sheet for documents in quirks mode We need to make some additional tweaks to the default UA style when displaying documents in quirks mode.
2020-09-24 10:33:33 +02:00
}
return *sheet;
}
LibHTML: Make StyleResolver responsible for loading the default style Instead of HtmlView clients having to worry about parsing and loading the default CSS, just take care of it inside StyleResolver. The default style is automatically inserted into the stylesheet list, at the very start, so everyone else gets a chance to override it.
2019-10-05 09:01:12 +02:00
template<typename Callback>
void StyleResolver::for_each_stylesheet(Callback callback) const
{
callback(default_stylesheet());
LibWeb: Add a separate UA style sheet for documents in quirks mode We need to make some additional tweaks to the default UA style when displaying documents in quirks mode.
2020-09-24 10:33:33 +02:00
if (document().in_quirks_mode())
callback(quirks_mode_stylesheet());
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 16:06:32 +02:00
for (auto& sheet : document().style_sheets().sheets()) {
LibHTML: Make StyleResolver responsible for loading the default style Instead of HtmlView clients having to worry about parsing and loading the default CSS, just take care of it inside StyleResolver. The default style is automatically inserted into the stylesheet list, at the very start, so everyone else gets a chance to override it.
2019-10-05 09:01:12 +02:00
callback(sheet);
}
}
LibWeb: Convert StyleResolver.{h,cpp} to east const
2021-07-14 16:56:11 +01:00
Vector<MatchingRule> StyleResolver::collect_matching_rules(DOM::Element const& element) const
LibHTML: Implement some very simple selector matching. We walk the entire DOM and check all selectors against all elements. Only id, class and tag name are checked right now. There's no ancestor stack or compound selectors. All in good time :^)
2019-06-27 20:40:21 +02:00
{
LibWeb: Sort matched style rules by specificity, document order If two rules have equal specificity, they should be applied in the order in which we encountered them.
2020-06-13 00:44:26 +02:00
Vector<MatchingRule> matching_rules;
LibHTML: Make StyleResolver responsible for loading the default style Instead of HtmlView clients having to worry about parsing and loading the default CSS, just take care of it inside StyleResolver. The default style is automatically inserted into the stylesheet list, at the very start, so everyone else gets a chance to override it.
2019-10-05 09:01:12 +02:00
LibWeb: Sort matched style rules by specificity, document order If two rules have equal specificity, they should be applied in the order in which we encountered them.
2020-06-13 00:44:26 +02:00
size_t style_sheet_index = 0;
LibHTML: Make StyleResolver responsible for loading the default style Instead of HtmlView clients having to worry about parsing and loading the default CSS, just take care of it inside StyleResolver. The default style is automatically inserted into the stylesheet list, at the very start, so everyone else gets a chance to override it.
2019-10-05 09:01:12 +02:00
for_each_stylesheet([&](auto& sheet) {
LibWeb: Sort matched style rules by specificity, document order If two rules have equal specificity, they should be applied in the order in which we encountered them.
2020-06-13 00:44:26 +02:00
size_t rule_index = 0;
LibWeb: Convert StyleResolver.{h,cpp} to east const
2021-07-14 16:56:11 +01:00
static_cast<CSSStyleSheet const&>(sheet).for_each_effective_style_rule([&](auto& rule) {
LibWeb: Sort matched style rules by specificity, document order If two rules have equal specificity, they should be applied in the order in which we encountered them.
2020-06-13 00:44:26 +02:00
size_t selector_index = 0;
LibHTML: Implement some very simple selector matching. We walk the entire DOM and check all selectors against all elements. Only id, class and tag name are checked right now. There's no ancestor stack or compound selectors. All in good time :^)
2019-06-27 20:40:21 +02:00
for (auto& selector : rule.selectors()) {
LibHTML: Move selector matching into a SelectorEngine namespace
2019-10-08 15:33:58 +02:00
if (SelectorEngine::matches(selector, element)) {
LibWeb: StyleResolver: Keep track of specificity of matched selector This way it gets easier to compare matches.
2021-05-24 23:01:24 +02:00
matching_rules.append({ rule, style_sheet_index, rule_index, selector_index, selector.specificity() });
LibHTML: Implement some very simple selector matching. We walk the entire DOM and check all selectors against all elements. Only id, class and tag name are checked right now. There's no ancestor stack or compound selectors. All in good time :^)
2019-06-27 20:40:21 +02:00
break;
}
LibWeb: Sort matched style rules by specificity, document order If two rules have equal specificity, they should be applied in the order in which we encountered them.
2020-06-13 00:44:26 +02:00
++selector_index;
LibHTML: Implement some very simple selector matching. We walk the entire DOM and check all selectors against all elements. Only id, class and tag name are checked right now. There's no ancestor stack or compound selectors. All in good time :^)
2019-06-27 20:40:21 +02:00
}
LibWeb: Sort matched style rules by specificity, document order If two rules have equal specificity, they should be applied in the order in which we encountered them.
2020-06-13 00:44:26 +02:00
++rule_index;
LibWeb: Create base class CSSRule for all CSS rules This is a foundation for handling other ("at") CSS rules.
2021-02-21 13:45:26 +02:00
});
LibWeb: Sort matched style rules by specificity, document order If two rules have equal specificity, they should be applied in the order in which we encountered them.
2020-06-13 00:44:26 +02:00
++style_sheet_index;
LibWeb: Fix clang-format issue in CSS/StyleResolver.cpp
2021-03-07 17:53:20 +01:00
});
LibHTML: Hide debugging output unless HTML_DEBUG is defined
2019-09-25 12:42:10 +03:00
LibHTML: Implement some very simple selector matching. We walk the entire DOM and check all selectors against all elements. Only id, class and tag name are checked right now. There's no ancestor stack or compound selectors. All in good time :^)
2019-06-27 20:40:21 +02:00
return matching_rules;
}
LibWeb: Add a simple StyleInvalidator class This patch adds a simple, naive & inefficient class for document-wide style invalidation, e.g. after element attribute updates. During construction it collects a HashMap of a document's elements and their matching rules, during destruction it does the same and then compares the results; dirtying all elements that have a different number or order of matching rules afterwards. Much room for improvement, but it solves the problem of stale element styling after attribute updates for now :^) Fixes #4404.
2020-12-14 21:31:10 +00:00
void StyleResolver::sort_matching_rules(Vector<MatchingRule>& matching_rules) const
{
quick_sort(matching_rules, [&](MatchingRule& a, MatchingRule& b) {
auto& a_selector = a.rule->selectors()[a.selector_index];
auto& b_selector = b.rule->selectors()[b.selector_index];
auto a_specificity = a_selector.specificity();
auto b_specificity = b_selector.specificity();
if (a_selector.specificity() == b_selector.specificity()) {
if (a.style_sheet_index == b.style_sheet_index)
return a.rule_index < b.rule_index;
return a.style_sheet_index < b.style_sheet_index;
}
return a_specificity < b_specificity;
});
}
LibHTML: Use an enum for CSS property ID's Instead of using string everywhere, have the CSS parser produce enum values, since they are a lot nicer to work with. In the future we should generate most of this code based on a list of supported CSS properties.
2019-10-08 15:34:19 +02:00
bool StyleResolver::is_inherited_property(CSS::PropertyID property_id)
LibHTML: Make CSS inheritance slightly less hacky Add a simple is_inherited_property(name) lookup function and use that to implement CSS property inheritance. It's a bug that "text-decoration" is inherited, but we currently rely on this in order to propagate e.g underline into linkified line boxes.
2019-10-04 22:52:49 +02:00
{
LibHTML: Use an enum for CSS property ID's Instead of using string everywhere, have the CSS parser produce enum values, since they are a lot nicer to work with. In the future we should generate most of this code based on a list of supported CSS properties.
2019-10-08 15:34:19 +02:00
static HashTable<CSS::PropertyID> inherited_properties;
LibHTML: Make CSS inheritance slightly less hacky Add a simple is_inherited_property(name) lookup function and use that to implement CSS property inheritance. It's a bug that "text-decoration" is inherited, but we currently rely on this in order to propagate e.g underline into linkified line boxes.
2019-10-04 22:52:49 +02:00
if (inherited_properties.is_empty()) {
LibHTML: Use an enum for CSS property ID's Instead of using string everywhere, have the CSS parser produce enum values, since they are a lot nicer to work with. In the future we should generate most of this code based on a list of supported CSS properties.
2019-10-08 15:34:19 +02:00
inherited_properties.set(CSS::PropertyID::BorderCollapse);
inherited_properties.set(CSS::PropertyID::BorderSpacing);
inherited_properties.set(CSS::PropertyID::Color);
inherited_properties.set(CSS::PropertyID::FontFamily);
inherited_properties.set(CSS::PropertyID::FontSize);
inherited_properties.set(CSS::PropertyID::FontStyle);
inherited_properties.set(CSS::PropertyID::FontVariant);
inherited_properties.set(CSS::PropertyID::FontWeight);
inherited_properties.set(CSS::PropertyID::LetterSpacing);
inherited_properties.set(CSS::PropertyID::LineHeight);
inherited_properties.set(CSS::PropertyID::ListStyle);
inherited_properties.set(CSS::PropertyID::ListStyleImage);
inherited_properties.set(CSS::PropertyID::ListStylePosition);
inherited_properties.set(CSS::PropertyID::ListStyleType);
inherited_properties.set(CSS::PropertyID::TextAlign);
inherited_properties.set(CSS::PropertyID::TextIndent);
inherited_properties.set(CSS::PropertyID::TextTransform);
inherited_properties.set(CSS::PropertyID::Visibility);
inherited_properties.set(CSS::PropertyID::WhiteSpace);
inherited_properties.set(CSS::PropertyID::WordSpacing);
LibHTML: Make CSS inheritance slightly less hacky Add a simple is_inherited_property(name) lookup function and use that to implement CSS property inheritance. It's a bug that "text-decoration" is inherited, but we currently rely on this in order to propagate e.g underline into linkified line boxes.
2019-10-04 22:52:49 +02:00
// FIXME: This property is not supposed to be inherited, but we currently
// rely on inheritance to propagate decorations into line boxes.
LibWeb: Update text-decoration hack to use text-decoration-line We have a hack that propagates text-decoration-line through inheritance even though it's not an inherited property. Once we implement the CSS cascade properly we can stop doing this.
2020-12-15 20:48:16 +01:00
inherited_properties.set(CSS::PropertyID::TextDecorationLine);
LibHTML: Make CSS inheritance slightly less hacky Add a simple is_inherited_property(name) lookup function and use that to implement CSS property inheritance. It's a bug that "text-decoration" is inherited, but we currently rely on this in order to propagate e.g underline into linkified line boxes.
2019-10-04 22:52:49 +02:00
}
LibHTML: Use an enum for CSS property ID's Instead of using string everywhere, have the CSS parser produce enum values, since they are a lot nicer to work with. In the future we should generate most of this code based on a list of supported CSS properties.
2019-10-08 15:34:19 +02:00
return inherited_properties.contains(property_id);
LibHTML: Make CSS inheritance slightly less hacky Add a simple is_inherited_property(name) lookup function and use that to implement CSS property inheritance. It's a bug that "text-decoration" is inherited, but we currently rely on this in order to propagate e.g underline into linkified line boxes.
2019-10-04 22:52:49 +02:00
}
LibWeb: Expand border-{top,right,bottom-left} CSS shorthand properties This code is pretty rough, but it's something that will also improve with the eventual new CSS parser.
2020-06-10 16:14:31 +02:00
enum class Edge {
Top,
Right,
Bottom,
Left,
All,
};
static bool contains(Edge a, Edge b)
{
return a == b || b == Edge::All;
}
LibWeb: Convert StyleResolver.{h,cpp} to east const
2021-07-14 16:56:11 +01:00
static void set_property_expanding_shorthands(StyleProperties& style, CSS::PropertyID property_id, StyleValue const& value, DOM::Document& document, bool is_internally_generated_pseudo_property = false)
LibHTML: Implement the "margin" shorthand property This is a very bulky way of doing this, and doesn't seem sustainable to implement every shorthand property this way, but it's a place to start. The "margin" CSS property now expands into its four longhands as far as my understanding of the specs. Note that shorthand expansion happens when we *resolve* style, not when we parse CSS. I'm not sure this is correct anymore, I think other UA's may actually expand shorthands into the declaration directly at parse these days. If so, we should do this at parsing as well.
2019-11-18 11:49:19 +01:00
{
LibWeb: Support "pseudo" CSS properties These are properties that may used internally by LibWeb when resolving style values, but may not be set by external stylesheets. For example, 'background-repeat' may be a two-value CSS property that internally translates to 'background-repeat-x' and 'background-repeat-y'.
2021-04-05 10:12:37 -04:00
if (is_pseudo_property(property_id) && !is_internally_generated_pseudo_property) {
dbgln("Ignoring non-internally-generated pseudo property: {}", string_from_property_id(property_id));
return;
}
LibWeb: Use new StyleValueList for simple properties Also, moved the repeated code for assigning 1-4 values to top/right/bottom/left properties, into an assign_edge_values() lambda, for convenience.
2021-08-06 14:34:59 +01:00
auto assign_edge_values = [&style](PropertyID top_property, PropertyID right_property, PropertyID bottom_property, PropertyID left_property, auto const& values) {
if (values.size() == 4) {
style.set_property(top_property, values[0]);
style.set_property(right_property, values[1]);
style.set_property(bottom_property, values[2]);
style.set_property(left_property, values[3]);
} else if (values.size() == 3) {
style.set_property(top_property, values[0]);
style.set_property(right_property, values[1]);
style.set_property(bottom_property, values[2]);
style.set_property(left_property, values[1]);
} else if (values.size() == 2) {
style.set_property(top_property, values[0]);
style.set_property(right_property, values[1]);
style.set_property(bottom_property, values[0]);
style.set_property(left_property, values[1]);
} else if (values.size() == 1) {
style.set_property(top_property, values[0]);
style.set_property(right_property, values[0]);
style.set_property(bottom_property, values[0]);
style.set_property(left_property, values[0]);
}
};
LibWeb: Use IdentifierStyleValue for CSS 'text-decoration-line' Also 'text-decoration' is actually a shorthand, so treat it that way.
2020-12-15 13:36:27 +01:00
if (property_id == CSS::PropertyID::TextDecoration) {
LibWeb: Implement and use TextDecorationStyleValue Modified text-decoration.html to better test that the values can be in any order, and that it adopts the color from the `color` property if no decoration color is specified. Right now, it always does because we do not support a different decoration color. Later, we need to support the `currentcolor` special CSS value for this purpose.
2021-08-04 12:34:14 +01:00
if (value.is_text_decoration()) {
auto& text_decoration = static_cast<TextDecorationStyleValue const&>(value);
style.set_property(CSS::PropertyID::TextDecorationLine, text_decoration.line());
style.set_property(CSS::PropertyID::TextDecorationStyle, text_decoration.style());
style.set_property(CSS::PropertyID::TextDecorationColor, text_decoration.color());
LibWeb: Resolve CSS text-decoration from value list This detects and resolves these in the text-decoration property, in any order: - text-decoration-color - text-decoration-line - text-decoration-style Only the solid underline renders, but all three sub-properties are assigned correctly.
2021-07-22 14:56:44 +01:00
return;
}
LibWeb: Implement and use TextDecorationStyleValue Modified text-decoration.html to better test that the values can be in any order, and that it adopts the color from the `color` property if no decoration color is specified. Right now, it always does because we do not support a different decoration color. Later, we need to support the `currentcolor` special CSS value for this purpose.
2021-08-04 12:34:14 +01:00
if (value.is_builtin()) {
LibWeb: Resolve CSS text-decoration from value list This detects and resolves these in the text-decoration property, in any order: - text-decoration-color - text-decoration-line - text-decoration-style Only the solid underline renders, but all three sub-properties are assigned correctly.
2021-07-22 14:56:44 +01:00
style.set_property(CSS::PropertyID::TextDecorationLine, value);
style.set_property(CSS::PropertyID::TextDecorationStyle, value);
LibWeb: Implement and use TextDecorationStyleValue Modified text-decoration.html to better test that the values can be in any order, and that it adopts the color from the `color` property if no decoration color is specified. Right now, it always does because we do not support a different decoration color. Later, we need to support the `currentcolor` special CSS value for this purpose.
2021-08-04 12:34:14 +01:00
style.set_property(CSS::PropertyID::TextDecorationColor, value);
LibWeb: Resolve CSS text-decoration from value list This detects and resolves these in the text-decoration property, in any order: - text-decoration-color - text-decoration-line - text-decoration-style Only the solid underline renders, but all three sub-properties are assigned correctly.
2021-07-22 14:56:44 +01:00
return;
}
LibWeb: Use IdentifierStyleValue for CSS 'text-decoration-line' Also 'text-decoration' is actually a shorthand, so treat it that way.
2020-12-15 13:36:27 +01:00
return;
}
LibWeb: Add parsing and application of CSS "overflow" property We don't actually do anything with the values yet, but now they are available for layout nodes once we are ready to implement them.
2021-02-22 15:20:31 +01:00
if (property_id == CSS::PropertyID::Overflow) {
LibWeb: Implement and use OverflowStyleValue Also added a test page for the `overflow` properties. They apparently don't work, but at least they do parse.
2021-08-09 14:54:40 +01:00
if (value.is_overflow()) {
auto& overflow = static_cast<OverflowStyleValue const&>(value);
style.set_property(CSS::PropertyID::OverflowX, overflow.overflow_x());
style.set_property(CSS::PropertyID::OverflowY, overflow.overflow_y());
return;
}
if (value.is_builtin()) {
style.set_property(CSS::PropertyID::OverflowX, value);
style.set_property(CSS::PropertyID::OverflowY, value);
return;
}
LibWeb: Add parsing and application of CSS "overflow" property We don't actually do anything with the values yet, but now they are available for layout nodes once we are ready to implement them.
2021-02-22 15:20:31 +01:00
return;
}
LibWeb: Add CSS property 'border' This makes it possible to write shorter CSS. Instead of writing .foo { border-width: 3px; border-style: solid; border-color: blue; } it is now possible to write .foo { border: 3px solid blue; } while the order of values is irrelevant. Currently only the basic values are supported. More values should be added in the future. Three more value specific parse functions were added: parse_line_width, parse_color, and parse_line_style Additionally a few test cases were added to borders.html.
2020-03-20 20:29:39 +01:00
if (property_id == CSS::PropertyID::Border) {
LibWeb: Expand "background: url()" into "background-image: url()" This gives us a yellow forehead on ACID2! :^)
2020-06-10 17:47:04 +02:00
set_property_expanding_shorthands(style, CSS::PropertyID::BorderTop, value, document);
set_property_expanding_shorthands(style, CSS::PropertyID::BorderRight, value, document);
set_property_expanding_shorthands(style, CSS::PropertyID::BorderBottom, value, document);
set_property_expanding_shorthands(style, CSS::PropertyID::BorderLeft, value, document);
LibWeb: Implement and use BorderStyleValue
2021-08-05 21:11:38 +01:00
// FIXME: Also reset border-image, in line with the spec: https://www.w3.org/TR/css-backgrounds-3/#border-shorthands
LibWeb: Don't leave "border" CSS property around after expansion The "border" property is a shorthand that expands into multiple longhand properties. We shouldn't leave it set in a StyleProperties after expanding it.
2020-12-19 19:30:49 +01:00
return;
LibWeb: Expand border-{top,right,bottom-left} CSS shorthand properties This code is pretty rough, but it's something that will also improve with the eventual new CSS parser.
2020-06-10 16:14:31 +02:00
}
LibWeb: Resolve shorthand for border-radius This takes care of the 1, 2, 3 and 4 parameter shorthand of the border- radius identifier. There are more as well as the ominous '/' character but that is for another time. The 2 and 3 parameter versions are weird enough already. I don't think anybody uses anything other than the 1 or 4 parameter version or even the elliptical stuff.
2021-05-14 22:31:52 +02:00
if (property_id == CSS::PropertyID::BorderRadius) {
LibWeb: Implement and use BorderRadiusStyleValue This parses the elliptical border-radius values, though currently we only support circular ones. So, to_length() is overloaded to return the horizontal-radius. This means the code in Layout/Node.cpp does not need to change for now.
2021-08-06 16:55:08 +01:00
if (value.is_value_list()) {
auto& values_list = static_cast<StyleValueList const&>(value);
assign_edge_values(PropertyID::BorderTopLeftRadius, PropertyID::BorderTopRightRadius, PropertyID::BorderBottomRightRadius, PropertyID::BorderBottomLeftRadius, values_list.values());
return;
}
if (value.is_builtin()) {
LibWeb: Resolve shorthand for border-radius This takes care of the 1, 2, 3 and 4 parameter shorthand of the border- radius identifier. There are more as well as the ominous '/' character but that is for another time. The 2 and 3 parameter versions are weird enough already. I don't think anybody uses anything other than the 1 or 4 parameter version or even the elliptical stuff.
2021-05-14 22:31:52 +02:00
style.set_property(CSS::PropertyID::BorderTopLeftRadius, value);
style.set_property(CSS::PropertyID::BorderTopRightRadius, value);
style.set_property(CSS::PropertyID::BorderBottomRightRadius, value);
style.set_property(CSS::PropertyID::BorderBottomLeftRadius, value);
return;
}
return;
}
LibWeb: Expand border-{top,right,bottom-left} CSS shorthand properties This code is pretty rough, but it's something that will also improve with the eventual new CSS parser.
2020-06-10 16:14:31 +02:00
if (property_id == CSS::PropertyID::BorderTop
|| property_id == CSS::PropertyID::BorderRight
|| property_id == CSS::PropertyID::BorderBottom
|| property_id == CSS::PropertyID::BorderLeft) {
Edge edge = Edge::All;
switch (property_id) {
case CSS::PropertyID::BorderTop:
edge = Edge::Top;
break;
case CSS::PropertyID::BorderRight:
edge = Edge::Right;
break;
case CSS::PropertyID::BorderBottom:
edge = Edge::Bottom;
break;
case CSS::PropertyID::BorderLeft:
edge = Edge::Left;
break;
default:
break;
}
LibWeb: Implement and use BorderStyleValue
2021-08-05 21:11:38 +01:00
if (value.is_border()) {
auto& border = static_cast<BorderStyleValue const&>(value);
if (contains(Edge::Top, edge)) {
style.set_property(PropertyID::BorderTopWidth, border.border_width());
style.set_property(PropertyID::BorderTopStyle, border.border_style());
style.set_property(PropertyID::BorderTopColor, border.border_color());
LibWeb: Handle ValueListStyleValues in StyleResolver This implements a lot of cases, but not all of them. The following need more infrastructure first: - Flex - FlexFlow - Background - BackgroundImage - BackgroundRepeat - ListStyle and parts - Font Also, colors are not parsed correctly. This will be handled next.
2021-07-14 19:57:02 +01:00
}
LibWeb: Implement and use BorderStyleValue
2021-08-05 21:11:38 +01:00
if (contains(Edge::Right, edge)) {
style.set_property(PropertyID::BorderRightWidth, border.border_width());
style.set_property(PropertyID::BorderRightStyle, border.border_style());
style.set_property(PropertyID::BorderRightColor, border.border_color());
}
if (contains(Edge::Bottom, edge)) {
style.set_property(PropertyID::BorderBottomWidth, border.border_width());
style.set_property(PropertyID::BorderBottomStyle, border.border_style());
style.set_property(PropertyID::BorderBottomColor, border.border_color());
}
if (contains(Edge::Left, edge)) {
style.set_property(PropertyID::BorderLeftWidth, border.border_width());
style.set_property(PropertyID::BorderLeftStyle, border.border_style());
style.set_property(PropertyID::BorderLeftColor, border.border_color());
LibWeb: Add CSS property 'border' This makes it possible to write shorter CSS. Instead of writing .foo { border-width: 3px; border-style: solid; border-color: blue; } it is now possible to write .foo { border: 3px solid blue; } while the order of values is irrelevant. Currently only the basic values are supported. More values should be added in the future. Three more value specific parse functions were added: parse_line_width, parse_color, and parse_line_style Additionally a few test cases were added to borders.html.
2020-03-20 20:29:39 +01:00
}
return;
}
return;
}
LibHTML: Add shorthand expansion for border-{style,width,color} This is going to be quite boring to do by hand for every single CSS property. We'll probably want to come up with a way to auto-generate some/most of the shorthand expansion code.
2019-11-27 20:51:15 +01:00
if (property_id == CSS::PropertyID::BorderStyle) {
LibWeb: Use new StyleValueList for simple properties Also, moved the repeated code for assigning 1-4 values to top/right/bottom/left properties, into an assign_edge_values() lambda, for convenience.
2021-08-06 14:34:59 +01:00
if (value.is_value_list()) {
auto& values_list = static_cast<StyleValueList const&>(value);
assign_edge_values(PropertyID::BorderTopStyle, PropertyID::BorderRightStyle, PropertyID::BorderBottomStyle, PropertyID::BorderLeftStyle, values_list.values());
return;
}
if (value.is_builtin()) {
style.set_property(CSS::PropertyID::BorderTopStyle, value);
style.set_property(CSS::PropertyID::BorderRightStyle, value);
style.set_property(CSS::PropertyID::BorderBottomStyle, value);
style.set_property(CSS::PropertyID::BorderLeftStyle, value);
LibWeb: Handle ValueListStyleValues in StyleResolver This implements a lot of cases, but not all of them. The following need more infrastructure first: - Flex - FlexFlow - Background - BackgroundImage - BackgroundRepeat - ListStyle and parts - Font Also, colors are not parsed correctly. This will be handled next.
2021-07-14 19:57:02 +01:00
return;
LibWeb: Don't try to expand shorthands from non-string CSS values If something is already e.g a length or a color value, we don't need to try to expand it by stringifying and looking at the parts.
2020-06-10 19:34:49 +02:00
}
LibHTML: Add shorthand expansion for border-{style,width,color} This is going to be quite boring to do by hand for every single CSS property. We'll probably want to come up with a way to auto-generate some/most of the shorthand expansion code.
2019-11-27 20:51:15 +01:00
return;
}
if (property_id == CSS::PropertyID::BorderWidth) {
LibWeb: Use new StyleValueList for simple properties Also, moved the repeated code for assigning 1-4 values to top/right/bottom/left properties, into an assign_edge_values() lambda, for convenience.
2021-08-06 14:34:59 +01:00
if (value.is_value_list()) {
auto& values_list = static_cast<StyleValueList const&>(value);
assign_edge_values(PropertyID::BorderTopWidth, PropertyID::BorderRightWidth, PropertyID::BorderBottomWidth, PropertyID::BorderLeftWidth, values_list.values());
return;
}
if (value.is_builtin()) {
style.set_property(CSS::PropertyID::BorderTopWidth, value);
style.set_property(CSS::PropertyID::BorderRightWidth, value);
style.set_property(CSS::PropertyID::BorderBottomWidth, value);
style.set_property(CSS::PropertyID::BorderLeftWidth, value);
LibWeb: Handle ValueListStyleValues in StyleResolver This implements a lot of cases, but not all of them. The following need more infrastructure first: - Flex - FlexFlow - Background - BackgroundImage - BackgroundRepeat - ListStyle and parts - Font Also, colors are not parsed correctly. This will be handled next.
2021-07-14 19:57:02 +01:00
return;
LibWeb: Expand 2-part border-width shorthand CSS properties
2020-06-10 16:42:58 +02:00
}
LibHTML: Add shorthand expansion for border-{style,width,color} This is going to be quite boring to do by hand for every single CSS property. We'll probably want to come up with a way to auto-generate some/most of the shorthand expansion code.
2019-11-27 20:51:15 +01:00
return;
}
if (property_id == CSS::PropertyID::BorderColor) {
LibWeb: Use new StyleValueList for simple properties Also, moved the repeated code for assigning 1-4 values to top/right/bottom/left properties, into an assign_edge_values() lambda, for convenience.
2021-08-06 14:34:59 +01:00
if (value.is_value_list()) {
auto& values_list = static_cast<StyleValueList const&>(value);
assign_edge_values(PropertyID::BorderTopColor, PropertyID::BorderRightColor, PropertyID::BorderBottomColor, PropertyID::BorderLeftColor, values_list.values());
return;
}
if (value.is_builtin()) {
style.set_property(CSS::PropertyID::BorderTopColor, value);
style.set_property(CSS::PropertyID::BorderRightColor, value);
style.set_property(CSS::PropertyID::BorderBottomColor, value);
style.set_property(CSS::PropertyID::BorderLeftColor, value);
LibWeb: Handle ValueListStyleValues in StyleResolver This implements a lot of cases, but not all of them. The following need more infrastructure first: - Flex - FlexFlow - Background - BackgroundImage - BackgroundRepeat - ListStyle and parts - Font Also, colors are not parsed correctly. This will be handled next.
2021-07-14 19:57:02 +01:00
return;
LibWeb: Don't try to expand shorthands from non-string CSS values If something is already e.g a length or a color value, we don't need to try to expand it by stringifying and looking at the parts.
2020-06-10 19:34:49 +02:00
}
LibHTML: Add shorthand expansion for border-{style,width,color} This is going to be quite boring to do by hand for every single CSS property. We'll probably want to come up with a way to auto-generate some/most of the shorthand expansion code.
2019-11-27 20:51:15 +01:00
return;
}
LibWeb: Naive support for CSS "background" shorthand Many sites simply use "background" as an alias for "background-color" so let's at least support that.
2020-05-30 11:58:05 +02:00
if (property_id == CSS::PropertyID::Background) {
LibWeb: Implement and use BackgroundStyleValue This one represents one secton of a `background` property, since it can have multiple background values separated by commas. Eventually, we will represent that as a List of BackgroundStyleValues. Also modified some background-foo properties in StyleResolver so that the is_background_x() functions could be removed. I realized that our handling of var() in shorthand properties is wrong, so have been removing the is_builtin_or_dynamic() calls from the parsing code for shorthands. This broke our var() test page, so I have replaced the use of 'background' with 'background-color' there.
2021-08-03 14:56:08 +01:00
auto set_single_background = [&](CSS::BackgroundStyleValue const& background) {
set_property_expanding_shorthands(style, CSS::PropertyID::BackgroundColor, background.color(), document);
set_property_expanding_shorthands(style, CSS::PropertyID::BackgroundImage, background.image(), document);
set_property_expanding_shorthands(style, CSS::PropertyID::BackgroundRepeatX, background.repeat_x(), document, true);
set_property_expanding_shorthands(style, CSS::PropertyID::BackgroundRepeatY, background.repeat_y(), document, true);
};
LibWeb: Don't allow more than one color sub-value in CSS 'background'
2020-06-25 16:55:43 +02:00
LibWeb: Implement and use BackgroundStyleValue This one represents one secton of a `background` property, since it can have multiple background values separated by commas. Eventually, we will represent that as a List of BackgroundStyleValues. Also modified some background-foo properties in StyleResolver so that the is_background_x() functions could be removed. I realized that our handling of var() in shorthand properties is wrong, so have been removing the is_builtin_or_dynamic() calls from the parsing code for shorthands. This broke our var() test page, so I have replaced the use of 'background' with 'background-color' there.
2021-08-03 14:56:08 +01:00
if (value.is_background()) {
auto& background = static_cast<CSS::BackgroundStyleValue const&>(value);
set_single_background(background);
LibWeb: Resolve background properties from ValueListStyleValue As before, there are several sub-properties that we do not support, and we ignore anything after the first comma.
2021-07-21 17:47:50 +01:00
return;
}
LibWeb: Implement and use BackgroundStyleValue This one represents one secton of a `background` property, since it can have multiple background values separated by commas. Eventually, we will represent that as a List of BackgroundStyleValues. Also modified some background-foo properties in StyleResolver so that the is_background_x() functions could be removed. I realized that our handling of var() in shorthand properties is wrong, so have been removing the is_builtin_or_dynamic() calls from the parsing code for shorthands. This broke our var() test page, so I have replaced the use of 'background' with 'background-color' there.
2021-08-03 14:56:08 +01:00
if (value.is_value_list()) {
auto& background_list = static_cast<CSS::StyleValueList const&>(value).values();
// FIXME: Handle multiple backgrounds.
if (!background_list.is_empty()) {
auto& background = background_list.first();
if (background.is_background())
set_single_background(static_cast<CSS::BackgroundStyleValue const&>(background));
}
LibWeb: Resolve background properties from ValueListStyleValue As before, there are several sub-properties that we do not support, and we ignore anything after the first comma.
2021-07-21 17:47:50 +01:00
return;
}
LibWeb: Implement and use BackgroundStyleValue This one represents one secton of a `background` property, since it can have multiple background values separated by commas. Eventually, we will represent that as a List of BackgroundStyleValues. Also modified some background-foo properties in StyleResolver so that the is_background_x() functions could be removed. I realized that our handling of var() in shorthand properties is wrong, so have been removing the is_builtin_or_dynamic() calls from the parsing code for shorthands. This broke our var() test page, so I have replaced the use of 'background' with 'background-color' there.
2021-08-03 14:56:08 +01:00
if (value.is_builtin()) {
set_property_expanding_shorthands(style, CSS::PropertyID::BackgroundColor, value, document);
set_property_expanding_shorthands(style, CSS::PropertyID::BackgroundImage, value, document);
set_property_expanding_shorthands(style, CSS::PropertyID::BackgroundRepeatX, value, document, true);
set_property_expanding_shorthands(style, CSS::PropertyID::BackgroundRepeatY, value, document, true);
LibWeb: Resolve background properties from ValueListStyleValue As before, there are several sub-properties that we do not support, and we ignore anything after the first comma.
2021-07-21 17:47:50 +01:00
return;
}
LibWeb: Handle ValueListStyleValues in StyleResolver This implements a lot of cases, but not all of them. The following need more infrastructure first: - Flex - FlexFlow - Background - BackgroundImage - BackgroundRepeat - ListStyle and parts - Font Also, colors are not parsed correctly. This will be handled next.
2021-07-14 19:57:02 +01:00
LibWeb: Naive support for CSS "background" shorthand Many sites simply use "background" as an alias for "background-color" so let's at least support that.
2020-05-30 11:58:05 +02:00
return;
}
LibWeb: Apply the CSS background-image property to elements Previously we'd only pick up background-image when it was part of the background shorthand. CSS property application remains hackish, lots of room for improvement in this area. :^)
2020-10-08 15:35:21 +02:00
if (property_id == CSS::PropertyID::BackgroundImage) {
LibWeb: Handle StyleValueList for background-image Also removed the string-parsing code I'd accidentally missed removing before. Oops!
2021-08-10 16:20:30 +01:00
if (value.is_value_list()) {
auto& background_image_list = static_cast<CSS::StyleValueList const&>(value).values();
LibWeb: Resolve background properties from ValueListStyleValue As before, there are several sub-properties that we do not support, and we ignore anything after the first comma.
2021-07-21 17:47:50 +01:00
// FIXME: Handle multiple backgrounds.
LibWeb: Handle StyleValueList for background-image Also removed the string-parsing code I'd accidentally missed removing before. Oops!
2021-08-10 16:20:30 +01:00
if (!background_image_list.is_empty()) {
auto& background_image = background_image_list.first();
style.set_property(CSS::PropertyID::BackgroundImage, background_image);
LibWeb: Resolve background properties from ValueListStyleValue As before, there are several sub-properties that we do not support, and we ignore anything after the first comma.
2021-07-21 17:47:50 +01:00
}
LibWeb: Ignore non-URL values for background-image for now
2020-10-09 21:27:01 +02:00
return;
LibWeb: Resolve background properties from ValueListStyleValue As before, there are several sub-properties that we do not support, and we ignore anything after the first comma.
2021-07-21 17:47:50 +01:00
}
LibWeb: Handle StyleValueList for background-image Also removed the string-parsing code I'd accidentally missed removing before. Oops!
2021-08-10 16:20:30 +01:00
if (value.is_builtin() || value.is_image() || value.to_identifier() == ValueID::None) {
style.set_property(CSS::PropertyID::BackgroundImage, value);
return;
}
LibWeb: Apply the CSS background-image property to elements Previously we'd only pick up background-image when it was part of the background shorthand. CSS property application remains hackish, lots of room for improvement in this area. :^)
2020-10-08 15:35:21 +02:00
return;
}
LibWeb: Store computed CSS value of background-repeat
2021-04-02 15:41:29 -04:00
if (property_id == CSS::PropertyID::BackgroundRepeat) {
LibWeb: Implement and use BackgroundRepeatStyleValue This wraps an x and y background-repeat value. Potentially, we could use this in place of the background-repeat-x and background-repeat-y pseudo-properties, but for now StyleResolver splits it into those properties, like it did before.
2021-08-10 10:21:42 +01:00
if (value.is_value_list()) {
auto& background_repeat_list = static_cast<CSS::StyleValueList const&>(value).values();
// FIXME: Handle multiple backgrounds.
if (!background_repeat_list.is_empty()) {
auto& maybe_background_repeat = background_repeat_list.first();
if (maybe_background_repeat.is_background_repeat()) {
auto& background_repeat = static_cast<BackgroundRepeatStyleValue const&>(maybe_background_repeat);
set_property_expanding_shorthands(style, PropertyID::BackgroundRepeatX, background_repeat.repeat_x(), document, true);
set_property_expanding_shorthands(style, PropertyID::BackgroundRepeatY, background_repeat.repeat_y(), document, true);
LibWeb: Resolve background properties from ValueListStyleValue As before, there are several sub-properties that we do not support, and we ignore anything after the first comma.
2021-07-21 17:47:50 +01:00
}
}
LibWeb: Implement and use BackgroundStyleValue This one represents one secton of a `background` property, since it can have multiple background values separated by commas. Eventually, we will represent that as a List of BackgroundStyleValues. Also modified some background-foo properties in StyleResolver so that the is_background_x() functions could be removed. I realized that our handling of var() in shorthand properties is wrong, so have been removing the is_builtin_or_dynamic() calls from the parsing code for shorthands. This broke our var() test page, so I have replaced the use of 'background' with 'background-color' there.
2021-08-03 14:56:08 +01:00
return;
LibWeb: Resolve background properties from ValueListStyleValue As before, there are several sub-properties that we do not support, and we ignore anything after the first comma.
2021-07-21 17:47:50 +01:00
}
LibWeb: Implement and use BackgroundRepeatStyleValue This wraps an x and y background-repeat value. Potentially, we could use this in place of the background-repeat-x and background-repeat-y pseudo-properties, but for now StyleResolver splits it into those properties, like it did before.
2021-08-10 10:21:42 +01:00
if (value.is_background_repeat()) {
auto& background_repeat = static_cast<BackgroundRepeatStyleValue const&>(value);
set_property_expanding_shorthands(style, PropertyID::BackgroundRepeatX, background_repeat.repeat_x(), document, true);
set_property_expanding_shorthands(style, PropertyID::BackgroundRepeatY, background_repeat.repeat_y(), document, true);
return;
}
if (value.is_builtin()) {
set_property_expanding_shorthands(style, PropertyID::BackgroundRepeatX, value, document, true);
set_property_expanding_shorthands(style, PropertyID::BackgroundRepeatY, value, document, true);
return;
}
LibWeb: Support two-value background-repeat The background-repeat value may be specified as either one- or two-value identifiers (to be interpreted as horizontal and vertical repeat). This adds two pseudo-properties, background-repeat-x and background-repeat-y, to handle this. One-value identifiers are mapped to two-value in accordance with the spec.
2021-04-05 12:05:35 -04:00
return;
}
if (property_id == CSS::PropertyID::BackgroundRepeatX || property_id == CSS::PropertyID::BackgroundRepeatY) {
auto value_id = value.to_identifier();
if (value_id == CSS::ValueID::RepeatX || value_id == CSS::ValueID::RepeatY)
return;
style.set_property(property_id, value);
LibWeb: Store computed CSS value of background-repeat
2021-04-02 15:41:29 -04:00
return;
}
LibHTML: Implement the "margin" shorthand property This is a very bulky way of doing this, and doesn't seem sustainable to implement every shorthand property this way, but it's a place to start. The "margin" CSS property now expands into its four longhands as far as my understanding of the specs. Note that shorthand expansion happens when we *resolve* style, not when we parse CSS. I'm not sure this is correct anymore, I think other UA's may actually expand shorthands into the declaration directly at parse these days. If so, we should do this at parsing as well.
2019-11-18 11:49:19 +01:00
if (property_id == CSS::PropertyID::Margin) {
LibWeb: Use new StyleValueList for simple properties Also, moved the repeated code for assigning 1-4 values to top/right/bottom/left properties, into an assign_edge_values() lambda, for convenience.
2021-08-06 14:34:59 +01:00
if (value.is_value_list()) {
auto& values_list = static_cast<StyleValueList const&>(value);
assign_edge_values(PropertyID::MarginTop, PropertyID::MarginRight, PropertyID::MarginBottom, PropertyID::MarginLeft, values_list.values());
return;
}
if (value.is_length() || value.is_builtin()) {
LibHTML: Implement the "margin" shorthand property This is a very bulky way of doing this, and doesn't seem sustainable to implement every shorthand property this way, but it's a place to start. The "margin" CSS property now expands into its four longhands as far as my understanding of the specs. Note that shorthand expansion happens when we *resolve* style, not when we parse CSS. I'm not sure this is correct anymore, I think other UA's may actually expand shorthands into the declaration directly at parse these days. If so, we should do this at parsing as well.
2019-11-18 11:49:19 +01:00
style.set_property(CSS::PropertyID::MarginTop, value);
style.set_property(CSS::PropertyID::MarginRight, value);
style.set_property(CSS::PropertyID::MarginBottom, value);
style.set_property(CSS::PropertyID::MarginLeft, value);
return;
}
return;
}
LibHTML: Expand the "padding" shorthand property This expands in the same way as "margin".
2019-11-18 12:25:22 +01:00
if (property_id == CSS::PropertyID::Padding) {
LibWeb: Use new StyleValueList for simple properties Also, moved the repeated code for assigning 1-4 values to top/right/bottom/left properties, into an assign_edge_values() lambda, for convenience.
2021-08-06 14:34:59 +01:00
if (value.is_value_list()) {
auto& values_list = static_cast<StyleValueList const&>(value);
assign_edge_values(PropertyID::PaddingTop, PropertyID::PaddingRight, PropertyID::PaddingBottom, PropertyID::PaddingLeft, values_list.values());
return;
}
if (value.is_length() || value.is_builtin()) {
LibHTML: Expand the "padding" shorthand property This expands in the same way as "margin".
2019-11-18 12:25:22 +01:00
style.set_property(CSS::PropertyID::PaddingTop, value);
style.set_property(CSS::PropertyID::PaddingRight, value);
style.set_property(CSS::PropertyID::PaddingBottom, value);
style.set_property(CSS::PropertyID::PaddingLeft, value);
return;
}
return;
}
LibWeb: Don't render list item markers for "list-style-type: none"
2020-05-30 12:04:15 +02:00
if (property_id == CSS::PropertyID::ListStyle) {
LibWeb: Implement and use ListStyleStyleValue Yes, the name is silly, but it's a StyleValue for list-style, so... yeah. :^) Since `list-style-type` and `list-style-image` can both have `none` as a value, and can appear in any order, we have to handle it separately, and then assign either or both of those to `none` depending on how many `none`s there are, and whether those sub-properties already have values. Added some extra test cases to lists.html to cover list-style-image and list-style-position parts of the list-style shorthand, and the `none` values.
2021-08-03 15:56:51 +01:00
if (value.is_list_style()) {
auto& list_style = static_cast<CSS::ListStyleStyleValue const&>(value);
style.set_property(CSS::PropertyID::ListStylePosition, list_style.position());
style.set_property(CSS::PropertyID::ListStyleImage, list_style.image());
style.set_property(CSS::PropertyID::ListStyleType, list_style.style_type());
LibWeb: Handle ValueListStyleValues in StyleResolver This implements a lot of cases, but not all of them. The following need more infrastructure first: - Flex - FlexFlow - Background - BackgroundImage - BackgroundRepeat - ListStyle and parts - Font Also, colors are not parsed correctly. This will be handled next.
2021-07-14 19:57:02 +01:00
return;
LibWeb: Don't render list item markers for "list-style-type: none"
2020-05-30 12:04:15 +02:00
}
LibWeb: Implement and use ListStyleStyleValue Yes, the name is silly, but it's a StyleValue for list-style, so... yeah. :^) Since `list-style-type` and `list-style-image` can both have `none` as a value, and can appear in any order, we have to handle it separately, and then assign either or both of those to `none` depending on how many `none`s there are, and whether those sub-properties already have values. Added some extra test cases to lists.html to cover list-style-image and list-style-position parts of the list-style shorthand, and the `none` values.
2021-08-03 15:56:51 +01:00
if (value.is_builtin()) {
LibWeb: Resolve CSS list-style from value list This resolves the three sub-properties, appearing in any order: - list-style-image - list-style-position - list-style-type Added `list-style-position` values to support this, though they are not yet used in rendering.
2021-07-20 16:11:19 +01:00
style.set_property(CSS::PropertyID::ListStylePosition, value);
style.set_property(CSS::PropertyID::ListStyleImage, value);
style.set_property(CSS::PropertyID::ListStyleType, value);
LibWeb: Implement and use ListStyleStyleValue Yes, the name is silly, but it's a StyleValue for list-style, so... yeah. :^) Since `list-style-type` and `list-style-image` can both have `none` as a value, and can appear in any order, we have to handle it separately, and then assign either or both of those to `none` depending on how many `none`s there are, and whether those sub-properties already have values. Added some extra test cases to lists.html to cover list-style-image and list-style-position parts of the list-style shorthand, and the `none` values.
2021-08-03 15:56:51 +01:00
return;
}
LibWeb: Don't render list item markers for "list-style-type: none"
2020-05-30 12:04:15 +02:00
return;
}
LibWeb: Start parsing font property
2021-04-13 20:41:57 +03:00
if (property_id == CSS::PropertyID::Font) {
LibWeb: Implement and use FontStyleValue After working with the code for a while, it makes more sense to put all the parsing in Parser, instead of some of it living in StyleResolver. That means our current ValueListStyleValue needs to be replaced with specific StyleValue types for the properties that are shorthands or otherwise combine several values together. Here we implement FontStyleProperty, which represents a `font` CSS property. Also adjusted the fonts.html test page so that font-weights are featured in test cases without things we do not yet support.
2021-08-03 11:37:24 +01:00
if (value.is_font()) {
auto& font_shorthand = static_cast<CSS::FontStyleValue const&>(value);
style.set_property(CSS::PropertyID::FontSize, font_shorthand.font_size());
LibWeb: Parse multiple font-family values Apart from now gathering comma-separated font-family names into a StyleValueList, this also corrects the logic for parsing a single font-family. Previously, we did not handle unquoted font names at all, and now they are handled including when they are several words separated by whitespace. Modified the logic for `font` to use `parse_font_family_value()`. `FontStyleValue.font_families()` is now a StyleValueList instead of a vector, so that it can be better handled in StyleResolver. We also finally remove the CSS::ParsingContext in set_property_expanding_shorthands(). :^)
2021-08-10 17:01:26 +01:00
set_property_expanding_shorthands(style, CSS::PropertyID::FontFamily, *font_shorthand.font_families(), document);
LibWeb: Implement and use FontStyleValue After working with the code for a while, it makes more sense to put all the parsing in Parser, instead of some of it living in StyleResolver. That means our current ValueListStyleValue needs to be replaced with specific StyleValue types for the properties that are shorthands or otherwise combine several values together. Here we implement FontStyleProperty, which represents a `font` CSS property. Also adjusted the fonts.html test page so that font-weights are featured in test cases without things we do not yet support.
2021-08-03 11:37:24 +01:00
style.set_property(CSS::PropertyID::FontStyle, font_shorthand.font_style());
style.set_property(CSS::PropertyID::FontWeight, font_shorthand.font_weight());
style.set_property(CSS::PropertyID::LineHeight, font_shorthand.line_height());
// FIXME: Implement font-stretch and font-variant
LibWeb: Resolve CSS font property from value list The font property now resolves into its various parts: - font-family - font-weight - font-size - font-style - line-height The font-variant and font-stretch parts are left unparsed since LibWeb doesn't know how to render those. Added `fonts.html` as a test for various forms of `font` declarations, based on the examples in the spec.
2021-07-21 15:39:40 +01:00
return;
}
LibWeb: Implement and use FontStyleValue After working with the code for a while, it makes more sense to put all the parsing in Parser, instead of some of it living in StyleResolver. That means our current ValueListStyleValue needs to be replaced with specific StyleValue types for the properties that are shorthands or otherwise combine several values together. Here we implement FontStyleProperty, which represents a `font` CSS property. Also adjusted the fonts.html test page so that font-weights are featured in test cases without things we do not yet support.
2021-08-03 11:37:24 +01:00
if (value.is_builtin()) {
LibWeb: Resolve CSS font property from value list The font property now resolves into its various parts: - font-family - font-weight - font-size - font-style - line-height The font-variant and font-stretch parts are left unparsed since LibWeb doesn't know how to render those. Added `fonts.html` as a test for various forms of `font` declarations, based on the examples in the spec.
2021-07-21 15:39:40 +01:00
style.set_property(CSS::PropertyID::FontSize, value);
LibWeb: Implement and use FontStyleValue After working with the code for a while, it makes more sense to put all the parsing in Parser, instead of some of it living in StyleResolver. That means our current ValueListStyleValue needs to be replaced with specific StyleValue types for the properties that are shorthands or otherwise combine several values together. Here we implement FontStyleProperty, which represents a `font` CSS property. Also adjusted the fonts.html test page so that font-weights are featured in test cases without things we do not yet support.
2021-08-03 11:37:24 +01:00
// FIXME: Support multiple font-families
LibWeb: Resolve CSS font property from value list The font property now resolves into its various parts: - font-family - font-weight - font-size - font-style - line-height The font-variant and font-stretch parts are left unparsed since LibWeb doesn't know how to render those. Added `fonts.html` as a test for various forms of `font` declarations, based on the examples in the spec.
2021-07-21 15:39:40 +01:00
style.set_property(CSS::PropertyID::FontFamily, value);
style.set_property(CSS::PropertyID::FontStyle, value);
style.set_property(CSS::PropertyID::FontWeight, value);
style.set_property(CSS::PropertyID::LineHeight, value);
LibWeb: Implement and use FontStyleValue After working with the code for a while, it makes more sense to put all the parsing in Parser, instead of some of it living in StyleResolver. That means our current ValueListStyleValue needs to be replaced with specific StyleValue types for the properties that are shorthands or otherwise combine several values together. Here we implement FontStyleProperty, which represents a `font` CSS property. Also adjusted the fonts.html test page so that font-weights are featured in test cases without things we do not yet support.
2021-08-03 11:37:24 +01:00
// FIXME: Implement font-stretch and font-variant
LibWeb: Resolve CSS font property from value list The font property now resolves into its various parts: - font-family - font-weight - font-size - font-style - line-height The font-variant and font-stretch parts are left unparsed since LibWeb doesn't know how to render those. Added `fonts.html` as a test for various forms of `font` declarations, based on the examples in the spec.
2021-07-21 15:39:40 +01:00
return;
}
return;
}
if (property_id == CSS::PropertyID::FontFamily) {
LibWeb: Parse multiple font-family values Apart from now gathering comma-separated font-family names into a StyleValueList, this also corrects the logic for parsing a single font-family. Previously, we did not handle unquoted font names at all, and now they are handled including when they are several words separated by whitespace. Modified the logic for `font` to use `parse_font_family_value()`. `FontStyleValue.font_families()` is now a StyleValueList instead of a vector, so that it can be better handled in StyleResolver. We also finally remove the CSS::ParsingContext in set_property_expanding_shorthands(). :^)
2021-08-10 17:01:26 +01:00
if (value.is_value_list()) {
auto& values_list = static_cast<StyleValueList const&>(value).values();
// FIXME: Support multiple font-families
if (!values_list.is_empty()) {
style.set_property(CSS::PropertyID::FontFamily, values_list.first());
LibWeb: Resolve CSS font property from value list The font property now resolves into its various parts: - font-family - font-weight - font-size - font-style - line-height The font-variant and font-stretch parts are left unparsed since LibWeb doesn't know how to render those. Added `fonts.html` as a test for various forms of `font` declarations, based on the examples in the spec.
2021-07-21 15:39:40 +01:00
}
return;
}
LibWeb: Parse multiple font-family values Apart from now gathering comma-separated font-family names into a StyleValueList, this also corrects the logic for parsing a single font-family. Previously, we did not handle unquoted font names at all, and now they are handled including when they are several words separated by whitespace. Modified the logic for `font` to use `parse_font_family_value()`. `FontStyleValue.font_families()` is now a StyleValueList instead of a vector, so that it can be better handled in StyleResolver. We also finally remove the CSS::ParsingContext in set_property_expanding_shorthands(). :^)
2021-08-10 17:01:26 +01:00
if (value.is_builtin() || value.is_string() || value.is_identifier()) {
style.set_property(CSS::PropertyID::FontFamily, value);
return;
}
LibWeb: Start parsing font property
2021-04-13 20:41:57 +03:00
return;
}
LibWeb: Resolve CSS flex/flex-flow from value list Also moved the 'flex' code in StyleResolver to be next to the 'flex-flow' code, because that seemed more reasonable.
2021-07-20 12:05:43 +01:00
if (property_id == CSS::PropertyID::Flex) {
LibWeb: Implement and use FlexStyleValue This is not just moving the code from StyleResolver to Parser. The logic has changed to allow for the `flex-basis` to come before or after the `flex-grow/shrink` values, as well as handle the special one-value cases. Also added test cases to flex.html to check the parsing. It does parse correctly, but elements with `flex-basis: auto` do not calculate their width correctly.
2021-08-04 17:48:08 +01:00
if (value.is_flex()) {
auto& flex = static_cast<CSS::FlexStyleValue const&>(value);
style.set_property(CSS::PropertyID::FlexGrow, flex.grow());
style.set_property(CSS::PropertyID::FlexShrink, flex.shrink());
style.set_property(CSS::PropertyID::FlexBasis, flex.basis());
LibWeb: Resolve CSS flex/flex-flow from value list Also moved the 'flex' code in StyleResolver to be next to the 'flex-flow' code, because that seemed more reasonable.
2021-07-20 12:05:43 +01:00
return;
}
LibWeb: Implement and use FlexStyleValue This is not just moving the code from StyleResolver to Parser. The logic has changed to allow for the `flex-basis` to come before or after the `flex-grow/shrink` values, as well as handle the special one-value cases. Also added test cases to flex.html to check the parsing. It does parse correctly, but elements with `flex-basis: auto` do not calculate their width correctly.
2021-08-04 17:48:08 +01:00
if (value.is_builtin()) {
style.set_property(CSS::PropertyID::FlexGrow, value);
style.set_property(CSS::PropertyID::FlexShrink, value);
style.set_property(CSS::PropertyID::FlexBasis, value);
LibWeb: Resolve CSS flex/flex-flow from value list Also moved the 'flex' code in StyleResolver to be next to the 'flex-flow' code, because that seemed more reasonable.
2021-07-20 12:05:43 +01:00
return;
}
return;
}
LibWeb: Parse and resolve flex-flow property
2021-05-30 12:25:10 +02:00
if (property_id == CSS::PropertyID::FlexFlow) {
LibWeb: Implement and use FlexFlowStyleValue
2021-08-05 17:19:29 +01:00
if (value.is_flex_flow()) {
auto& flex_flow = static_cast<FlexFlowStyleValue const&>(value);
style.set_property(CSS::PropertyID::FlexDirection, flex_flow.flex_direction());
style.set_property(CSS::PropertyID::FlexWrap, flex_flow.flex_wrap());
return;
}
if (value.is_builtin()) {
style.set_property(CSS::PropertyID::FlexDirection, value);
style.set_property(CSS::PropertyID::FlexWrap, value);
LibWeb: Resolve CSS flex/flex-flow from value list Also moved the 'flex' code in StyleResolver to be next to the 'flex-flow' code, because that seemed more reasonable.
2021-07-20 12:05:43 +01:00
return;
}
LibWeb: Handle ValueListStyleValues in StyleResolver This implements a lot of cases, but not all of them. The following need more infrastructure first: - Flex - FlexFlow - Background - BackgroundImage - BackgroundRepeat - ListStyle and parts - Font Also, colors are not parsed correctly. This will be handled next.
2021-07-14 19:57:02 +01:00
return;
}
LibHTML: Implement the "margin" shorthand property This is a very bulky way of doing this, and doesn't seem sustainable to implement every shorthand property this way, but it's a place to start. The "margin" CSS property now expands into its four longhands as far as my understanding of the specs. Note that shorthand expansion happens when we *resolve* style, not when we parse CSS. I'm not sure this is correct anymore, I think other UA's may actually expand shorthands into the declaration directly at parse these days. If so, we should do this at parsing as well.
2019-11-18 11:49:19 +01:00
style.set_property(property_id, value);
}
LibWeb: Convert StyleResolver.{h,cpp} to east const
2021-07-14 16:56:11 +01:00
StyleResolver::CustomPropertyResolutionTuple StyleResolver::resolve_custom_property_with_specificity(DOM::Element& element, String const& custom_property_name) const
LibWeb: Resolve custom properties The way to get the custom properties is pretty weird and this code is as far from optimized as it gets but somehow it works :^)
2021-05-24 23:02:58 +02:00
{
LibWeb: Improve performance of CSS custom property resolution By memoizing already resolved custom properties in the DOM::Element, we achieve a notable speed increase when loading SerenityOS on GitHub.
2021-05-28 21:21:44 +02:00
if (auto maybe_property = element.resolve_custom_property(custom_property_name); maybe_property.has_value())
return maybe_property.value();
LibWeb: Resolve custom properties The way to get the custom properties is pretty weird and this code is as far from optimized as it gets but somehow it works :^)
2021-05-24 23:02:58 +02:00
auto parent_element = element.parent_element();
CustomPropertyResolutionTuple parent_resolved {};
if (parent_element)
parent_resolved = resolve_custom_property_with_specificity(*parent_element, custom_property_name);
auto matching_rules = collect_matching_rules(element);
sort_matching_rules(matching_rules);
for (int i = matching_rules.size() - 1; i >= 0; --i) {
auto& match = matching_rules[i];
if (match.specificity < parent_resolved.specificity)
continue;
auto custom_property_style = match.rule->declaration().custom_property(custom_property_name);
if (custom_property_style.has_value()) {
LibWeb: Improve performance of CSS custom property resolution By memoizing already resolved custom properties in the DOM::Element, we achieve a notable speed increase when loading SerenityOS on GitHub.
2021-05-28 21:21:44 +02:00
element.add_custom_property(custom_property_name, { custom_property_style.value(), match.specificity });
LibWeb: Resolve custom properties The way to get the custom properties is pretty weird and this code is as far from optimized as it gets but somehow it works :^)
2021-05-24 23:02:58 +02:00
return { custom_property_style.value(), match.specificity };
}
}
return parent_resolved;
}
LibWeb: Convert StyleResolver.{h,cpp} to east const
2021-07-14 16:56:11 +01:00
Optional<StyleProperty> StyleResolver::resolve_custom_property(DOM::Element& element, String const& custom_property_name) const
LibWeb: Resolve custom properties The way to get the custom properties is pretty weird and this code is as far from optimized as it gets but somehow it works :^)
2021-05-24 23:02:58 +02:00
{
auto resolved_with_specificity = resolve_custom_property_with_specificity(element, custom_property_name);
return resolved_with_specificity.style;
}
LibWeb: Improve performance of CSS custom property resolution By memoizing already resolved custom properties in the DOM::Element, we achieve a notable speed increase when loading SerenityOS on GitHub.
2021-05-28 21:21:44 +02:00
NonnullRefPtr<StyleProperties> StyleResolver::resolve_style(DOM::Element& element) const
LibHTML: Start fleshing out a StyleResolver class. This will be responsible for matching selectors and creating LayoutStyle objects for the document and its elements.
2019-06-27 17:47:59 +02:00
{
LibHTML: Rename "style_properties" to "style" everywhere
2019-10-07 09:23:53 +02:00
auto style = StyleProperties::create();
LibHTML: Implement basic style inheritance
2019-09-25 12:33:28 +03:00
LibWeb: Make DOM::Node::create_layout_node() not need parent's style The StyleResolver can find the specified CSS values for the parent element via the DOM. Forcing everyone to locate specified values for their parent was completely unnecessary.
2021-01-06 14:27:40 +01:00
if (auto* parent_style = element.parent_element() ? element.parent_element()->specified_css_values() : nullptr) {
LibHTML: Use an enum for CSS property ID's Instead of using string everywhere, have the CSS parser produce enum values, since they are a lot nicer to work with. In the future we should generate most of this code based on a list of supported CSS properties.
2019-10-08 15:34:19 +02:00
parent_style->for_each_property([&](auto property_id, auto& value) {
if (is_inherited_property(property_id))
LibWeb: Expand "background: url()" into "background-image: url()" This gives us a yellow forehead on ACID2! :^)
2020-06-10 17:47:04 +02:00
set_property_expanding_shorthands(style, property_id, value, m_document);
LibHTML: Implement basic style inheritance
2019-09-25 12:33:28 +03:00
});
}
LibHTML: Rename "style_properties" to "style" everywhere
2019-10-07 09:23:53 +02:00
element.apply_presentational_hints(*style);
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 21:05:52 +02:00
LibHTML: Implement some very simple selector matching. We walk the entire DOM and check all selectors against all elements. Only id, class and tag name are checked right now. There's no ancestor stack or compound selectors. All in good time :^)
2019-06-27 20:40:21 +02:00
auto matching_rules = collect_matching_rules(element);
LibWeb: Add a simple StyleInvalidator class This patch adds a simple, naive & inefficient class for document-wide style invalidation, e.g. after element attribute updates. During construction it collects a HashMap of a document's elements and their matching rules, during destruction it does the same and then compares the results; dirtying all elements that have a different number or order of matching rules afterwards. Much room for improvement, but it solves the problem of stale element styling after attribute updates for now :^) Fixes #4404.
2020-12-14 21:31:10 +00:00
sort_matching_rules(matching_rules);
LibWeb: Apply style rules in order of specificity (kinda) We now sort the matched rules by the specificity of the first selector in them. This is not perfect, since a rule can have multiple selectors, but it is a nice chin-related progression on ACID2. :^)
2020-06-10 16:41:30 +02:00
LibWeb: Sort matched style rules by specificity, document order If two rules have equal specificity, they should be applied in the order in which we encountered them.
2020-06-13 00:44:26 +02:00
for (auto& match : matching_rules) {
for (auto& property : match.rule->declaration().properties()) {
LibWeb: Resolve custom properties The way to get the custom properties is pretty weird and this code is as far from optimized as it gets but somehow it works :^)
2021-05-24 23:02:58 +02:00
auto property_value = property.value;
if (property.value->is_custom_property()) {
LibWeb: Convert StyleResolver.{h,cpp} to east const
2021-07-14 16:56:11 +01:00
auto prop = reinterpret_cast<CSS::CustomStyleValue const*>(property.value.ptr());
LibWeb: Resolve custom properties The way to get the custom properties is pretty weird and this code is as far from optimized as it gets but somehow it works :^)
2021-05-24 23:02:58 +02:00
auto custom_prop_name = prop->custom_property_name();
auto resolved = resolve_custom_property(element, custom_prop_name);
if (resolved.has_value()) {
property_value = resolved.value().value;
}
}
set_property_expanding_shorthands(style, property.property_id, property_value, m_document);
LibHTML: Start building the style tree. Walk the DOM and construct a parallel style tree that points back to the DOM and has the relevant CSS property values hanging off of them. The values are picked based on naive selector matching. There's no cascade or specificity taken into account yet.
2019-06-28 21:17:34 +02:00
}
}
LibHTML: Implement basic support for inline style attributes You can now style elements with inline styles: <div style="color: #ff0000">This is red!</div> Pretty neat :^)
2019-09-30 20:25:33 +02:00
LibWeb: Cache parsed inline style of DOM elements Instead of invoking the CSS parser every time we compute the style for an element that has a "style" attribute, we now cache the result of parsing the inline style whenever the "style" attribute is set. This is a nice boost to relayout performance since we no longer hit the CSS parser at all.
2020-12-07 19:56:53 +01:00
if (auto* inline_style = element.inline_style()) {
for (auto& property : inline_style->properties()) {
set_property_expanding_shorthands(style, property.property_id, property.value, m_document);
LibHTML: Implement basic support for inline style attributes You can now style elements with inline styles: <div style="color: #ff0000">This is red!</div> Pretty neat :^)
2019-09-30 20:25:33 +02:00
}
}
LibHTML: Rename "style_properties" to "style" everywhere
2019-10-07 09:23:53 +02:00
return style;
LibHTML: Start fleshing out a StyleResolver class. This will be responsible for matching selectors and creating LayoutStyle objects for the document and its elements.
2019-06-27 17:47:59 +02:00
}
LibWeb: Move everything into the Web namespace
2020-03-07 10:27:02 +01:00
}
Reference in a new issue Copy permalink