[Conic Gradients] Add support for parsing conic gradients
[WebKit-https.git] / Source / WebCore / css / CSSValue.h
1 /*
2  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  */
20
21 #pragma once
22
23 #include "URLHash.h"
24 #include <wtf/Function.h>
25 #include <wtf/HashMap.h>
26 #include <wtf/RefCounted.h>
27 #include <wtf/RefPtr.h>
28 #include <wtf/TypeCasts.h>
29
30 namespace WebCore {
31
32 class CSSCustomPropertyValue;
33 class CSSStyleDeclaration;
34 class CachedResource;
35 class DeprecatedCSSOMValue;
36 class StyleSheetContents;
37
38 enum CSSPropertyID : uint16_t;
39
40 class CSSValue : public RefCounted<CSSValue> {
41 public:
42     enum Type {
43         CSS_INHERIT = 0,
44         CSS_PRIMITIVE_VALUE = 1,
45         CSS_VALUE_LIST = 2,
46         CSS_CUSTOM = 3,
47         CSS_INITIAL = 4,
48         CSS_UNSET = 5,
49         CSS_REVERT = 6
50     };
51
52     // Override RefCounted's deref() to ensure operator delete is called on
53     // the appropriate subclass type.
54     void deref()
55     {
56         if (derefBase())
57             destroy();
58     }
59
60     Type cssValueType() const;
61     String cssText() const;
62
63     bool isPrimitiveValue() const { return m_classType == PrimitiveClass; }
64     bool isValueList() const { return m_classType >= ValueListClass; }
65     
66     bool isBaseValueList() const { return m_classType == ValueListClass; }
67         
68
69     bool isAspectRatioValue() const { return m_classType == AspectRatioClass; }
70     bool isBorderImageSliceValue() const { return m_classType == BorderImageSliceClass; }
71     bool isCanvasValue() const { return m_classType == CanvasClass; }
72     bool isCrossfadeValue() const { return m_classType == CrossfadeClass; }
73     bool isCursorImageValue() const { return m_classType == CursorImageClass; }
74     bool isCustomPropertyValue() const { return m_classType == CustomPropertyClass; }
75     bool isFunctionValue() const { return m_classType == FunctionClass; }
76     bool isFontFeatureValue() const { return m_classType == FontFeatureClass; }
77 #if ENABLE(VARIATION_FONTS)
78     bool isFontVariationValue() const { return m_classType == FontVariationClass; }
79 #endif
80     bool isFontFaceSrcValue() const { return m_classType == FontFaceSrcClass; }
81     bool isFontValue() const { return m_classType == FontClass; }
82     bool isFontStyleValue() const { return m_classType == FontStyleClass; }
83     bool isFontStyleRangeValue() const { return m_classType == FontStyleRangeClass; }
84     bool isImageGeneratorValue() const { return m_classType >= CanvasClass && m_classType <= ConicGradientClass; }
85     bool isGradientValue() const { return m_classType >= LinearGradientClass && m_classType <= ConicGradientClass; }
86     bool isNamedImageValue() const { return m_classType == NamedImageClass; }
87     bool isImageSetValue() const { return m_classType == ImageSetClass; }
88     bool isImageValue() const { return m_classType == ImageClass; }
89     bool isImplicitInitialValue() const;
90     bool isInheritedValue() const { return m_classType == InheritedClass; }
91     bool isInitialValue() const { return m_classType == InitialClass; }
92     bool isUnsetValue() const { return m_classType == UnsetClass; }
93     bool isRevertValue() const { return m_classType == RevertClass; }
94     bool treatAsInitialValue(CSSPropertyID) const;
95     bool treatAsInheritedValue(CSSPropertyID) const;
96     bool isLinearGradientValue() const { return m_classType == LinearGradientClass; }
97     bool isRadialGradientValue() const { return m_classType == RadialGradientClass; }
98     bool isConicGradientValue() const { return m_classType == ConicGradientClass; }
99     bool isReflectValue() const { return m_classType == ReflectClass; }
100     bool isShadowValue() const { return m_classType == ShadowClass; }
101     bool isCubicBezierTimingFunctionValue() const { return m_classType == CubicBezierTimingFunctionClass; }
102     bool isStepsTimingFunctionValue() const { return m_classType == StepsTimingFunctionClass; }
103     bool isSpringTimingFunctionValue() const { return m_classType == SpringTimingFunctionClass; }
104     bool isLineBoxContainValue() const { return m_classType == LineBoxContainClass; }
105     bool isCalcValue() const {return m_classType == CalculationClass; }
106     bool isFilterImageValue() const { return m_classType == FilterImageClass; }
107     bool isContentDistributionValue() const { return m_classType == CSSContentDistributionClass; }
108     bool isGridAutoRepeatValue() const { return m_classType == GridAutoRepeatClass; }
109     bool isGridTemplateAreasValue() const { return m_classType == GridTemplateAreasClass; }
110     bool isGridLineNamesValue() const { return m_classType == GridLineNamesClass; }
111     bool isUnicodeRangeValue() const { return m_classType == UnicodeRangeClass; }
112
113 #if ENABLE(CSS_ANIMATIONS_LEVEL_2)
114     bool isAnimationTriggerScrollValue() const { return m_classType == AnimationTriggerScrollClass; }
115 #endif
116
117     bool isCustomIdentValue() const { return m_classType == CustomIdentClass; }
118     bool isVariableReferenceValue() const { return m_classType == VariableReferenceClass; }
119     bool isPendingSubstitutionValue() const { return m_classType == PendingSubstitutionValueClass; }
120     
121     bool hasVariableReferences() const { return isVariableReferenceValue() || isPendingSubstitutionValue(); }
122
123     Ref<DeprecatedCSSOMValue> createDeprecatedCSSOMWrapper(CSSStyleDeclaration&) const;
124
125     bool traverseSubresources(const WTF::Function<bool (const CachedResource&)>& handler) const;
126
127     bool equals(const CSSValue&) const;
128     bool operator==(const CSSValue& other) const { return equals(other); }
129
130 protected:
131
132     static const size_t ClassTypeBits = 6;
133     enum ClassType {
134         PrimitiveClass,
135
136         // Image classes.
137         ImageClass,
138         CursorImageClass,
139
140         // Image generator classes.
141         CanvasClass,
142         NamedImageClass,
143         CrossfadeClass,
144         FilterImageClass,
145         LinearGradientClass,
146         RadialGradientClass,
147         ConicGradientClass,
148
149         // Timing function classes.
150         CubicBezierTimingFunctionClass,
151         StepsTimingFunctionClass,
152         SpringTimingFunctionClass,
153
154         // Other class types.
155         AspectRatioClass,
156         BorderImageSliceClass,
157         FontFeatureClass,
158 #if ENABLE(VARIATION_FONTS)
159         FontVariationClass,
160 #endif
161         FontClass,
162         FontStyleClass,
163         FontStyleRangeClass,
164         FontFaceSrcClass,
165         FunctionClass,
166
167         InheritedClass,
168         InitialClass,
169         UnsetClass,
170         RevertClass,
171
172         ReflectClass,
173         ShadowClass,
174         UnicodeRangeClass,
175         LineBoxContainClass,
176         CalculationClass,
177         GridTemplateAreasClass,
178 #if ENABLE(CSS_ANIMATIONS_LEVEL_2)
179         AnimationTriggerScrollClass,
180 #endif
181
182         CSSContentDistributionClass,
183         
184         CustomIdentClass,
185
186         CustomPropertyClass,
187         VariableReferenceClass,
188         PendingSubstitutionValueClass,
189
190         // List class types must appear after ValueListClass. Note CSSFunctionValue
191         // is deliberately excluded, since we don't want it exposed to the CSS OM
192         // as a list.
193         ValueListClass,
194         ImageSetClass,
195         GridLineNamesClass,
196         GridAutoRepeatClass,
197         // Do not append non-list class types here.
198     };
199
200 public:
201     static const size_t ValueListSeparatorBits = 2;
202     enum ValueListSeparator {
203         SpaceSeparator,
204         CommaSeparator,
205         SlashSeparator
206     };
207
208 protected:
209     ClassType classType() const { return static_cast<ClassType>(m_classType); }
210
211     explicit CSSValue(ClassType classType)
212         : m_primitiveUnitType(0)
213         , m_hasCachedCSSText(false)
214         , m_isQuirkValue(false)
215         , m_valueListSeparator(SpaceSeparator)
216         , m_classType(classType)
217     {
218     }
219
220     // NOTE: This class is non-virtual for memory and performance reasons.
221     // Don't go making it virtual again unless you know exactly what you're doing!
222
223     ~CSSValue() = default;
224
225 private:
226     WEBCORE_EXPORT void destroy();
227
228 protected:
229     // The bits in this section are only used by specific subclasses but kept here
230     // to maximize struct packing.
231
232     // CSSPrimitiveValue bits:
233     unsigned m_primitiveUnitType : 7; // CSSPrimitiveValue::UnitType
234     mutable unsigned m_hasCachedCSSText : 1;
235     unsigned m_isQuirkValue : 1;
236
237     unsigned m_valueListSeparator : ValueListSeparatorBits;
238
239 private:
240     unsigned m_classType : ClassTypeBits; // ClassType
241     
242 friend class CSSValueList;
243 };
244
245 template<typename CSSValueType>
246 inline bool compareCSSValueVector(const Vector<Ref<CSSValueType>>& firstVector, const Vector<Ref<CSSValueType>>& secondVector)
247 {
248     size_t size = firstVector.size();
249     if (size != secondVector.size())
250         return false;
251
252     for (size_t i = 0; i < size; ++i) {
253         auto& firstPtr = firstVector[i];
254         auto& secondPtr = secondVector[i];
255         if (firstPtr.ptr() == secondPtr.ptr() || firstPtr->equals(secondPtr))
256             continue;
257         return false;
258     }
259     return true;
260 }
261
262 template<typename CSSValueType>
263 inline bool compareCSSValuePtr(const RefPtr<CSSValueType>& first, const RefPtr<CSSValueType>& second)
264 {
265     return first ? second && first->equals(*second) : !second;
266 }
267
268 template<typename CSSValueType>
269 inline bool compareCSSValue(const Ref<CSSValueType>& first, const Ref<CSSValueType>& second)
270 {
271     return first.get().equals(second);
272 }
273
274 typedef HashMap<AtomicString, RefPtr<CSSCustomPropertyValue>> CustomPropertyValueMap;
275
276 } // namespace WebCore
277
278 #define SPECIALIZE_TYPE_TRAITS_CSS_VALUE(ToValueTypeName, predicate) \
279 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::ToValueTypeName) \
280     static bool isType(const WebCore::CSSValue& value) { return value.predicate; } \
281 SPECIALIZE_TYPE_TRAITS_END()