CSSValue: Devirtualize isFooType().
[WebKit-https.git] / Source / WebCore / css / CSSPrimitiveValue.h
1 /*
2  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
4  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public License
17  * along with this library; see the file COPYING.LIB.  If not, write to
18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  * Boston, MA 02110-1301, USA.
20  */
21
22 #ifndef CSSPrimitiveValue_h
23 #define CSSPrimitiveValue_h
24
25 #include "CSSValue.h"
26 #include "Color.h"
27 #include <wtf/Forward.h>
28 #include <wtf/MathExtras.h>
29 #include <wtf/PassRefPtr.h>
30
31 namespace WebCore {
32
33 class Counter;
34 class DashboardRegion;
35 class Pair;
36 class Quad;
37 class RGBColor;
38 class Rect;
39 class RenderStyle;
40 class CSSWrapShape;
41
42 struct Length;
43
44 template<typename T, T max, T min> inline T roundForImpreciseConversion(double value)
45 {
46     // Dimension calculations are imprecise, often resulting in values of e.g.
47     // 44.99998.  We need to go ahead and round if we're really close to the
48     // next integer value.
49     value += (value < 0) ? -0.01 : +0.01;
50     return ((value > max) || (value < min)) ? 0 : static_cast<T>(value);
51 }
52
53 class CSSPrimitiveValue : public CSSValue {
54 public:
55     static const int UnitTypesBits = 8;
56     enum UnitTypes {
57         CSS_UNKNOWN = 0,
58         CSS_NUMBER = 1,
59         CSS_PERCENTAGE = 2,
60         CSS_EMS = 3,
61         CSS_EXS = 4,
62         CSS_PX = 5,
63         CSS_CM = 6,
64         CSS_MM = 7,
65         CSS_IN = 8,
66         CSS_PT = 9,
67         CSS_PC = 10,
68         CSS_DEG = 11,
69         CSS_RAD = 12,
70         CSS_GRAD = 13,
71         CSS_MS = 14,
72         CSS_S = 15,
73         CSS_HZ = 16,
74         CSS_KHZ = 17,
75         CSS_DIMENSION = 18,
76         CSS_STRING = 19,
77         CSS_URI = 20,
78         CSS_IDENT = 21,
79         CSS_ATTR = 22,
80         CSS_COUNTER = 23,
81         CSS_RECT = 24,
82         CSS_RGBCOLOR = 25,
83         CSS_PAIR = 100, // We envision this being exposed as a means of getting computed style values for pairs (border-spacing/radius, background-position, etc.)
84         CSS_DASHBOARD_REGION = 101, // FIXME: Dashboard region should not be a primitive value.
85         CSS_UNICODE_RANGE = 102,
86
87         // These next types are just used internally to allow us to translate back and forth from CSSPrimitiveValues to CSSParserValues.
88         CSS_PARSER_OPERATOR = 103,
89         CSS_PARSER_INTEGER = 104,
90         CSS_PARSER_HEXCOLOR = 105,
91
92         // This is used internally for unknown identifiers
93         CSS_PARSER_IDENTIFIER = 106,
94
95         // These are from CSS3 Values and Units, but that isn't a finished standard yet
96         CSS_TURN = 107,
97         CSS_REMS = 108,
98
99         // This is used internally for counter names (as opposed to counter values)
100         CSS_COUNTER_NAME = 109,
101
102         // This is used by the CSS Exclusions draft
103         CSS_SHAPE = 110,
104
105         // Used by border images.
106         CSS_QUAD = 111
107     };
108
109     // This enum follows the CSSParser::Units enum augmented with UNIT_FREQUENCY for frequencies.
110     enum UnitCategory {
111         UNumber,
112         UPercent,
113         ULength,
114         UAngle,
115         UTime,
116         UFrequency,
117         UOther
118     };
119
120     static bool isUnitTypeLength(int type) { return (type > CSSPrimitiveValue::CSS_PERCENTAGE && type < CSSPrimitiveValue::CSS_DEG) ||
121                                                     type == CSSPrimitiveValue::CSS_REMS; }
122
123     bool isLength() const { return isUnitTypeLength(m_type); }
124
125     static PassRefPtr<CSSPrimitiveValue> createIdentifier(int identifier) { return adoptRef(new CSSPrimitiveValue(identifier)); }
126     static PassRefPtr<CSSPrimitiveValue> createColor(unsigned rgbValue) { return adoptRef(new CSSPrimitiveValue(rgbValue)); }
127     static PassRefPtr<CSSPrimitiveValue> create(double value, UnitTypes type) { return adoptRef(new CSSPrimitiveValue(value, type)); }
128     static PassRefPtr<CSSPrimitiveValue> create(const String& value, UnitTypes type) { return adoptRef(new CSSPrimitiveValue(value, type)); }
129
130     template<typename T> static PassRefPtr<CSSPrimitiveValue> create(T value)
131     {
132         return adoptRef(new CSSPrimitiveValue(value));
133     }
134
135     // This value is used to handle quirky margins in reflow roots (body, td, and th) like WinIE.
136     // The basic idea is that a stylesheet can use the value __qem (for quirky em) instead of em.
137     // When the quirky value is used, if you're in quirks mode, the margin will collapse away
138     // inside a table cell.
139     static PassRefPtr<CSSPrimitiveValue> createAllowingMarginQuirk(double value, UnitTypes type)
140     {
141         CSSPrimitiveValue* quirkValue = new CSSPrimitiveValue(value, type);
142         quirkValue->m_isQuirkValue = true;
143         return adoptRef(quirkValue);
144     }
145
146     virtual ~CSSPrimitiveValue();
147
148     void cleanup();
149
150     unsigned short primitiveType() const { return m_type; }
151
152     /*
153      * computes a length in pixels out of the given CSSValue. Need the RenderStyle to get
154      * the fontinfo in case val is defined in em or ex.
155      *
156      * The metrics have to be a bit different for screen and printer output.
157      * For screen output we assume 1 inch == 72 px, for printer we assume 300 dpi
158      *
159      * this is screen/printer dependent, so we probably need a config option for this,
160      * and some tool to calibrate.
161      */
162     template<typename T> T computeLength(RenderStyle* currStyle, RenderStyle* rootStyle, double multiplier = 1.0, bool computingFontSize = false);
163
164     // use with care!!!
165     void setPrimitiveType(unsigned short type) { m_type = type; }
166
167     double getDoubleValue(unsigned short unitType, ExceptionCode&) const;
168     double getDoubleValue(unsigned short unitType) const;
169     double getDoubleValue() const { return m_value.num; }
170
171     void setFloatValue(unsigned short unitType, double floatValue, ExceptionCode&);
172     float getFloatValue(unsigned short unitType, ExceptionCode& ec) const { return getValue<float>(unitType, ec); }
173     float getFloatValue(unsigned short unitType) const { return getValue<float>(unitType); }
174     float getFloatValue() const { return getValue<float>(); }
175
176     int getIntValue(unsigned short unitType, ExceptionCode& ec) const { return getValue<int>(unitType, ec); }
177     int getIntValue(unsigned short unitType) const { return getValue<int>(unitType); }
178     int getIntValue() const { return getValue<int>(); }
179
180     template<typename T> inline T getValue(unsigned short unitType, ExceptionCode& ec) const { return clampTo<T>(getDoubleValue(unitType, ec)); }
181     template<typename T> inline T getValue(unsigned short unitType) const { return clampTo<T>(getDoubleValue(unitType)); }
182     template<typename T> inline T getValue() const { return clampTo<T>(m_value.num); }
183
184     void setStringValue(unsigned short stringType, const String& stringValue, ExceptionCode&);
185     String getStringValue(ExceptionCode&) const;
186     String getStringValue() const;
187
188     Counter* getCounterValue(ExceptionCode&) const;
189     Counter* getCounterValue() const { return m_type != CSS_COUNTER ? 0 : m_value.counter; }
190
191     Rect* getRectValue(ExceptionCode&) const;
192     Rect* getRectValue() const { return m_type != CSS_RECT ? 0 : m_value.rect; }
193
194     Quad* getQuadValue(ExceptionCode&) const;
195     Quad* getQuadValue() const { return m_type != CSS_QUAD ? 0 : m_value.quad; }
196
197     PassRefPtr<RGBColor> getRGBColorValue(ExceptionCode&) const;
198     RGBA32 getRGBA32Value() const { return m_type != CSS_RGBCOLOR ? 0 : m_value.rgbcolor; }
199
200     Pair* getPairValue(ExceptionCode&) const;
201     Pair* getPairValue() const { return m_type != CSS_PAIR ? 0 : m_value.pair; }
202
203     DashboardRegion* getDashboardRegionValue() const { return m_type != CSS_DASHBOARD_REGION ? 0 : m_value.region; }
204
205     CSSWrapShape* getShapeValue() const { return m_type != CSS_SHAPE ? 0 : m_value.shape; }
206
207     int getIdent() const;
208     template<typename T> inline operator T() const; // Defined in CSSPrimitiveValueMappings.h
209
210     virtual String cssText() const;
211
212     bool isQuirkValue() { return m_isQuirkValue; }
213
214     virtual void addSubresourceStyleURLs(ListHashSet<KURL>&, const CSSStyleSheet*);
215
216 protected:
217     CSSPrimitiveValue(ClassType, int ident);
218     CSSPrimitiveValue(ClassType, const String&, UnitTypes);
219
220 private:
221     CSSPrimitiveValue();
222     // FIXME: int vs. unsigned overloading is too subtle to distinguish the color and identifier cases.
223     explicit CSSPrimitiveValue(int ident);
224     explicit CSSPrimitiveValue(unsigned color); // RGB value
225     explicit CSSPrimitiveValue(const Length&);
226     CSSPrimitiveValue(const String&, UnitTypes);
227     CSSPrimitiveValue(double, UnitTypes);
228
229     template<typename T> CSSPrimitiveValue(T); // Defined in CSSPrimitiveValueMappings.h
230     template<typename T> CSSPrimitiveValue(T* val)
231         : CSSValue(PrimitiveClass)
232     {
233         init(PassRefPtr<T>(val));
234     }
235
236     template<typename T> CSSPrimitiveValue(PassRefPtr<T> val)
237         : CSSValue(PrimitiveClass)
238     {
239         init(val);
240     }
241
242     static void create(int); // compile-time guard
243     static void create(unsigned); // compile-time guard
244     template<typename T> operator T*(); // compile-time guard
245
246     static PassRefPtr<CSSPrimitiveValue> createUncachedIdentifier(int identifier);
247     static PassRefPtr<CSSPrimitiveValue> createUncachedColor(unsigned rgbValue);
248     static PassRefPtr<CSSPrimitiveValue> createUncached(double value, UnitTypes type);
249
250     static UnitTypes canonicalUnitTypeForCategory(UnitCategory category);
251
252     void init(PassRefPtr<Counter>);
253     void init(PassRefPtr<Rect>);
254     void init(PassRefPtr<Pair>);
255     void init(PassRefPtr<Quad>);
256     void init(PassRefPtr<DashboardRegion>); // FIXME: Dashboard region should not be a primitive value.
257     void init(PassRefPtr<CSSWrapShape>);
258
259     bool getDoubleValueInternal(UnitTypes targetUnitType, double* result) const;
260
261     double computeLengthDouble(RenderStyle* currentStyle, RenderStyle* rootStyle, double multiplier, bool computingFontSize);
262
263     signed m_type : UnitTypesBits;
264     mutable unsigned m_hasCachedCSSText : 1;
265     unsigned m_isQuirkValue : 1;
266     union {
267         int ident;
268         double num;
269         StringImpl* string;
270         Counter* counter;
271         Rect* rect;
272         Quad* quad;
273         unsigned rgbcolor;
274         Pair* pair;
275         DashboardRegion* region;
276         CSSWrapShape* shape;
277     } m_value;
278 };
279
280 } // namespace WebCore
281
282 #endif // CSSPrimitiveValue_h