Parsing and Style Resolution of Container-based Animation Triggers
[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 #ifndef CSSValue_h
22 #define CSSValue_h
23
24 #include "ExceptionCode.h"
25 #include "URLHash.h"
26 #include <wtf/ListHashSet.h>
27 #include <wtf/RefCounted.h>
28 #include <wtf/RefPtr.h>
29 #include <wtf/TypeCasts.h>
30
31 namespace WebCore {
32
33 class StyleSheetContents;
34     
35 // FIXME: The current CSSValue and subclasses should be turned into internal types (StyleValue).
36 // The few subtypes that are actually exposed in CSSOM can be seen in the cloneForCSSOM() function.
37 // They should be handled by separate wrapper classes.
38
39 // Please don't expose more CSSValue types to the web.
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
49     };
50
51     // Override RefCounted's deref() to ensure operator delete is called on
52     // the appropriate subclass type.
53     void deref()
54     {
55         if (derefBase())
56             destroy();
57     }
58
59     Type cssValueType() const;
60
61     String cssText() const;
62     void setCssText(const String&, ExceptionCode&) { } // FIXME: Not implemented.
63
64     bool isPrimitiveValue() const { return m_classType == PrimitiveClass; }
65     bool isValueList() const { return m_classType >= ValueListClass; }
66     
67     bool isBaseValueList() const { return m_classType == ValueListClass; }
68         
69
70     bool isAspectRatioValue() const { return m_classType == AspectRatioClass; }
71     bool isBorderImageSliceValue() const { return m_classType == BorderImageSliceClass; }
72     bool isCanvasValue() const { return m_classType == CanvasClass; }
73     bool isCrossfadeValue() const { return m_classType == CrossfadeClass; }
74     bool isCursorImageValue() const { return m_classType == CursorImageClass; }
75     bool isFunctionValue() const { return m_classType == FunctionClass; }
76     bool isFontFeatureValue() const { return m_classType == FontFeatureClass; }
77     bool isFontFaceSrcValue() const { return m_classType == FontFaceSrcClass; }
78     bool isFontValue() const { return m_classType == FontClass; }
79     bool isImageGeneratorValue() const { return m_classType >= CanvasClass && m_classType <= RadialGradientClass; }
80     bool isGradientValue() const { return m_classType >= LinearGradientClass && m_classType <= RadialGradientClass; }
81 #if ENABLE(CSS_IMAGE_SET)
82     bool isImageSetValue() const { return m_classType == ImageSetClass; }
83 #endif
84     bool isImageValue() const { return m_classType == ImageClass; }
85     bool isImplicitInitialValue() const;
86     bool isInheritedValue() const { return m_classType == InheritedClass; }
87     bool isInitialValue() const { return m_classType == InitialClass; }
88     bool isLinearGradientValue() const { return m_classType == LinearGradientClass; }
89     bool isRadialGradientValue() const { return m_classType == RadialGradientClass; }
90     bool isReflectValue() const { return m_classType == ReflectClass; }
91     bool isShadowValue() const { return m_classType == ShadowClass; }
92     bool isCubicBezierTimingFunctionValue() const { return m_classType == CubicBezierTimingFunctionClass; }
93     bool isStepsTimingFunctionValue() const { return m_classType == StepsTimingFunctionClass; }
94     bool isWebKitCSSTransformValue() const { return m_classType == WebKitCSSTransformClass; }
95     bool isLineBoxContainValue() const { return m_classType == LineBoxContainClass; }
96     bool isCalcValue() const {return m_classType == CalculationClass; }
97     bool isFilterImageValue() const { return m_classType == FilterImageClass; }
98     bool isWebKitCSSFilterValue() const { return m_classType == WebKitCSSFilterClass; }
99 #if ENABLE(CSS_GRID_LAYOUT)
100     bool isGridTemplateAreasValue() const { return m_classType == GridTemplateAreasClass; }
101     bool isGridLineNamesValue() const { return m_classType == GridLineNamesClass; }
102 #endif
103     bool isSVGColor() const { return m_classType == SVGColorClass || m_classType == SVGPaintClass; }
104     bool isSVGPaint() const { return m_classType == SVGPaintClass; }
105     bool isUnicodeRangeValue() const { return m_classType == UnicodeRangeClass; }
106     bool isWebKitCSSResourceValue() const { return m_classType == WebKitCSSResourceClass; }
107
108 #if ENABLE(CSS_ANIMATIONS_LEVEL_2)
109     bool isAnimationTriggerScrollValue() const { return m_classType == AnimationTriggerScrollClass; }
110 #endif
111
112     bool isCSSOMSafe() const { return m_isCSSOMSafe; }
113     bool isSubtypeExposedToCSSOM() const
114     { 
115         return isPrimitiveValue() 
116             || isSVGColor()
117             || isValueList();
118     }
119
120     PassRefPtr<CSSValue> cloneForCSSOM() const;
121
122     void addSubresourceStyleURLs(ListHashSet<URL>&, const StyleSheetContents*) const;
123
124     bool hasFailedOrCanceledSubresources() const;
125
126     bool equals(const CSSValue&) const;
127
128 protected:
129
130     static const size_t ClassTypeBits = 6;
131     enum ClassType {
132         PrimitiveClass,
133
134         // Image classes.
135         ImageClass,
136         CursorImageClass,
137
138         // Image generator classes.
139         CanvasClass,
140         CrossfadeClass,
141         FilterImageClass,
142         LinearGradientClass,
143         RadialGradientClass,
144
145         // Timing function classes.
146         CubicBezierTimingFunctionClass,
147         StepsTimingFunctionClass,
148
149         // Other class types.
150         AspectRatioClass,
151         BorderImageSliceClass,
152         FontFeatureClass,
153         FontClass,
154         FontFaceSrcClass,
155         FunctionClass,
156
157         InheritedClass,
158         InitialClass,
159
160         ReflectClass,
161         ShadowClass,
162         UnicodeRangeClass,
163         LineBoxContainClass,
164         CalculationClass,
165 #if ENABLE(CSS_GRID_LAYOUT)
166         GridTemplateAreasClass,
167 #endif
168         SVGColorClass,
169         SVGPaintClass,
170         WebKitCSSResourceClass,
171
172 #if ENABLE(CSS_ANIMATIONS_LEVEL_2)
173         AnimationTriggerScrollClass,
174 #endif
175
176         // List class types must appear after ValueListClass.
177         ValueListClass,
178 #if ENABLE(CSS_IMAGE_SET)
179         ImageSetClass,
180 #endif
181         WebKitCSSFilterClass,
182         WebKitCSSTransformClass,
183 #if ENABLE(CSS_GRID_LAYOUT)
184         GridLineNamesClass,
185 #endif
186
187         // Do not append non-list class types here.
188     };
189
190     static const size_t ValueListSeparatorBits = 2;
191     enum ValueListSeparator {
192         SpaceSeparator,
193         CommaSeparator,
194         SlashSeparator
195     };
196
197     ClassType classType() const { return static_cast<ClassType>(m_classType); }
198
199     explicit CSSValue(ClassType classType, bool isCSSOMSafe = false)
200         : m_isCSSOMSafe(isCSSOMSafe)
201         , m_isTextClone(false)
202         , m_primitiveUnitType(0)
203         , m_hasCachedCSSText(false)
204         , m_isQuirkValue(false)
205         , m_valueListSeparator(SpaceSeparator)
206         , m_classType(classType)
207     {
208     }
209
210     // NOTE: This class is non-virtual for memory and performance reasons.
211     // Don't go making it virtual again unless you know exactly what you're doing!
212
213     ~CSSValue() { }
214
215 private:
216     WEBCORE_EXPORT void destroy();
217
218 protected:
219     unsigned m_isCSSOMSafe : 1;
220     unsigned m_isTextClone : 1;
221     // The bits in this section are only used by specific subclasses but kept here
222     // to maximize struct packing.
223
224     // CSSPrimitiveValue bits:
225     unsigned m_primitiveUnitType : 7; // CSSPrimitiveValue::UnitTypes
226     mutable unsigned m_hasCachedCSSText : 1;
227     unsigned m_isQuirkValue : 1;
228
229     unsigned m_valueListSeparator : ValueListSeparatorBits;
230
231 private:
232     unsigned m_classType : ClassTypeBits; // ClassType
233 };
234
235 template<typename CSSValueType>
236 inline bool compareCSSValueVector(const Vector<RefPtr<CSSValueType>>& firstVector, const Vector<RefPtr<CSSValueType>>& secondVector)
237 {
238     size_t size = firstVector.size();
239     if (size != secondVector.size())
240         return false;
241
242     for (size_t i = 0; i < size; i++) {
243         const RefPtr<CSSValueType>& firstPtr = firstVector[i];
244         const RefPtr<CSSValueType>& secondPtr = secondVector[i];
245         if (firstPtr == secondPtr || (firstPtr && secondPtr && firstPtr->equals(*secondPtr)))
246             continue;
247         return false;
248     }
249     return true;
250 }
251
252 template<typename CSSValueType>
253 inline bool compareCSSValuePtr(const RefPtr<CSSValueType>& first, const RefPtr<CSSValueType>& second)
254 {
255     return first ? second && first->equals(*second) : !second;
256 }
257
258 template<typename CSSValueType>
259 inline bool compareCSSValue(const Ref<CSSValueType>& first, const Ref<CSSValueType>& second)
260 {
261     return first.get().equals(second);
262 }
263
264 } // namespace WebCore
265
266 #define SPECIALIZE_TYPE_TRAITS_CSS_VALUE(ToValueTypeName, predicate) \
267 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::ToValueTypeName) \
268     static bool isType(const WebCore::CSSValue& value) { return value.predicate; } \
269 SPECIALIZE_TYPE_TRAITS_END()
270
271 #endif // CSSValue_h