Everywhere: Hoist the Libraries folder to the top-level

Author: https://github.com/trflynn89 Commit: 93712b24bf Pull-request: https://github.com/LadybirdBrowser/ladybird/pull/2256 Reviewed-by: https://github.com/sideshowbarker
2025-08-27 12:46:06 +00:00 · 2024-11-09 12:25:08 -05:00 · 2024-11-09 12:25:08 -05:00 · 93712b24bf · 2024-11-10 11:51:52 +00:00
commit 93712b24bf
parent 950e819ee7
4547 changed files with 104 additions and 113 deletions
--- a/Libraries/LibWeb/CSS/MediaQuery.h
+++ b/Libraries/LibWeb/CSS/MediaQuery.h
@ -0,0 +1,290 @@
+/*
+ * Copyright (c) 2021-2023, Sam Atkins <atkinssj@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/NonnullRefPtr.h>
+#include <AK/Optional.h>
+#include <AK/OwnPtr.h>
+#include <AK/RefCounted.h>
+#include <LibWeb/CSS/GeneralEnclosed.h>
+#include <LibWeb/CSS/Length.h>
+#include <LibWeb/CSS/MediaFeatureID.h>
+#include <LibWeb/CSS/Ratio.h>
+#include <LibWeb/CSS/Resolution.h>
+
+namespace Web::CSS {
+
+// https://www.w3.org/TR/mediaqueries-4/#typedef-mf-value
+class MediaFeatureValue {
+public:
+    explicit MediaFeatureValue(Keyword ident)
+        : m_value(move(ident))
+    {
+    }
+
+    explicit MediaFeatureValue(Length length)
+        : m_value(move(length))
+    {
+    }
+
+    explicit MediaFeatureValue(Ratio ratio)
+        : m_value(move(ratio))
+    {
+    }
+
+    explicit MediaFeatureValue(Resolution resolution)
+        : m_value(move(resolution))
+    {
+    }
+
+    explicit MediaFeatureValue(float number)
+        : m_value(number)
+    {
+    }
+
+    String to_string() const;
+
+    bool is_ident() const { return m_value.has<Keyword>(); }
+    bool is_length() const { return m_value.has<Length>(); }
+    bool is_number() const { return m_value.has<float>(); }
+    bool is_ratio() const { return m_value.has<Ratio>(); }
+    bool is_resolution() const { return m_value.has<Resolution>(); }
+    bool is_same_type(MediaFeatureValue const& other) const;
+
+    Keyword const& ident() const
+    {
+        VERIFY(is_ident());
+        return m_value.get<Keyword>();
+    }
+
+    Length const& length() const
+    {
+        VERIFY(is_length());
+        return m_value.get<Length>();
+    }
+
+    Ratio const& ratio() const
+    {
+        VERIFY(is_ratio());
+        return m_value.get<Ratio>();
+    }
+
+    Resolution const& resolution() const
+    {
+        VERIFY(is_resolution());
+        return m_value.get<Resolution>();
+    }
+
+    float number() const
+    {
+        VERIFY(is_number());
+        return m_value.get<float>();
+    }
+
+private:
+    Variant<Keyword, Length, Ratio, Resolution, float> m_value;
+};
+
+// https://www.w3.org/TR/mediaqueries-4/#mq-features
+class MediaFeature {
+public:
+    enum class Comparison {
+        Equal,
+        LessThan,
+        LessThanOrEqual,
+        GreaterThan,
+        GreaterThanOrEqual,
+    };
+
+    // Corresponds to `<mf-boolean>` grammar
+    static MediaFeature boolean(MediaFeatureID id)
+    {
+        return MediaFeature(Type::IsTrue, id);
+    }
+
+    // Corresponds to `<mf-plain>` grammar
+    static MediaFeature plain(MediaFeatureID id, MediaFeatureValue value)
+    {
+        return MediaFeature(Type::ExactValue, move(id), move(value));
+    }
+    static MediaFeature min(MediaFeatureID id, MediaFeatureValue value)
+    {
+        return MediaFeature(Type::MinValue, id, move(value));
+    }
+    static MediaFeature max(MediaFeatureID id, MediaFeatureValue value)
+    {
+        return MediaFeature(Type::MaxValue, id, move(value));
+    }
+
+    // Corresponds to `<mf-range>` grammar, with a single comparison
+    static MediaFeature half_range(MediaFeatureValue value, Comparison comparison, MediaFeatureID id)
+    {
+        MediaFeature feature { Type::Range, id };
+        feature.m_range = Range {
+            .left_value = value,
+            .left_comparison = comparison,
+        };
+        return feature;
+    }
+
+    // Corresponds to `<mf-range>` grammar, with two comparisons
+    static MediaFeature range(MediaFeatureValue left_value, Comparison left_comparison, MediaFeatureID id, Comparison right_comparison, MediaFeatureValue right_value)
+    {
+        MediaFeature feature { Type::Range, id };
+        feature.m_range = Range {
+            .left_value = left_value,
+            .left_comparison = left_comparison,
+            .right_comparison = right_comparison,
+            .right_value = right_value,
+        };
+        return feature;
+    }
+
+    bool evaluate(HTML::Window const&) const;
+    String to_string() const;
+
+private:
+    enum class Type {
+        IsTrue,
+        ExactValue,
+        MinValue,
+        MaxValue,
+        Range,
+    };
+
+    MediaFeature(Type type, MediaFeatureID id, Optional<MediaFeatureValue> value = {})
+        : m_type(type)
+        , m_id(move(id))
+        , m_value(move(value))
+    {
+    }
+
+    static bool compare(HTML::Window const& window, MediaFeatureValue left, Comparison comparison, MediaFeatureValue right);
+
+    struct Range {
+        MediaFeatureValue left_value;
+        Comparison left_comparison;
+        Optional<Comparison> right_comparison {};
+        Optional<MediaFeatureValue> right_value {};
+    };
+
+    Type m_type;
+    MediaFeatureID m_id;
+    Optional<MediaFeatureValue> m_value {};
+    Optional<Range> m_range {};
+};
+
+// https://www.w3.org/TR/mediaqueries-4/#media-conditions
+struct MediaCondition {
+    enum class Type {
+        Single,
+        And,
+        Or,
+        Not,
+        GeneralEnclosed,
+    };
+
+    // Only used in parsing
+    enum class AllowOr {
+        No = 0,
+        Yes = 1,
+    };
+
+    static NonnullOwnPtr<MediaCondition> from_general_enclosed(GeneralEnclosed&&);
+    static NonnullOwnPtr<MediaCondition> from_feature(MediaFeature&&);
+    static NonnullOwnPtr<MediaCondition> from_not(NonnullOwnPtr<MediaCondition>&&);
+    static NonnullOwnPtr<MediaCondition> from_and_list(Vector<NonnullOwnPtr<MediaCondition>>&&);
+    static NonnullOwnPtr<MediaCondition> from_or_list(Vector<NonnullOwnPtr<MediaCondition>>&&);
+
+    MatchResult evaluate(HTML::Window const&) const;
+    String to_string() const;
+
+private:
+    MediaCondition() = default;
+    Type type;
+    Optional<MediaFeature> feature;
+    Vector<NonnullOwnPtr<MediaCondition>> conditions;
+    Optional<GeneralEnclosed> general_enclosed;
+};
+
+class MediaQuery : public RefCounted<MediaQuery> {
+    friend class Parser::Parser;
+
+public:
+    ~MediaQuery() = default;
+
+    // https://www.w3.org/TR/mediaqueries-4/#media-types
+    enum class MediaType {
+        All,
+        Print,
+        Screen,
+        Unknown,
+
+        // Deprecated, must never match:
+        TTY,
+        TV,
+        Projection,
+        Handheld,
+        Braille,
+        Embossed,
+        Aural,
+        Speech,
+    };
+
+    static NonnullRefPtr<MediaQuery> create_not_all();
+    static NonnullRefPtr<MediaQuery> create() { return adopt_ref(*new MediaQuery); }
+
+    bool matches() const { return m_matches; }
+    bool evaluate(HTML::Window const&);
+    String to_string() const;
+
+private:
+    MediaQuery() = default;
+
+    // https://www.w3.org/TR/mediaqueries-4/#mq-not
+    bool m_negated { false };
+    MediaType m_media_type { MediaType::All };
+    OwnPtr<MediaCondition> m_media_condition { nullptr };
+
+    // Cached value, updated by evaluate()
+    bool m_matches { false };
+};
+
+String serialize_a_media_query_list(Vector<NonnullRefPtr<MediaQuery>> const&);
+
+MediaQuery::MediaType media_type_from_string(StringView);
+StringView to_string(MediaQuery::MediaType);
+
+}
+
+namespace AK {
+
+template<>
+struct Formatter<Web::CSS::MediaFeature> : Formatter<StringView> {
+    ErrorOr<void> format(FormatBuilder& builder, Web::CSS::MediaFeature const& media_feature)
+    {
+        return Formatter<StringView>::format(builder, media_feature.to_string());
+    }
+};
+
+template<>
+struct Formatter<Web::CSS::MediaCondition> : Formatter<StringView> {
+    ErrorOr<void> format(FormatBuilder& builder, Web::CSS::MediaCondition const& media_condition)
+    {
+        return Formatter<StringView>::format(builder, media_condition.to_string());
+    }
+};
+
+template<>
+struct Formatter<Web::CSS::MediaQuery> : Formatter<StringView> {
+    ErrorOr<void> format(FormatBuilder& builder, Web::CSS::MediaQuery const& media_query)
+    {
+        return Formatter<StringView>::format(builder, media_query.to_string());
+    }
+};
+
+}