LibWeb: Split LinearGradientStyleValue out of StyleValue.{h,cpp}

Userland/Libraries/LibWeb/CMakeLists.txt

@@ -85,6 +85,7 @@ set(SOURCES
     CSS/StyleValues/GridTrackSizeStyleValue.cpp
     CSS/StyleValues/IdentifierStyleValue.cpp
     CSS/StyleValues/ImageStyleValue.cpp
+    CSS/StyleValues/LinearGradientStyleValue.cpp
     CSS/Supports.cpp
     CSS/SyntaxHighlighter/SyntaxHighlighter.cpp
     CSS/Time.cpp

Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp

@@ -51,6 +51,7 @@
 #include <LibWeb/CSS/StyleValues/GridTrackSizeStyleValue.h>
 #include <LibWeb/CSS/StyleValues/IdentifierStyleValue.h>
 #include <LibWeb/CSS/StyleValues/ImageStyleValue.h>
+#include <LibWeb/CSS/StyleValues/LinearGradientStyleValue.h>
 #include <LibWeb/DOM/Document.h>
 #include <LibWeb/Dump.h>
 #include <LibWeb/Infra/Strings.h>

Userland/Libraries/LibWeb/CSS/StyleValue.cpp

@@ -33,6 +33,7 @@
 #include <LibWeb/CSS/StyleValues/GridTrackSizeStyleValue.h>
 #include <LibWeb/CSS/StyleValues/IdentifierStyleValue.h>
 #include <LibWeb/CSS/StyleValues/ImageStyleValue.h>
+#include <LibWeb/CSS/StyleValues/LinearGradientStyleValue.h>
 #include <LibWeb/DOM/Document.h>
 #include <LibWeb/HTML/BrowsingContext.h>
 #include <LibWeb/Loader/LoadRequest.h>
@@ -1055,110 +1056,6 @@ static ErrorOr<void> serialize_color_stop_list(StringBuilder& builder, auto cons
     return {};
 }
 
-ErrorOr<String> LinearGradientStyleValue::to_string() const
-{
-    StringBuilder builder;
-    auto side_or_corner_to_string = [](SideOrCorner value) {
-        switch (value) {
-        case SideOrCorner::Top:
-            return "top"sv;
-        case SideOrCorner::Bottom:
-            return "bottom"sv;
-        case SideOrCorner::Left:
-            return "left"sv;
-        case SideOrCorner::Right:
-            return "right"sv;
-        case SideOrCorner::TopLeft:
-            return "top left"sv;
-        case SideOrCorner::TopRight:
-            return "top right"sv;
-        case SideOrCorner::BottomLeft:
-            return "bottom left"sv;
-        case SideOrCorner::BottomRight:
-            return "bottom right"sv;
-        default:
-            VERIFY_NOT_REACHED();
-        }
-    };
-
-    if (m_properties.gradient_type == GradientType::WebKit)
-        TRY(builder.try_append("-webkit-"sv));
-    if (is_repeating())
-        TRY(builder.try_append("repeating-"sv));
-    TRY(builder.try_append("linear-gradient("sv));
-    TRY(m_properties.direction.visit(
-        [&](SideOrCorner side_or_corner) -> ErrorOr<void> {
-            return builder.try_appendff("{}{}, "sv, m_properties.gradient_type == GradientType::Standard ? "to "sv : ""sv, side_or_corner_to_string(side_or_corner));
-        },
-        [&](Angle const& angle) -> ErrorOr<void> {
-            return builder.try_appendff("{}, "sv, TRY(angle.to_string()));
-        }));
-
-    TRY(serialize_color_stop_list(builder, m_properties.color_stop_list));
-    TRY(builder.try_append(")"sv));
-    return builder.to_string();
-}
-
-bool LinearGradientStyleValue::equals(StyleValue const& other_) const
-{
-    if (type() != other_.type())
-        return false;
-    auto& other = other_.as_linear_gradient();
-    return m_properties == other.m_properties;
-}
-
-float LinearGradientStyleValue::angle_degrees(CSSPixelSize gradient_size) const
-{
-    auto corner_angle_degrees = [&] {
-        return static_cast<float>(atan2(gradient_size.height().value(), gradient_size.width().value())) * 180 / AK::Pi<float>;
-    };
-    return m_properties.direction.visit(
-        [&](SideOrCorner side_or_corner) {
-            auto angle = [&] {
-                switch (side_or_corner) {
-                case SideOrCorner::Top:
-                    return 0.0f;
-                case SideOrCorner::Bottom:
-                    return 180.0f;
-                case SideOrCorner::Left:
-                    return 270.0f;
-                case SideOrCorner::Right:
-                    return 90.0f;
-                case SideOrCorner::TopRight:
-                    return corner_angle_degrees();
-                case SideOrCorner::BottomLeft:
-                    return corner_angle_degrees() + 180.0f;
-                case SideOrCorner::TopLeft:
-                    return -corner_angle_degrees();
-                case SideOrCorner::BottomRight:
-                    return -(corner_angle_degrees() + 180.0f);
-                default:
-                    VERIFY_NOT_REACHED();
-                }
-            }();
-            // Note: For unknowable reasons the angles are opposite on the -webkit- version
-            if (m_properties.gradient_type == GradientType::WebKit)
-                return angle + 180.0f;
-            return angle;
-        },
-        [&](Angle const& angle) {
-            return angle.to_degrees();
-        });
-}
-
-void LinearGradientStyleValue::resolve_for_size(Layout::Node const& node, CSSPixelSize size) const
-{
-    if (m_resolved.has_value() && m_resolved->size == size)
-        return;
-    m_resolved = ResolvedData { Painting::resolve_linear_gradient_data(node, size, *this), size };
-}
-
-void LinearGradientStyleValue::paint(PaintContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering) const
-{
-    VERIFY(m_resolved.has_value());
-    Painting::paint_linear_gradient(context, dest_rect, m_resolved->data);
-}
-
 CSSPixelPoint PositionValue::resolved(Layout::Node const& node, CSSPixelRect const& rect) const
 {
     // Note: A preset + a none default x/y_relative_to is impossible in the syntax (and makes little sense)

Userland/Libraries/LibWeb/CSS/StyleValue.h

@@ -63,18 +63,6 @@ enum class FlexBasis {
     Auto,
 };
 
-// Note: The sides must be before the corners in this enum (as this order is used in parsing).
-enum class SideOrCorner {
-    Top,
-    Bottom,
-    Left,
-    Right,
-    TopLeft,
-    TopRight,
-    BottomLeft,
-    BottomRight
-};
-
 template<typename TPosition>
 struct ColorStopListElement {
     using PositionType = TPosition;
@@ -759,62 +747,6 @@ private:
     mutable Optional<ResolvedData> m_resolved;
 };
 
-class LinearGradientStyleValue final : public AbstractImageStyleValue {
-public:
-    using GradientDirection = Variant<Angle, SideOrCorner>;
-
-    enum class GradientType {
-        Standard,
-        WebKit
-    };
-
-    static ValueComparingNonnullRefPtr<LinearGradientStyleValue> create(GradientDirection direction, Vector<LinearColorStopListElement> color_stop_list, GradientType type, GradientRepeating repeating)
-    {
-        VERIFY(color_stop_list.size() >= 2);
-        return adopt_ref(*new LinearGradientStyleValue(direction, move(color_stop_list), type, repeating));
-    }
-
-    virtual ErrorOr<String> to_string() const override;
-    virtual ~LinearGradientStyleValue() override = default;
-    virtual bool equals(StyleValue const& other) const override;
-
-    Vector<LinearColorStopListElement> const& color_stop_list() const
-    {
-        return m_properties.color_stop_list;
-    }
-
-    bool is_repeating() const { return m_properties.repeating == GradientRepeating::Yes; }
-
-    float angle_degrees(CSSPixelSize gradient_size) const;
-
-    void resolve_for_size(Layout::Node const&, CSSPixelSize) const override;
-
-    bool is_paintable() const override { return true; }
-    void paint(PaintContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering image_rendering) const override;
-
-private:
-    LinearGradientStyleValue(GradientDirection direction, Vector<LinearColorStopListElement> color_stop_list, GradientType type, GradientRepeating repeating)
-        : AbstractImageStyleValue(Type::LinearGradient)
-        , m_properties { .direction = direction, .color_stop_list = move(color_stop_list), .gradient_type = type, .repeating = repeating }
-    {
-    }
-
-    struct Properties {
-        GradientDirection direction;
-        Vector<LinearColorStopListElement> color_stop_list;
-        GradientType gradient_type;
-        GradientRepeating repeating;
-        bool operator==(Properties const&) const = default;
-    } m_properties;
-
-    struct ResolvedData {
-        Painting::LinearGradientData data;
-        CSSPixelSize size;
-    };
-
-    mutable Optional<ResolvedData> m_resolved;
-};
-
 class InheritStyleValue final : public StyleValueWithDefaultOperators<InheritStyleValue> {
 public:
     static ValueComparingNonnullRefPtr<InheritStyleValue> the()

Userland/Libraries/LibWeb/CSS/StyleValues/LinearGradientStyleValue.cpp

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ * Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
+ * Copyright (c) 2021-2023, Sam Atkins <atkinssj@serenityos.org>
+ * Copyright (c) 2022-2023, MacDue <macdue@dueutil.tech>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include "LinearGradientStyleValue.h"
+#include <LibWeb/CSS/Serialize.h>
+
+namespace Web::CSS {
+
+// FIXME: Temporary until AbstractImageStyleValue.h exists. (And the Serialize.h include above.)
+static ErrorOr<void> serialize_color_stop_list(StringBuilder& builder, auto const& color_stop_list)
+{
+    bool first = true;
+    for (auto const& element : color_stop_list) {
+        if (!first)
+            TRY(builder.try_append(", "sv));
+
+        if (element.transition_hint.has_value())
+            TRY(builder.try_appendff("{}, "sv, TRY(element.transition_hint->value.to_string())));
+
+        TRY(serialize_a_srgb_value(builder, element.color_stop.color));
+        for (auto position : Array { &element.color_stop.position, &element.color_stop.second_position }) {
+            if (position->has_value())
+                TRY(builder.try_appendff(" {}"sv, TRY((*position)->to_string())));
+        }
+        first = false;
+    }
+    return {};
+}
+
+ErrorOr<String> LinearGradientStyleValue::to_string() const
+{
+    StringBuilder builder;
+    auto side_or_corner_to_string = [](SideOrCorner value) {
+        switch (value) {
+        case SideOrCorner::Top:
+            return "top"sv;
+        case SideOrCorner::Bottom:
+            return "bottom"sv;
+        case SideOrCorner::Left:
+            return "left"sv;
+        case SideOrCorner::Right:
+            return "right"sv;
+        case SideOrCorner::TopLeft:
+            return "top left"sv;
+        case SideOrCorner::TopRight:
+            return "top right"sv;
+        case SideOrCorner::BottomLeft:
+            return "bottom left"sv;
+        case SideOrCorner::BottomRight:
+            return "bottom right"sv;
+        default:
+            VERIFY_NOT_REACHED();
+        }
+    };
+
+    if (m_properties.gradient_type == GradientType::WebKit)
+        TRY(builder.try_append("-webkit-"sv));
+    if (is_repeating())
+        TRY(builder.try_append("repeating-"sv));
+    TRY(builder.try_append("linear-gradient("sv));
+    TRY(m_properties.direction.visit(
+        [&](SideOrCorner side_or_corner) -> ErrorOr<void> {
+            return builder.try_appendff("{}{}, "sv, m_properties.gradient_type == GradientType::Standard ? "to "sv : ""sv, side_or_corner_to_string(side_or_corner));
+        },
+        [&](Angle const& angle) -> ErrorOr<void> {
+            return builder.try_appendff("{}, "sv, TRY(angle.to_string()));
+        }));
+
+    TRY(serialize_color_stop_list(builder, m_properties.color_stop_list));
+    TRY(builder.try_append(")"sv));
+    return builder.to_string();
+}
+
+bool LinearGradientStyleValue::equals(StyleValue const& other_) const
+{
+    if (type() != other_.type())
+        return false;
+    auto& other = other_.as_linear_gradient();
+    return m_properties == other.m_properties;
+}
+
+float LinearGradientStyleValue::angle_degrees(CSSPixelSize gradient_size) const
+{
+    auto corner_angle_degrees = [&] {
+        return static_cast<float>(atan2(gradient_size.height().value(), gradient_size.width().value())) * 180 / AK::Pi<float>;
+    };
+    return m_properties.direction.visit(
+        [&](SideOrCorner side_or_corner) {
+            auto angle = [&] {
+                switch (side_or_corner) {
+                case SideOrCorner::Top:
+                    return 0.0f;
+                case SideOrCorner::Bottom:
+                    return 180.0f;
+                case SideOrCorner::Left:
+                    return 270.0f;
+                case SideOrCorner::Right:
+                    return 90.0f;
+                case SideOrCorner::TopRight:
+                    return corner_angle_degrees();
+                case SideOrCorner::BottomLeft:
+                    return corner_angle_degrees() + 180.0f;
+                case SideOrCorner::TopLeft:
+                    return -corner_angle_degrees();
+                case SideOrCorner::BottomRight:
+                    return -(corner_angle_degrees() + 180.0f);
+                default:
+                    VERIFY_NOT_REACHED();
+                }
+            }();
+            // Note: For unknowable reasons the angles are opposite on the -webkit- version
+            if (m_properties.gradient_type == GradientType::WebKit)
+                return angle + 180.0f;
+            return angle;
+        },
+        [&](Angle const& angle) {
+            return angle.to_degrees();
+        });
+}
+
+void LinearGradientStyleValue::resolve_for_size(Layout::Node const& node, CSSPixelSize size) const
+{
+    if (m_resolved.has_value() && m_resolved->size == size)
+        return;
+    m_resolved = ResolvedData { Painting::resolve_linear_gradient_data(node, size, *this), size };
+}
+
+void LinearGradientStyleValue::paint(PaintContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering) const
+{
+    VERIFY(m_resolved.has_value());
+    Painting::paint_linear_gradient(context, dest_rect, m_resolved->data);
+}
+
+}

Userland/Libraries/LibWeb/CSS/StyleValues/LinearGradientStyleValue.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ * Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
+ * Copyright (c) 2021-2023, Sam Atkins <atkinssj@serenityos.org>
+ * Copyright (c) 2022-2023, MacDue <macdue@dueutil.tech>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Vector.h>
+#include <LibWeb/CSS/StyleValue.h>
+
+namespace Web::CSS {
+
+// Note: The sides must be before the corners in this enum (as this order is used in parsing).
+enum class SideOrCorner {
+    Top,
+    Bottom,
+    Left,
+    Right,
+    TopLeft,
+    TopRight,
+    BottomLeft,
+    BottomRight
+};
+
+class LinearGradientStyleValue final : public AbstractImageStyleValue {
+public:
+    using GradientDirection = Variant<Angle, SideOrCorner>;
+
+    enum class GradientType {
+        Standard,
+        WebKit
+    };
+
+    static ValueComparingNonnullRefPtr<LinearGradientStyleValue> create(GradientDirection direction, Vector<LinearColorStopListElement> color_stop_list, GradientType type, GradientRepeating repeating)
+    {
+        VERIFY(color_stop_list.size() >= 2);
+        return adopt_ref(*new LinearGradientStyleValue(direction, move(color_stop_list), type, repeating));
+    }
+
+    virtual ErrorOr<String> to_string() const override;
+    virtual ~LinearGradientStyleValue() override = default;
+    virtual bool equals(StyleValue const& other) const override;
+
+    Vector<LinearColorStopListElement> const& color_stop_list() const
+    {
+        return m_properties.color_stop_list;
+    }
+
+    bool is_repeating() const { return m_properties.repeating == GradientRepeating::Yes; }
+
+    float angle_degrees(CSSPixelSize gradient_size) const;
+
+    void resolve_for_size(Layout::Node const&, CSSPixelSize) const override;
+
+    bool is_paintable() const override { return true; }
+    void paint(PaintContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering image_rendering) const override;
+
+private:
+    LinearGradientStyleValue(GradientDirection direction, Vector<LinearColorStopListElement> color_stop_list, GradientType type, GradientRepeating repeating)
+        : AbstractImageStyleValue(Type::LinearGradient)
+        , m_properties { .direction = direction, .color_stop_list = move(color_stop_list), .gradient_type = type, .repeating = repeating }
+    {
+    }
+
+    struct Properties {
+        GradientDirection direction;
+        Vector<LinearColorStopListElement> color_stop_list;
+        GradientType gradient_type;
+        GradientRepeating repeating;
+        bool operator==(Properties const&) const = default;
+    } m_properties;
+
+    struct ResolvedData {
+        Painting::LinearGradientData data;
+        CSSPixelSize size;
+    };
+
+    mutable Optional<ResolvedData> m_resolved;
+};
+
+}

Userland/Libraries/LibWeb/Painting/GradientPainting.cpp

@@ -8,6 +8,7 @@
 #include <LibGfx/Gradients.h>
 #include <LibWeb/CSS/StyleValue.h>
 #include <LibWeb/CSS/StyleValues/ConicGradientStyleValue.h>
+#include <LibWeb/CSS/StyleValues/LinearGradientStyleValue.h>
 #include <LibWeb/Painting/GradientPainting.h>
 
 namespace Web::Painting {