Generate toCSSFooValue() for CSSCanvasValue
[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 isFontFeatureValue() const { return m_classType == FontFeatureClass; }
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 isReflectValue() const { return m_classType == ReflectClass; }
89     bool isShadowValue() const { return m_classType == ShadowClass; }
90     bool isCubicBezierTimingFunctionValue() const { return m_classType == CubicBezierTimingFunctionClass; }
91     bool isStepsTimingFunctionValue() const { return m_classType == StepsTimingFunctionClass; }
92     bool isWebKitCSSTransformValue() const { return m_classType == WebKitCSSTransformClass; }
93     bool isLineBoxContainValue() const { return m_classType == LineBoxContainClass; }
94     bool isCalculationValue() const {return m_classType == CalculationClass; }
95 #if ENABLE(CSS_FILTERS)
96     bool isFilterImageValue() const { return m_classType == FilterImageClass; }
97     bool isWebKitCSSFilterValue() const { return m_classType == WebKitCSSFilterClass; }
98 #if ENABLE(CSS_SHADERS)
99     bool isWebKitCSSArrayFunctionValue() const { return m_classType == WebKitCSSArrayFunctionValueClass; }
100     bool isWebKitCSSMatFunctionValue() const { return m_classType == WebKitCSSMatFunctionValueClass; }
101     bool isWebKitCSSMixFunctionValue() const { return m_classType == WebKitCSSMixFunctionValueClass; }
102     bool isWebKitCSSShaderValue() const { return m_classType == WebKitCSSShaderClass; }
103 #endif
104 #endif // ENABLE(CSS_FILTERS)
105 #if ENABLE(CSS_VARIABLES)
106     bool isVariableValue() const { return m_classType == VariableClass; }
107 #endif
108 #if ENABLE(SVG)
109     bool isSVGColor() const { return m_classType == SVGColorClass || m_classType == SVGPaintClass; }
110     bool isSVGPaint() const { return m_classType == SVGPaintClass; }
111     bool isWebKitCSSSVGDocumentValue() const { return m_classType == WebKitCSSSVGDocumentClass; }
112 #endif
113     
114     bool isCSSOMSafe() const { return m_isCSSOMSafe; }
115     bool isSubtypeExposedToCSSOM() const
116     { 
117         return isPrimitiveValue() 
118 #if ENABLE(SVG)
119             || isSVGColor()
120 #endif
121             || isValueList();
122     }
123
124     PassRefPtr<CSSValue> cloneForCSSOM() const;
125
126     void addSubresourceStyleURLs(ListHashSet<URL>&, const StyleSheetContents*) const;
127
128     bool hasFailedOrCanceledSubresources() const;
129
130     bool equals(const CSSValue&) const;
131
132 protected:
133
134     static const size_t ClassTypeBits = 6;
135     enum ClassType {
136         PrimitiveClass,
137
138         // Image classes.
139         ImageClass,
140         CursorImageClass,
141
142         // Image generator classes.
143         CanvasClass,
144         CrossfadeClass,
145 #if ENABLE(CSS_FILTERS)
146         FilterImageClass,
147 #endif
148         LinearGradientClass,
149         RadialGradientClass,
150
151         // Timing function classes.
152         CubicBezierTimingFunctionClass,
153         StepsTimingFunctionClass,
154
155         // Other class types.
156         AspectRatioClass,
157         BorderImageSliceClass,
158         FontFeatureClass,
159         FontClass,
160         FontFaceSrcClass,
161         FunctionClass,
162
163         InheritedClass,
164         InitialClass,
165
166         ReflectClass,
167         ShadowClass,
168         UnicodeRangeClass,
169         LineBoxContainClass,
170         CalculationClass,
171 #if ENABLE(CSS_FILTERS) && ENABLE(CSS_SHADERS)
172         WebKitCSSShaderClass,
173 #endif
174 #if ENABLE(CSS_VARIABLES)
175         VariableClass,
176 #endif
177 #if ENABLE(SVG)
178         SVGColorClass,
179         SVGPaintClass,
180         WebKitCSSSVGDocumentClass,
181 #endif
182
183         // List class types must appear after ValueListClass.
184         ValueListClass,
185 #if ENABLE(CSS_IMAGE_SET)
186         ImageSetClass,
187 #endif
188 #if ENABLE(CSS_FILTERS)
189         WebKitCSSFilterClass,
190 #if ENABLE(CSS_SHADERS)
191         WebKitCSSArrayFunctionValueClass,
192         WebKitCSSMatFunctionValueClass,
193         WebKitCSSMixFunctionValueClass,
194 #endif
195 #endif
196         WebKitCSSTransformClass,
197         // Do not append non-list class types here.
198     };
199
200     static const size_t ValueListSeparatorBits = 2;
201     enum ValueListSeparator {
202         SpaceSeparator,
203         CommaSeparator,
204         SlashSeparator
205     };
206
207     ClassType classType() const { return static_cast<ClassType>(m_classType); }
208
209     explicit CSSValue(ClassType classType, bool isCSSOMSafe = false)
210         : m_isCSSOMSafe(isCSSOMSafe)
211         , m_isTextClone(false)
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() { }
224
225 private:
226     void destroy();
227
228 protected:
229     unsigned m_isCSSOMSafe : 1;
230     unsigned m_isTextClone : 1;
231     // The bits in this section are only used by specific subclasses but kept here
232     // to maximize struct packing.
233
234     // CSSPrimitiveValue bits:
235     unsigned m_primitiveUnitType : 7; // CSSPrimitiveValue::UnitTypes
236     mutable unsigned m_hasCachedCSSText : 1;
237     unsigned m_isQuirkValue : 1;
238
239     unsigned m_valueListSeparator : ValueListSeparatorBits;
240
241 private:
242     unsigned m_classType : ClassTypeBits; // ClassType
243 };
244
245 template<typename CSSValueType>
246 inline bool compareCSSValueVector(const Vector<RefPtr<CSSValueType> >& firstVector, const Vector<RefPtr<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         const RefPtr<CSSValueType>& firstPtr = firstVector[i];
254         const RefPtr<CSSValueType>& secondPtr = secondVector[i];
255         if (firstPtr == secondPtr || (firstPtr && secondPtr && 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 #define CSS_VALUE_TYPE_CASTS(ValueTypeName) \
269 inline const CSS##ValueTypeName* toCSS##ValueTypeName(const CSSValue* value) \
270 { \
271     ASSERT_WITH_SECURITY_IMPLICATION(!value || value->is##ValueTypeName()); \
272     return static_cast<const CSS##ValueTypeName*>(value); \
273 } \
274 inline CSS##ValueTypeName* toCSS##ValueTypeName(CSSValue* value) \
275 { \
276     ASSERT_WITH_SECURITY_IMPLICATION(!value || value->is##ValueTypeName()); \
277     return static_cast<CSS##ValueTypeName*>(value); \
278 } \
279 void toCSS##ValueTypeName(const CSS##ValueTypeName*); \
280 void toCSS##ValueTypeName(const CSS##ValueTypeName&);
281
282 } // namespace WebCore
283
284 #endif // CSSValue_h