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