2020-08-01 03:05:43 +01:00
|
|
|
/*
|
2021-04-28 22:46:44 +02:00
|
|
|
* Copyright (c) 2020, the SerenityOS developers.
|
2024-07-13 00:25:04 +01:00
|
|
|
* Copyright (c) 2024, Jamie Mansfield <jmansfield@cadixdev.org>
|
2020-08-01 03:05:43 +01:00
|
|
|
*
|
2021-04-22 01:24:48 -07:00
|
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
2020-08-01 03:05:43 +01:00
|
|
|
*/
|
|
|
|
|
2024-04-27 12:09:58 +12:00
|
|
|
#include <LibWeb/Bindings/HTMLMarqueeElementPrototype.h>
|
2022-09-30 17:16:16 -06:00
|
|
|
#include <LibWeb/Bindings/Intrinsics.h>
|
2024-12-20 11:32:17 +01:00
|
|
|
#include <LibWeb/CSS/ComputedProperties.h>
|
2025-08-08 11:24:15 +01:00
|
|
|
#include <LibWeb/CSS/StyleValues/ColorStyleValue.h>
|
2020-08-01 03:05:43 +01:00
|
|
|
#include <LibWeb/HTML/HTMLMarqueeElement.h>
|
2024-07-13 00:25:04 +01:00
|
|
|
#include <LibWeb/HTML/Numbers.h>
|
2023-05-28 15:06:12 +12:00
|
|
|
#include <LibWeb/HTML/Parser/HTMLParser.h>
|
2020-08-01 03:05:43 +01:00
|
|
|
|
|
|
|
namespace Web::HTML {
|
|
|
|
|
2024-11-15 04:01:23 +13:00
|
|
|
GC_DEFINE_ALLOCATOR(HTMLMarqueeElement);
|
2023-11-19 19:47:52 +01:00
|
|
|
|
2022-02-18 21:00:52 +01:00
|
|
|
HTMLMarqueeElement::HTMLMarqueeElement(DOM::Document& document, DOM::QualifiedName qualified_name)
|
2021-02-07 11:20:15 +01:00
|
|
|
: HTMLElement(document, move(qualified_name))
|
2020-08-01 03:05:43 +01:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2022-03-14 13:21:51 -06:00
|
|
|
HTMLMarqueeElement::~HTMLMarqueeElement() = default;
|
2020-08-01 03:05:43 +01:00
|
|
|
|
2023-08-07 08:41:28 +02:00
|
|
|
void HTMLMarqueeElement::initialize(JS::Realm& realm)
|
2023-01-10 06:28:20 -05:00
|
|
|
{
|
2024-03-16 13:13:08 +01:00
|
|
|
WEB_SET_PROTOTYPE_FOR_INTERFACE(HTMLMarqueeElement);
|
2025-04-20 16:22:57 +02:00
|
|
|
Base::initialize(realm);
|
2023-01-10 06:28:20 -05:00
|
|
|
}
|
|
|
|
|
2024-12-23 17:51:10 +01:00
|
|
|
bool HTMLMarqueeElement::is_presentational_hint(FlyString const& name) const
|
|
|
|
{
|
|
|
|
if (Base::is_presentational_hint(name))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return first_is_one_of(name,
|
|
|
|
HTML::AttributeNames::bgcolor,
|
|
|
|
HTML::AttributeNames::height,
|
|
|
|
HTML::AttributeNames::hspace,
|
|
|
|
HTML::AttributeNames::vspace,
|
|
|
|
HTML::AttributeNames::width);
|
|
|
|
}
|
|
|
|
|
LibWeb: Split StyleComputer work into two phases with separate outputs
Before this change, StyleComputer would essentially take a DOM element,
find all the CSS rules that apply to it, and resolve the computed value
for each CSS property for that element.
This worked great, but it meant we had to do all the work of selector
matching and cascading every time.
To enable new optimizations, this change introduces a break in the
middle of this process where we've produced a "CascadedProperties".
This object contains the result of the cascade, before we've begun
turning cascaded values into computed values.
The cascaded properties are now stored with each element, which will
later allow us to do partial updates without re-running the full
StyleComputer machine. This will be particularly valuable for
re-implementing CSS inheritance, which is extremely heavy today.
Note that CSS animations and CSS transitions operate entirely on the
computed values, even though the cascade order would have you believe
they happen earlier. I'm not confident we have the right architecture
for this, but that's a separate issue.
2024-12-12 10:06:29 +01:00
|
|
|
void HTMLMarqueeElement::apply_presentational_hints(GC::Ref<CSS::CascadedProperties> cascaded_properties) const
|
2021-02-10 09:54:16 +01:00
|
|
|
{
|
LibWeb: Split StyleComputer work into two phases with separate outputs
Before this change, StyleComputer would essentially take a DOM element,
find all the CSS rules that apply to it, and resolve the computed value
for each CSS property for that element.
This worked great, but it meant we had to do all the work of selector
matching and cascading every time.
To enable new optimizations, this change introduces a break in the
middle of this process where we've produced a "CascadedProperties".
This object contains the result of the cascade, before we've begun
turning cascaded values into computed values.
The cascaded properties are now stored with each element, which will
later allow us to do partial updates without re-running the full
StyleComputer machine. This will be particularly valuable for
re-implementing CSS inheritance, which is extremely heavy today.
Note that CSS animations and CSS transitions operate entirely on the
computed values, even though the cascade order would have you believe
they happen earlier. I'm not confident we have the right architecture
for this, but that's a separate issue.
2024-12-12 10:06:29 +01:00
|
|
|
HTMLElement::apply_presentational_hints(cascaded_properties);
|
2021-02-10 09:54:16 +01:00
|
|
|
for_each_attribute([&](auto& name, auto& value) {
|
|
|
|
if (name == HTML::AttributeNames::bgcolor) {
|
2023-05-28 15:06:12 +12:00
|
|
|
// https://html.spec.whatwg.org/multipage/rendering.html#the-marquee-element-2:rules-for-parsing-a-legacy-colour-value
|
|
|
|
auto color = parse_legacy_color_value(value);
|
2021-02-10 09:54:16 +01:00
|
|
|
if (color.has_value())
|
2025-08-08 11:24:15 +01:00
|
|
|
cascaded_properties->set_property_from_presentational_hint(CSS::PropertyID::BackgroundColor, CSS::ColorStyleValue::create_from_color(color.value(), CSS::ColorSyntax::Legacy));
|
2024-10-01 17:23:34 +01:00
|
|
|
} else if (name == HTML::AttributeNames::height) {
|
|
|
|
// https://html.spec.whatwg.org/multipage/rendering.html#the-marquee-element-2:maps-to-the-dimension-property
|
|
|
|
if (auto parsed_value = parse_dimension_value(value)) {
|
LibWeb: Split StyleComputer work into two phases with separate outputs
Before this change, StyleComputer would essentially take a DOM element,
find all the CSS rules that apply to it, and resolve the computed value
for each CSS property for that element.
This worked great, but it meant we had to do all the work of selector
matching and cascading every time.
To enable new optimizations, this change introduces a break in the
middle of this process where we've produced a "CascadedProperties".
This object contains the result of the cascade, before we've begun
turning cascaded values into computed values.
The cascaded properties are now stored with each element, which will
later allow us to do partial updates without re-running the full
StyleComputer machine. This will be particularly valuable for
re-implementing CSS inheritance, which is extremely heavy today.
Note that CSS animations and CSS transitions operate entirely on the
computed values, even though the cascade order would have you believe
they happen earlier. I'm not confident we have the right architecture
for this, but that's a separate issue.
2024-12-12 10:06:29 +01:00
|
|
|
cascaded_properties->set_property_from_presentational_hint(CSS::PropertyID::Height, *parsed_value);
|
2024-10-01 17:23:34 +01:00
|
|
|
}
|
|
|
|
} else if (name == HTML::AttributeNames::hspace) {
|
|
|
|
if (auto parsed_value = parse_dimension_value(value)) {
|
LibWeb: Split StyleComputer work into two phases with separate outputs
Before this change, StyleComputer would essentially take a DOM element,
find all the CSS rules that apply to it, and resolve the computed value
for each CSS property for that element.
This worked great, but it meant we had to do all the work of selector
matching and cascading every time.
To enable new optimizations, this change introduces a break in the
middle of this process where we've produced a "CascadedProperties".
This object contains the result of the cascade, before we've begun
turning cascaded values into computed values.
The cascaded properties are now stored with each element, which will
later allow us to do partial updates without re-running the full
StyleComputer machine. This will be particularly valuable for
re-implementing CSS inheritance, which is extremely heavy today.
Note that CSS animations and CSS transitions operate entirely on the
computed values, even though the cascade order would have you believe
they happen earlier. I'm not confident we have the right architecture
for this, but that's a separate issue.
2024-12-12 10:06:29 +01:00
|
|
|
cascaded_properties->set_property_from_presentational_hint(CSS::PropertyID::MarginLeft, *parsed_value);
|
|
|
|
cascaded_properties->set_property_from_presentational_hint(CSS::PropertyID::MarginRight, *parsed_value);
|
2024-10-01 17:23:34 +01:00
|
|
|
}
|
|
|
|
} else if (name == HTML::AttributeNames::vspace) {
|
|
|
|
if (auto parsed_value = parse_dimension_value(value)) {
|
LibWeb: Split StyleComputer work into two phases with separate outputs
Before this change, StyleComputer would essentially take a DOM element,
find all the CSS rules that apply to it, and resolve the computed value
for each CSS property for that element.
This worked great, but it meant we had to do all the work of selector
matching and cascading every time.
To enable new optimizations, this change introduces a break in the
middle of this process where we've produced a "CascadedProperties".
This object contains the result of the cascade, before we've begun
turning cascaded values into computed values.
The cascaded properties are now stored with each element, which will
later allow us to do partial updates without re-running the full
StyleComputer machine. This will be particularly valuable for
re-implementing CSS inheritance, which is extremely heavy today.
Note that CSS animations and CSS transitions operate entirely on the
computed values, even though the cascade order would have you believe
they happen earlier. I'm not confident we have the right architecture
for this, but that's a separate issue.
2024-12-12 10:06:29 +01:00
|
|
|
cascaded_properties->set_property_from_presentational_hint(CSS::PropertyID::MarginTop, *parsed_value);
|
|
|
|
cascaded_properties->set_property_from_presentational_hint(CSS::PropertyID::MarginBottom, *parsed_value);
|
2024-10-01 17:23:34 +01:00
|
|
|
}
|
|
|
|
} else if (name == HTML::AttributeNames::width) {
|
|
|
|
if (auto parsed_value = parse_dimension_value(value)) {
|
LibWeb: Split StyleComputer work into two phases with separate outputs
Before this change, StyleComputer would essentially take a DOM element,
find all the CSS rules that apply to it, and resolve the computed value
for each CSS property for that element.
This worked great, but it meant we had to do all the work of selector
matching and cascading every time.
To enable new optimizations, this change introduces a break in the
middle of this process where we've produced a "CascadedProperties".
This object contains the result of the cascade, before we've begun
turning cascaded values into computed values.
The cascaded properties are now stored with each element, which will
later allow us to do partial updates without re-running the full
StyleComputer machine. This will be particularly valuable for
re-implementing CSS inheritance, which is extremely heavy today.
Note that CSS animations and CSS transitions operate entirely on the
computed values, even though the cascade order would have you believe
they happen earlier. I'm not confident we have the right architecture
for this, but that's a separate issue.
2024-12-12 10:06:29 +01:00
|
|
|
cascaded_properties->set_property_from_presentational_hint(CSS::PropertyID::Width, *parsed_value);
|
2024-10-01 17:23:34 +01:00
|
|
|
}
|
2021-02-10 09:54:16 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2024-07-13 00:25:04 +01:00
|
|
|
// https://html.spec.whatwg.org/multipage/obsolete.html#dom-marquee-scrollamount
|
|
|
|
WebIDL::UnsignedLong HTMLMarqueeElement::scroll_amount()
|
|
|
|
{
|
|
|
|
// The scrollAmount IDL attribute must reflect the scrollamount content attribute. The default value is 6.
|
|
|
|
if (auto scroll_amount_string = get_attribute(HTML::AttributeNames::scrollamount); scroll_amount_string.has_value()) {
|
2024-11-26 20:40:48 +00:00
|
|
|
if (auto scroll_amount = parse_non_negative_integer(*scroll_amount_string); scroll_amount.has_value() && *scroll_amount <= 2147483647)
|
2024-07-13 00:25:04 +01:00
|
|
|
return *scroll_amount;
|
|
|
|
}
|
|
|
|
return 6;
|
|
|
|
}
|
|
|
|
|
|
|
|
// https://html.spec.whatwg.org/multipage/obsolete.html#dom-marquee-scrollamount
|
|
|
|
WebIDL::ExceptionOr<void> HTMLMarqueeElement::set_scroll_amount(WebIDL::UnsignedLong value)
|
|
|
|
{
|
2024-11-26 20:40:48 +00:00
|
|
|
if (value > 2147483647)
|
|
|
|
value = 6;
|
2024-10-14 10:05:01 +02:00
|
|
|
return set_attribute(HTML::AttributeNames::scrollamount, String::number(value));
|
2024-07-13 00:25:04 +01:00
|
|
|
}
|
|
|
|
|
2024-07-13 00:33:26 +01:00
|
|
|
// https://html.spec.whatwg.org/multipage/obsolete.html#dom-marquee-scrolldelay
|
|
|
|
WebIDL::UnsignedLong HTMLMarqueeElement::scroll_delay()
|
|
|
|
{
|
|
|
|
// The scrollDelay IDL attribute must reflect the scrolldelay content attribute. The default value is 85.
|
|
|
|
if (auto scroll_delay_string = get_attribute(HTML::AttributeNames::scrolldelay); scroll_delay_string.has_value()) {
|
2024-11-26 20:40:48 +00:00
|
|
|
if (auto scroll_delay = parse_non_negative_integer(*scroll_delay_string); scroll_delay.has_value() && *scroll_delay <= 2147483647)
|
2024-07-13 00:33:26 +01:00
|
|
|
return *scroll_delay;
|
|
|
|
}
|
|
|
|
return 85;
|
|
|
|
}
|
|
|
|
|
|
|
|
// https://html.spec.whatwg.org/multipage/obsolete.html#dom-marquee-scrolldelay
|
|
|
|
WebIDL::ExceptionOr<void> HTMLMarqueeElement::set_scroll_delay(WebIDL::UnsignedLong value)
|
|
|
|
{
|
2024-11-26 20:40:48 +00:00
|
|
|
if (value > 2147483647)
|
|
|
|
value = 85;
|
2024-10-14 10:05:01 +02:00
|
|
|
return set_attribute(HTML::AttributeNames::scrolldelay, String::number(value));
|
2024-07-13 00:33:26 +01:00
|
|
|
}
|
|
|
|
|
2020-08-01 03:05:43 +01:00
|
|
|
}
|