1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 23:07:35 +00:00

LibWeb: Alphabetically sort StyleValues

The random order keeps confuzing me!
This commit is contained in:
Sam Atkins 2021-09-23 16:30:40 +01:00 committed by Andreas Kling
parent 4d2f349710
commit 1ae0781ce1

View file

@ -228,60 +228,60 @@ public:
virtual ~StyleValue();
enum class Type {
Invalid,
Inherit,
Initial,
Unset,
String,
Length,
Color,
Identifier,
Image,
CustomProperty,
Numeric,
ValueList,
Calculated,
Background,
BackgroundRepeat,
Border,
BorderRadius,
CombinedBorderRadius,
BoxShadow,
Calculated,
Color,
CombinedBorderRadius,
CustomProperty,
Flex,
FlexFlow,
Font,
Identifier,
Image,
Inherit,
Initial,
Invalid,
Length,
ListStyle,
Numeric,
Overflow,
String,
TextDecoration,
Transformation,
Unset,
ValueList,
};
Type type() const { return m_type; }
bool is_inherit() const { return type() == Type::Inherit; }
bool is_initial() const { return type() == Type::Initial; }
bool is_unset() const { return type() == Type::Unset; }
bool is_color() const;
bool is_identifier() const { return type() == Type::Identifier || is_auto(); }
bool is_image() const { return type() == Type::Image; }
bool is_string() const { return type() == Type::String; }
virtual bool is_length() const { return type() == Type::Length; }
bool is_custom_property() const { return type() == Type::CustomProperty; }
bool is_numeric() const { return type() == Type::Numeric; }
bool is_value_list() const { return type() == Type::ValueList; }
bool is_calculated() const { return type() == Type::Calculated; }
bool is_background() const { return type() == Type::Background; }
bool is_background_repeat() const { return type() == Type::BackgroundRepeat; }
bool is_border() const { return type() == Type::Border; }
bool is_border_radius() const { return type() == Type::BorderRadius; }
bool is_box_shadow() const { return type() == Type::BoxShadow; }
bool is_calculated() const { return type() == Type::Calculated; }
bool is_color() const { return type() == Type::Color; }
bool is_custom_property() const { return type() == Type::CustomProperty; }
bool is_flex() const { return type() == Type::Flex; }
bool is_flex_flow() const { return type() == Type::FlexFlow; }
bool is_font() const { return type() == Type::Font; }
bool is_identifier() const { return type() == Type::Identifier || is_auto(); }
bool is_image() const { return type() == Type::Image; }
bool is_inherit() const { return type() == Type::Inherit; }
bool is_initial() const { return type() == Type::Initial; }
virtual bool is_length() const { return type() == Type::Length; }
bool is_list_style() const { return type() == Type::ListStyle; }
bool is_numeric() const { return type() == Type::Numeric; }
bool is_overflow() const { return type() == Type::Overflow; }
bool is_string() const { return type() == Type::String; }
bool is_text_decoration() const { return type() == Type::TextDecoration; }
bool is_transformation() const { return type() == Type::Transformation; }
bool is_unset() const { return type() == Type::Unset; }
bool is_value_list() const { return type() == Type::ValueList; }
bool is_builtin() const { return is_inherit() || is_initial() || is_unset(); }
@ -318,382 +318,6 @@ private:
Type m_type { Type::Invalid };
};
// FIXME: Allow for fallback
class CustomStyleValue : public StyleValue {
public:
static NonnullRefPtr<CustomStyleValue> create(const String& custom_property_name)
{
return adopt_ref(*new CustomStyleValue(custom_property_name));
}
String custom_property_name() const { return m_custom_property_name; }
String to_string() const override { return m_custom_property_name; }
private:
explicit CustomStyleValue(const String& custom_property_name)
: StyleValue(Type::CustomProperty)
, m_custom_property_name(custom_property_name)
{
}
String m_custom_property_name {};
};
class NumericStyleValue : public StyleValue {
public:
static NonnullRefPtr<NumericStyleValue> create(float value)
{
return adopt_ref(*new NumericStyleValue(value));
}
virtual bool is_length() const override { return m_value == 0; }
virtual Length to_length() const override { return Length(0, Length::Type::Px); }
float value() const { return m_value; }
String to_string() const override { return String::formatted("{}", m_value); }
virtual bool equals(StyleValue const& other) const override
{
if (type() != other.type())
return false;
return m_value == static_cast<NumericStyleValue const&>(other).m_value;
}
private:
explicit NumericStyleValue(float value)
: StyleValue(Type::Numeric)
, m_value(value)
{
}
float m_value { 0 };
};
class StringStyleValue : public StyleValue {
public:
static NonnullRefPtr<StringStyleValue> create(const String& string)
{
return adopt_ref(*new StringStyleValue(string));
}
virtual ~StringStyleValue() override { }
String to_string() const override { return m_string; }
private:
explicit StringStyleValue(const String& string)
: StyleValue(Type::String)
, m_string(string)
{
}
String m_string;
};
class BoxShadowStyleValue : public StyleValue {
public:
static NonnullRefPtr<BoxShadowStyleValue> create(Length const& offset_x, Length const& offset_y, Length const& blur_radius, Color const& color)
{
return adopt_ref(*new BoxShadowStyleValue(offset_x, offset_y, blur_radius, color));
}
virtual ~BoxShadowStyleValue() override { }
Length const& offset_x() const { return m_offset_x; }
Length const& offset_y() const { return m_offset_y; }
Length const& blur_radius() const { return m_blur_radius; }
Color const& color() const { return m_color; }
String to_string() const override { return String::formatted("BoxShadow offset_x: {}, offset_y: {}, blur_radius: {}, color: {}",
m_offset_x.to_string(), m_offset_y.to_string(), m_blur_radius.to_string(), m_color.to_string()); }
private:
explicit BoxShadowStyleValue(Length const& offset_x, Length const& offset_y, Length const& blur_radius, Color const& color)
: StyleValue(Type::BoxShadow)
, m_offset_x(offset_x)
, m_offset_y(offset_y)
, m_blur_radius(blur_radius)
, m_color(color)
{
}
Length m_offset_x;
Length m_offset_y;
Length m_blur_radius;
Color m_color;
};
class LengthStyleValue : public StyleValue {
public:
static NonnullRefPtr<LengthStyleValue> create(const Length& length)
{
return adopt_ref(*new LengthStyleValue(length));
}
virtual ~LengthStyleValue() override { }
virtual String to_string() const override { return m_length.to_string(); }
virtual Length to_length() const override { return m_length; }
const Length& length() const { return m_length; }
virtual bool is_auto() const override { return m_length.is_auto(); }
virtual bool equals(const StyleValue& other) const override
{
if (type() != other.type())
return false;
return m_length == static_cast<const LengthStyleValue&>(other).m_length;
}
private:
explicit LengthStyleValue(const Length& length)
: StyleValue(Type::Length)
, m_length(length)
{
}
Length m_length;
};
class CalculatedStyleValue : public StyleValue {
public:
struct CalcSum;
struct CalcSumPartWithOperator;
struct CalcProduct;
struct CalcProductPartWithOperator;
struct CalcNumberSum;
struct CalcNumberSumPartWithOperator;
struct CalcNumberProduct;
struct CalcNumberProductPartWithOperator;
using CalcNumberValue = Variant<float, NonnullOwnPtr<CalcNumberSum>>;
using CalcValue = Variant<float, CSS::Length, NonnullOwnPtr<CalcSum>>;
// This represents that: https://drafts.csswg.org/css-values-3/#calc-syntax
struct CalcSum {
CalcSum(NonnullOwnPtr<CalcProduct> first_calc_product, NonnullOwnPtrVector<CalcSumPartWithOperator> additional)
: first_calc_product(move(first_calc_product))
, zero_or_more_additional_calc_products(move(additional)) {};
NonnullOwnPtr<CalcProduct> first_calc_product;
NonnullOwnPtrVector<CalcSumPartWithOperator> zero_or_more_additional_calc_products;
};
struct CalcNumberSum {
CalcNumberSum(NonnullOwnPtr<CalcNumberProduct> first_calc_number_product, NonnullOwnPtrVector<CalcNumberSumPartWithOperator> additional)
: first_calc_number_product(move(first_calc_number_product))
, zero_or_more_additional_calc_number_products(move(additional)) {};
NonnullOwnPtr<CalcNumberProduct> first_calc_number_product;
NonnullOwnPtrVector<CalcNumberSumPartWithOperator> zero_or_more_additional_calc_number_products;
};
struct CalcProduct {
CalcValue first_calc_value;
NonnullOwnPtrVector<CalcProductPartWithOperator> zero_or_more_additional_calc_values;
};
struct CalcSumPartWithOperator {
enum Operation {
Add,
Subtract,
};
CalcSumPartWithOperator(Operation op, NonnullOwnPtr<CalcProduct> calc_product)
: op(op)
, calc_product(move(calc_product)) {};
Operation op;
NonnullOwnPtr<CalcProduct> calc_product;
};
struct CalcProductPartWithOperator {
enum {
Multiply,
Divide,
} op;
Variant<CalcValue, CalcNumberValue> value;
};
struct CalcNumberProduct {
CalcNumberValue first_calc_number_value;
NonnullOwnPtrVector<CalcNumberProductPartWithOperator> zero_or_more_additional_calc_number_values;
};
struct CalcNumberProductPartWithOperator {
enum {
Multiply,
Divide,
} op;
CalcNumberValue value;
};
struct CalcNumberSumPartWithOperator {
enum Operation {
Add,
Subtract,
};
CalcNumberSumPartWithOperator(Operation op, NonnullOwnPtr<CalcNumberProduct> calc_number_product)
: op(op)
, calc_number_product(move(calc_number_product)) {};
Operation op;
NonnullOwnPtr<CalcNumberProduct> calc_number_product;
};
static NonnullRefPtr<CalculatedStyleValue> create(String const& expression_string, NonnullOwnPtr<CalcSum> calc_sum)
{
return adopt_ref(*new CalculatedStyleValue(expression_string, move(calc_sum)));
}
String to_string() const override { return m_expression_string; }
NonnullOwnPtr<CalcSum> const& expression() const { return m_expression; }
private:
explicit CalculatedStyleValue(String const& expression_string, NonnullOwnPtr<CalcSum> calc_sum)
: StyleValue(Type::Calculated)
, m_expression_string(expression_string)
, m_expression(move(calc_sum))
{
}
String m_expression_string;
NonnullOwnPtr<CalcSum> m_expression;
};
class InitialStyleValue final : public StyleValue {
public:
static NonnullRefPtr<InitialStyleValue> the()
{
static NonnullRefPtr<InitialStyleValue> instance = adopt_ref(*new InitialStyleValue);
return instance;
}
virtual ~InitialStyleValue() override { }
String to_string() const override { return "initial"; }
private:
InitialStyleValue()
: StyleValue(Type::Initial)
{
}
};
class InheritStyleValue final : public StyleValue {
public:
static NonnullRefPtr<InheritStyleValue> the()
{
static NonnullRefPtr<InheritStyleValue> instance = adopt_ref(*new InheritStyleValue);
return instance;
}
virtual ~InheritStyleValue() override { }
String to_string() const override { return "inherit"; }
private:
InheritStyleValue()
: StyleValue(Type::Inherit)
{
}
};
class UnsetStyleValue final : public StyleValue {
public:
static NonnullRefPtr<UnsetStyleValue> the()
{
static NonnullRefPtr<UnsetStyleValue> instance = adopt_ref(*new UnsetStyleValue);
return instance;
}
virtual ~UnsetStyleValue() override { }
String to_string() const override { return "unset"; }
private:
UnsetStyleValue()
: StyleValue(Type::Unset)
{
}
};
class ColorStyleValue : public StyleValue {
public:
static NonnullRefPtr<ColorStyleValue> create(Color color)
{
return adopt_ref(*new ColorStyleValue(color));
}
virtual ~ColorStyleValue() override { }
Color color() const { return m_color; }
String to_string() const override { return m_color.to_string(); }
Color to_color(Layout::NodeWithStyle const&) const override { return m_color; }
virtual bool equals(const StyleValue& other) const override
{
if (type() != other.type())
return false;
return m_color == static_cast<const ColorStyleValue&>(other).m_color;
}
private:
explicit ColorStyleValue(Color color)
: StyleValue(Type::Color)
, m_color(color)
{
}
Color m_color;
};
class IdentifierStyleValue final : public StyleValue {
public:
static NonnullRefPtr<IdentifierStyleValue> create(CSS::ValueID id)
{
return adopt_ref(*new IdentifierStyleValue(id));
}
virtual ~IdentifierStyleValue() override { }
CSS::ValueID id() const { return m_id; }
virtual String to_string() const override;
virtual Color to_color(Layout::NodeWithStyle const& node) const override;
virtual bool equals(const StyleValue& other) const override
{
if (type() != other.type())
return false;
return m_id == static_cast<const IdentifierStyleValue&>(other).m_id;
}
private:
explicit IdentifierStyleValue(CSS::ValueID id)
: StyleValue(Type::Identifier)
, m_id(id)
{
}
CSS::ValueID m_id { CSS::ValueID::Invalid };
};
class ImageStyleValue final
: public StyleValue
, public ImageResourceClient {
public:
static NonnullRefPtr<ImageStyleValue> create(const AK::URL& url, DOM::Document& document) { return adopt_ref(*new ImageStyleValue(url, document)); }
virtual ~ImageStyleValue() override { }
String to_string() const override { return String::formatted("Image({})", m_url.to_string()); }
const Gfx::Bitmap* bitmap() const { return m_bitmap; }
private:
ImageStyleValue(const AK::URL&, DOM::Document&);
// ^ResourceClient
virtual void resource_did_load() override;
AK::URL m_url;
WeakPtr<DOM::Document> m_document;
RefPtr<Gfx::Bitmap> m_bitmap;
};
class BackgroundStyleValue final : public StyleValue {
public:
static NonnullRefPtr<BackgroundStyleValue> create(
@ -849,6 +473,174 @@ private:
Length m_vertical_radius;
};
class BoxShadowStyleValue : public StyleValue {
public:
static NonnullRefPtr<BoxShadowStyleValue> create(Length const& offset_x, Length const& offset_y, Length const& blur_radius, Color const& color)
{
return adopt_ref(*new BoxShadowStyleValue(offset_x, offset_y, blur_radius, color));
}
virtual ~BoxShadowStyleValue() override { }
Length const& offset_x() const { return m_offset_x; }
Length const& offset_y() const { return m_offset_y; }
Length const& blur_radius() const { return m_blur_radius; }
Color const& color() const { return m_color; }
String to_string() const override { return String::formatted("BoxShadow offset_x: {}, offset_y: {}, blur_radius: {}, color: {}",
m_offset_x.to_string(), m_offset_y.to_string(), m_blur_radius.to_string(), m_color.to_string()); }
private:
explicit BoxShadowStyleValue(Length const& offset_x, Length const& offset_y, Length const& blur_radius, Color const& color)
: StyleValue(Type::BoxShadow)
, m_offset_x(offset_x)
, m_offset_y(offset_y)
, m_blur_radius(blur_radius)
, m_color(color)
{
}
Length m_offset_x;
Length m_offset_y;
Length m_blur_radius;
Color m_color;
};
class CalculatedStyleValue : public StyleValue {
public:
struct CalcSum;
struct CalcSumPartWithOperator;
struct CalcProduct;
struct CalcProductPartWithOperator;
struct CalcNumberSum;
struct CalcNumberSumPartWithOperator;
struct CalcNumberProduct;
struct CalcNumberProductPartWithOperator;
using CalcNumberValue = Variant<float, NonnullOwnPtr<CalcNumberSum>>;
using CalcValue = Variant<float, CSS::Length, NonnullOwnPtr<CalcSum>>;
// This represents that: https://drafts.csswg.org/css-values-3/#calc-syntax
struct CalcSum {
CalcSum(NonnullOwnPtr<CalcProduct> first_calc_product, NonnullOwnPtrVector<CalcSumPartWithOperator> additional)
: first_calc_product(move(first_calc_product))
, zero_or_more_additional_calc_products(move(additional)) {};
NonnullOwnPtr<CalcProduct> first_calc_product;
NonnullOwnPtrVector<CalcSumPartWithOperator> zero_or_more_additional_calc_products;
};
struct CalcNumberSum {
CalcNumberSum(NonnullOwnPtr<CalcNumberProduct> first_calc_number_product, NonnullOwnPtrVector<CalcNumberSumPartWithOperator> additional)
: first_calc_number_product(move(first_calc_number_product))
, zero_or_more_additional_calc_number_products(move(additional)) {};
NonnullOwnPtr<CalcNumberProduct> first_calc_number_product;
NonnullOwnPtrVector<CalcNumberSumPartWithOperator> zero_or_more_additional_calc_number_products;
};
struct CalcProduct {
CalcValue first_calc_value;
NonnullOwnPtrVector<CalcProductPartWithOperator> zero_or_more_additional_calc_values;
};
struct CalcSumPartWithOperator {
enum Operation {
Add,
Subtract,
};
CalcSumPartWithOperator(Operation op, NonnullOwnPtr<CalcProduct> calc_product)
: op(op)
, calc_product(move(calc_product)) {};
Operation op;
NonnullOwnPtr<CalcProduct> calc_product;
};
struct CalcProductPartWithOperator {
enum {
Multiply,
Divide,
} op;
Variant<CalcValue, CalcNumberValue> value;
};
struct CalcNumberProduct {
CalcNumberValue first_calc_number_value;
NonnullOwnPtrVector<CalcNumberProductPartWithOperator> zero_or_more_additional_calc_number_values;
};
struct CalcNumberProductPartWithOperator {
enum {
Multiply,
Divide,
} op;
CalcNumberValue value;
};
struct CalcNumberSumPartWithOperator {
enum Operation {
Add,
Subtract,
};
CalcNumberSumPartWithOperator(Operation op, NonnullOwnPtr<CalcNumberProduct> calc_number_product)
: op(op)
, calc_number_product(move(calc_number_product)) {};
Operation op;
NonnullOwnPtr<CalcNumberProduct> calc_number_product;
};
static NonnullRefPtr<CalculatedStyleValue> create(String const& expression_string, NonnullOwnPtr<CalcSum> calc_sum)
{
return adopt_ref(*new CalculatedStyleValue(expression_string, move(calc_sum)));
}
String to_string() const override { return m_expression_string; }
NonnullOwnPtr<CalcSum> const& expression() const { return m_expression; }
private:
explicit CalculatedStyleValue(String const& expression_string, NonnullOwnPtr<CalcSum> calc_sum)
: StyleValue(Type::Calculated)
, m_expression_string(expression_string)
, m_expression(move(calc_sum))
{
}
String m_expression_string;
NonnullOwnPtr<CalcSum> m_expression;
};
class ColorStyleValue : public StyleValue {
public:
static NonnullRefPtr<ColorStyleValue> create(Color color)
{
return adopt_ref(*new ColorStyleValue(color));
}
virtual ~ColorStyleValue() override { }
Color color() const { return m_color; }
String to_string() const override { return m_color.to_string(); }
Color to_color(Layout::NodeWithStyle const&) const override { return m_color; }
virtual bool equals(const StyleValue& other) const override
{
if (type() != other.type())
return false;
return m_color == static_cast<const ColorStyleValue&>(other).m_color;
}
private:
explicit ColorStyleValue(Color color)
: StyleValue(Type::Color)
, m_color(color)
{
}
Color m_color;
};
class CombinedBorderRadiusStyleValue final : public StyleValue {
public:
static NonnullRefPtr<CombinedBorderRadiusStyleValue> create(NonnullRefPtr<BorderRadiusStyleValue> top_left, NonnullRefPtr<BorderRadiusStyleValue> top_right, NonnullRefPtr<BorderRadiusStyleValue> bottom_right, NonnullRefPtr<BorderRadiusStyleValue> bottom_left)
@ -883,6 +675,26 @@ private:
NonnullRefPtr<BorderRadiusStyleValue> m_bottom_left;
};
// FIXME: Allow for fallback
class CustomStyleValue : public StyleValue {
public:
static NonnullRefPtr<CustomStyleValue> create(const String& custom_property_name)
{
return adopt_ref(*new CustomStyleValue(custom_property_name));
}
String custom_property_name() const { return m_custom_property_name; }
String to_string() const override { return m_custom_property_name; }
private:
explicit CustomStyleValue(const String& custom_property_name)
: StyleValue(Type::CustomProperty)
, m_custom_property_name(custom_property_name)
{
}
String m_custom_property_name {};
};
class FlexStyleValue final : public StyleValue {
public:
static NonnullRefPtr<FlexStyleValue> create(
@ -984,6 +796,126 @@ private:
// FIXME: Implement font-stretch and font-variant.
};
class IdentifierStyleValue final : public StyleValue {
public:
static NonnullRefPtr<IdentifierStyleValue> create(CSS::ValueID id)
{
return adopt_ref(*new IdentifierStyleValue(id));
}
virtual ~IdentifierStyleValue() override { }
CSS::ValueID id() const { return m_id; }
virtual String to_string() const override;
virtual Color to_color(Layout::NodeWithStyle const& node) const override;
virtual bool equals(const StyleValue& other) const override
{
if (type() != other.type())
return false;
return m_id == static_cast<const IdentifierStyleValue&>(other).m_id;
}
private:
explicit IdentifierStyleValue(CSS::ValueID id)
: StyleValue(Type::Identifier)
, m_id(id)
{
}
CSS::ValueID m_id { CSS::ValueID::Invalid };
};
class ImageStyleValue final
: public StyleValue
, public ImageResourceClient {
public:
static NonnullRefPtr<ImageStyleValue> create(const AK::URL& url, DOM::Document& document) { return adopt_ref(*new ImageStyleValue(url, document)); }
virtual ~ImageStyleValue() override { }
String to_string() const override { return String::formatted("Image({})", m_url.to_string()); }
const Gfx::Bitmap* bitmap() const { return m_bitmap; }
private:
ImageStyleValue(const AK::URL&, DOM::Document&);
// ^ResourceClient
virtual void resource_did_load() override;
AK::URL m_url;
WeakPtr<DOM::Document> m_document;
RefPtr<Gfx::Bitmap> m_bitmap;
};
class InheritStyleValue final : public StyleValue {
public:
static NonnullRefPtr<InheritStyleValue> the()
{
static NonnullRefPtr<InheritStyleValue> instance = adopt_ref(*new InheritStyleValue);
return instance;
}
virtual ~InheritStyleValue() override { }
String to_string() const override { return "inherit"; }
private:
InheritStyleValue()
: StyleValue(Type::Inherit)
{
}
};
class InitialStyleValue final : public StyleValue {
public:
static NonnullRefPtr<InitialStyleValue> the()
{
static NonnullRefPtr<InitialStyleValue> instance = adopt_ref(*new InitialStyleValue);
return instance;
}
virtual ~InitialStyleValue() override { }
String to_string() const override { return "initial"; }
private:
InitialStyleValue()
: StyleValue(Type::Initial)
{
}
};
class LengthStyleValue : public StyleValue {
public:
static NonnullRefPtr<LengthStyleValue> create(const Length& length)
{
return adopt_ref(*new LengthStyleValue(length));
}
virtual ~LengthStyleValue() override { }
virtual String to_string() const override { return m_length.to_string(); }
virtual Length to_length() const override { return m_length; }
const Length& length() const { return m_length; }
virtual bool is_auto() const override { return m_length.is_auto(); }
virtual bool equals(const StyleValue& other) const override
{
if (type() != other.type())
return false;
return m_length == static_cast<const LengthStyleValue&>(other).m_length;
}
private:
explicit LengthStyleValue(const Length& length)
: StyleValue(Type::Length)
, m_length(length)
{
}
Length m_length;
};
class ListStyleStyleValue final : public StyleValue {
public:
static NonnullRefPtr<ListStyleStyleValue> create(
@ -1021,6 +953,36 @@ private:
NonnullRefPtr<StyleValue> m_style_type;
};
class NumericStyleValue : public StyleValue {
public:
static NonnullRefPtr<NumericStyleValue> create(float value)
{
return adopt_ref(*new NumericStyleValue(value));
}
virtual bool is_length() const override { return m_value == 0; }
virtual Length to_length() const override { return Length(0, Length::Type::Px); }
float value() const { return m_value; }
String to_string() const override { return String::formatted("{}", m_value); }
virtual bool equals(StyleValue const& other) const override
{
if (type() != other.type())
return false;
return m_value == static_cast<NumericStyleValue const&>(other).m_value;
}
private:
explicit NumericStyleValue(float value)
: StyleValue(Type::Numeric)
, m_value(value)
{
}
float m_value { 0 };
};
class OverflowStyleValue final : public StyleValue {
public:
static NonnullRefPtr<OverflowStyleValue> create(NonnullRefPtr<StyleValue> overflow_x, NonnullRefPtr<StyleValue> overflow_y)
@ -1049,6 +1011,26 @@ private:
NonnullRefPtr<StyleValue> m_overflow_y;
};
class StringStyleValue : public StyleValue {
public:
static NonnullRefPtr<StringStyleValue> create(const String& string)
{
return adopt_ref(*new StringStyleValue(string));
}
virtual ~StringStyleValue() override { }
String to_string() const override { return m_string; }
private:
explicit StringStyleValue(const String& string)
: StyleValue(Type::String)
, m_string(string)
{
}
String m_string;
};
class TextDecorationStyleValue final : public StyleValue {
public:
static NonnullRefPtr<TextDecorationStyleValue> create(
@ -1114,6 +1096,24 @@ private:
NonnullRefPtrVector<StyleValue> m_values;
};
class UnsetStyleValue final : public StyleValue {
public:
static NonnullRefPtr<UnsetStyleValue> the()
{
static NonnullRefPtr<UnsetStyleValue> instance = adopt_ref(*new UnsetStyleValue);
return instance;
}
virtual ~UnsetStyleValue() override { }
String to_string() const override { return "unset"; }
private:
UnsetStyleValue()
: StyleValue(Type::Unset)
{
}
};
class StyleValueList final : public StyleValue {
public:
static NonnullRefPtr<StyleValueList> create(NonnullRefPtrVector<StyleValue>&& values) { return adopt_ref(*new StyleValueList(move(values))); }