Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2026-04-18 18:00:31 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/CSS/CSSFontFaceRule.h

63 lines
2 KiB
C
Raw Permalink Normal View History

LibWeb: Implement initial CSSFontFaceRule and FontFace classes For now, this is the bare minimum that's needed: font-family and src.
2022-03-28 20:30:26 +01:00
/*
LibWeb/CSS: Parse `@font-face` descriptors as style values CSSFontFaceRule now stores its values as a CSSFontFaceDescriptors, with a ParsedFontFace produced on request. This is exposed via the `style` attribute, so we pass a lot of tests that try to read values from that. We have one test regression, which we passed by mistake before: The test wanted to ensure we don't allow `@font-face` nested inside other rules. We passed it just because we discarded any `@font-face` without a `font-family`. What we're supposed to do is 1) keep at-rules with missing required descriptors and just not use them, and 2) reject certain ones when nested. We may want to cache the ParsedFontFace in the future, but I didn't here because 1) it's called rarely, and 2) that would mean knowing to invalidate it when the CSSFontFaceDescriptors changes, which isn't obvious to me right now.
2025-04-03 12:05:49 +01:00
* Copyright (c) 2022-2025, Sam Atkins <sam@ladybird.org>
Meta: Update my e-mail address everywhere
2024-10-04 13:19:50 +02:00
* Copyright (c) 2022, Andreas Kling <andreas@ladybird.org>
LibWeb: Implement initial CSSFontFaceRule and FontFace classes For now, this is the bare minimum that's needed: font-family and src.
2022-03-28 20:30:26 +01:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
LibWeb/CSS: Parse `@font-face` descriptors as style values CSSFontFaceRule now stores its values as a CSSFontFaceDescriptors, with a ParsedFontFace produced on request. This is exposed via the `style` attribute, so we pass a lot of tests that try to read values from that. We have one test regression, which we passed by mistake before: The test wanted to ensure we don't allow `@font-face` nested inside other rules. We passed it just because we discarded any `@font-face` without a `font-family`. What we're supposed to do is 1) keep at-rules with missing required descriptors and just not use them, and 2) reject certain ones when nested. We may want to cache the ParsedFontFace in the future, but I didn't here because 1) it's called rarely, and 2) that would mean knowing to invalidate it when the CSSFontFaceDescriptors changes, which isn't obvious to me right now.
2025-04-03 12:05:49 +01:00
#include <LibWeb/CSS/CSSFontFaceDescriptors.h>
LibWeb: Implement initial CSSFontFaceRule and FontFace classes For now, this is the bare minimum that's needed: font-family and src.
2022-03-28 20:30:26 +01:00
#include <LibWeb/CSS/CSSRule.h>
LibWeb/CSS: Make `@font-face` a critical style subresource This causes `@font-face`'s loading state to propagate to its style sheet and upwards.
2026-02-23 14:31:54 +00:00
#include <LibWeb/CSS/CSSStyleSheet.h>
LibWeb: Rename CSS::FontFace to CSS::ParsedFontFace This implementation detail of CSSFontFaceRule is hogging the name of a Web API from CSS Font Loading Module Level 3.
2024-05-07 09:18:37 -06:00
#include <LibWeb/CSS/ParsedFontFace.h>
LibWeb: Implement initial CSSFontFaceRule and FontFace classes For now, this is the bare minimum that's needed: font-family and src.
2022-03-28 20:30:26 +01:00
namespace Web::CSS {
LibWeb: Disconnect and replace FontFace on @font-face src change
2026-01-05 09:50:55 +00:00
class FontFace;
LibWeb/CSS: Make `@font-face` a critical style subresource This causes `@font-face`'s loading state to propagate to its style sheet and upwards.
2026-02-23 14:31:54 +00:00
class CSSFontFaceRule final
: public CSSRule
, public CSSStyleSheet::Subresource {
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
WEB_PLATFORM_OBJECT(CSSFontFaceRule, CSSRule);
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC_DECLARE_ALLOCATOR(CSSFontFaceRule);
LibWeb: Implement initial CSSFontFaceRule and FontFace classes For now, this is the bare minimum that's needed: font-family and src.
2022-03-28 20:30:26 +01:00
public:
LibWeb/CSS: Parse `@font-face` descriptors as style values CSSFontFaceRule now stores its values as a CSSFontFaceDescriptors, with a ParsedFontFace produced on request. This is exposed via the `style` attribute, so we pass a lot of tests that try to read values from that. We have one test regression, which we passed by mistake before: The test wanted to ensure we don't allow `@font-face` nested inside other rules. We passed it just because we discarded any `@font-face` without a `font-family`. What we're supposed to do is 1) keep at-rules with missing required descriptors and just not use them, and 2) reject certain ones when nested. We may want to cache the ParsedFontFace in the future, but I didn't here because 1) it's called rarely, and 2) that would mean knowing to invalidate it when the CSSFontFaceDescriptors changes, which isn't obvious to me right now.
2025-04-03 12:05:49 +01:00
[[nodiscard]] static GC::Ref<CSSFontFaceRule> create(JS::Realm&, GC::Ref<CSSFontFaceDescriptors>);
LibWeb: Implement initial CSSFontFaceRule and FontFace classes For now, this is the bare minimum that's needed: font-family and src.
2022-03-28 20:30:26 +01:00
virtual ~CSSFontFaceRule() override = default;
LibWeb/CSS: Only attempt to load valid `@font-face` fonts These must have a `font-family` and `src` set to be included in font-matching. Otherwise they should be ignored, but still exist in the CSSOM.
2025-04-03 12:15:11 +01:00
bool is_valid() const;
LibWeb/CSS: Parse `@font-face` descriptors as style values CSSFontFaceRule now stores its values as a CSSFontFaceDescriptors, with a ParsedFontFace produced on request. This is exposed via the `style` attribute, so we pass a lot of tests that try to read values from that. We have one test regression, which we passed by mistake before: The test wanted to ensure we don't allow `@font-face` nested inside other rules. We passed it just because we discarded any `@font-face` without a `font-family`. What we're supposed to do is 1) keep at-rules with missing required descriptors and just not use them, and 2) reject certain ones when nested. We may want to cache the ParsedFontFace in the future, but I didn't here because 1) it's called rarely, and 2) that would mean knowing to invalidate it when the CSSFontFaceDescriptors changes, which isn't obvious to me right now.
2025-04-03 12:05:49 +01:00
ParsedFontFace font_face() const;
LibWeb: Dump CSSDescriptors in a generic way This replaces the need for bespoke (and verbose) dumping for each at-rule that has descriptors.
2025-05-08 14:37:25 +01:00
GC::Ref<CSSStyleDeclaration> style() { return m_style; }
LibWeb: Propagate FontFace changes to CSSFontFaceRule
2026-01-05 09:30:38 +00:00
GC::Ref<CSSFontFaceDescriptors> descriptors() { return m_style; }
LibWeb: Dump CSSDescriptors in a generic way This replaces the need for bespoke (and verbose) dumping for each at-rule that has descriptors.
2025-05-08 14:37:25 +01:00
GC::Ref<CSSFontFaceDescriptors const> descriptors() const { return m_style; }
LibWeb: Implement initial CSSFontFaceRule and FontFace classes For now, this is the bare minimum that's needed: font-family and src.
2022-03-28 20:30:26 +01:00
LibWeb: Disconnect and replace FontFace on @font-face src change
2026-01-05 09:50:55 +00:00
GC::Ptr<FontFace> css_connected_font_face() const { return m_css_connected_font_face; }
void set_css_connected_font_face(GC::Ptr<FontFace> font_face) { m_css_connected_font_face = font_face; }
LibWeb: Store updated attributes directly within `FontFace` The spec states that updates to descriptors in a `@font-face` rule should be reflected in the connected `FontFace`'s attributes. Previously this was achieved by directly accessing those descriptors when calling the attribute getters, but this has a couple of issues: a) The changes are only reflected if we use the accessors (i.e. `FontFace::family()` rather than `FontFace::m_family`) which isn't the case everywhere b) The changes aren't persisted after the `FontFace` is disconnected from it's `CSSFontFaceRule` To fix these issues we now reparse and store the `FontFace`'s attributes whenever the `CSSFontFaceRule`'s descriptors change.
2026-01-10 16:23:23 +13:00
void handle_descriptor_change(FlyString const& property);
LibWeb: Mark FontFace as CSS-disconnected when font-face rule is removed
2026-01-05 10:08:52 +00:00
void disconnect_font_face();
LibWeb: Disconnect and replace FontFace on @font-face src change
2026-01-05 09:50:55 +00:00
LibWeb: Implement initial CSSFontFaceRule and FontFace classes For now, this is the bare minimum that's needed: font-family and src.
2022-03-28 20:30:26 +01:00
private:
LibWeb/CSS: Parse `@font-face` descriptors as style values CSSFontFaceRule now stores its values as a CSSFontFaceDescriptors, with a ParsedFontFace produced on request. This is exposed via the `style` attribute, so we pass a lot of tests that try to read values from that. We have one test regression, which we passed by mistake before: The test wanted to ensure we don't allow `@font-face` nested inside other rules. We passed it just because we discarded any `@font-face` without a `font-family`. What we're supposed to do is 1) keep at-rules with missing required descriptors and just not use them, and 2) reject certain ones when nested. We may want to cache the ParsedFontFace in the future, but I didn't here because 1) it's called rarely, and 2) that would mean knowing to invalidate it when the CSSFontFaceDescriptors changes, which isn't obvious to me right now.
2025-04-03 12:05:49 +01:00
CSSFontFaceRule(JS::Realm&, GC::Ref<CSSFontFaceDescriptors>);
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
LibJS: Make Cell::initialize() return void Stop worrying about tiny OOMs. Work towards #20405
2023-08-07 08:41:28 +02:00
virtual void initialize(JS::Realm&) override;
LibWeb: Port CSSRule::serialized from DeprecatedString to String
2023-11-20 23:16:39 +13:00
virtual String serialized() const override;
LibWeb/CSS: Parse `@font-face` descriptors as style values CSSFontFaceRule now stores its values as a CSSFontFaceDescriptors, with a ParsedFontFace produced on request. This is exposed via the `style` attribute, so we pass a lot of tests that try to read values from that. We have one test regression, which we passed by mistake before: The test wanted to ensure we don't allow `@font-face` nested inside other rules. We passed it just because we discarded any `@font-face` without a `font-family`. What we're supposed to do is 1) keep at-rules with missing required descriptors and just not use them, and 2) reject certain ones when nested. We may want to cache the ParsedFontFace in the future, but I didn't here because 1) it's called rarely, and 2) that would mean knowing to invalidate it when the CSSFontFaceDescriptors changes, which isn't obvious to me right now.
2025-04-03 12:05:49 +01:00
virtual void visit_edges(Visitor&) override;
LibWeb: Move CSSRule dumping code into CSSRule classes Having the dumping code in a separate Dump.cpp meant that it was often overlooked when the rules gained new features, and also limits dumping to publicly-accessible information.
2025-12-04 12:03:01 +00:00
virtual void dump(StringBuilder&, int indent_levels) const override;
LibWeb: Implement initial CSSFontFaceRule and FontFace classes For now, this is the bare minimum that's needed: font-family and src.
2022-03-28 20:30:26 +01:00
LibWeb: Store updated attributes directly within `FontFace` The spec states that updates to descriptors in a `@font-face` rule should be reflected in the connected `FontFace`'s attributes. Previously this was achieved by directly accessing those descriptors when calling the attribute getters, but this has a couple of issues: a) The changes are only reflected if we use the accessors (i.e. `FontFace::family()` rather than `FontFace::m_family`) which isn't the case everywhere b) The changes aren't persisted after the `FontFace` is disconnected from it's `CSSFontFaceRule` To fix these issues we now reparse and store the `FontFace`'s attributes whenever the `CSSFontFaceRule`'s descriptors change.
2026-01-10 16:23:23 +13:00
void handle_src_descriptor_change();
LibWeb/CSS: Make `@font-face` a critical style subresource This causes `@font-face`'s loading state to propagate to its style sheet and upwards.
2026-02-23 14:31:54 +00:00
virtual void set_parent_style_sheet(CSSStyleSheet*) override;
GC::Ptr<CSSStyleSheet> parent_style_sheet_for_subresource() override { return parent_style_sheet(); }
LibWeb/CSS: Parse `@font-face` descriptors as style values CSSFontFaceRule now stores its values as a CSSFontFaceDescriptors, with a ParsedFontFace produced on request. This is exposed via the `style` attribute, so we pass a lot of tests that try to read values from that. We have one test regression, which we passed by mistake before: The test wanted to ensure we don't allow `@font-face` nested inside other rules. We passed it just because we discarded any `@font-face` without a `font-family`. What we're supposed to do is 1) keep at-rules with missing required descriptors and just not use them, and 2) reject certain ones when nested. We may want to cache the ParsedFontFace in the future, but I didn't here because 1) it's called rarely, and 2) that would mean knowing to invalidate it when the CSSFontFaceDescriptors changes, which isn't obvious to me right now.
2025-04-03 12:05:49 +01:00
GC::Ref<CSSFontFaceDescriptors> m_style;
LibWeb: Disconnect and replace FontFace on @font-face src change
2026-01-05 09:50:55 +00:00
GC::Ptr<FontFace> m_css_connected_font_face;
LibWeb: Implement initial CSSFontFaceRule and FontFace classes For now, this is the bare minimum that's needed: font-family and src.
2022-03-28 20:30:26 +01:00
};
template<>
inline bool CSSRule::fast_is<CSSFontFaceRule>() const { return type() == CSSRule::Type::FontFace; }
}
Reference in a new issue Copy permalink