WebCore:
[WebKit-https.git] / 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 <wtf/PassRefPtr.h>
27
28 namespace WebCore {
29
30 class Counter;
31 class DashboardRegion;
32 struct Length;
33 class Pair;
34 class Rect;
35 class RenderStyle;
36 class StringImpl;
37
38 typedef int ExceptionCode;
39
40 class CSSPrimitiveValue : public CSSValue {
41 public:
42     enum UnitTypes {
43         CSS_UNKNOWN = 0,
44         CSS_NUMBER = 1,
45         CSS_PERCENTAGE = 2,
46         CSS_EMS = 3,
47         CSS_EXS = 4,
48         CSS_PX = 5,
49         CSS_CM = 6,
50         CSS_MM = 7,
51         CSS_IN = 8,
52         CSS_PT = 9,
53         CSS_PC = 10,
54         CSS_DEG = 11,
55         CSS_RAD = 12,
56         CSS_GRAD = 13,
57         CSS_MS = 14,
58         CSS_S = 15,
59         CSS_HZ = 16,
60         CSS_KHZ = 17,
61         CSS_DIMENSION = 18,
62         CSS_STRING = 19,
63         CSS_URI = 20,
64         CSS_IDENT = 21,
65         CSS_ATTR = 22,
66         CSS_COUNTER = 23,
67         CSS_RECT = 24,
68         CSS_RGBCOLOR = 25,
69         CSS_PAIR = 100, // We envision this being exposed as a means of getting computed style values for pairs (border-spacing/radius, background-position, etc.)
70         CSS_DASHBOARD_REGION = 101 // FIXME: What on earth is this doing as a primitive value? It should not be!
71     };
72
73     // FIXME: int vs. unsigned overloading is too tricky for color vs. ident
74     CSSPrimitiveValue();
75     CSSPrimitiveValue(int ident);
76     CSSPrimitiveValue(double, UnitTypes);
77     CSSPrimitiveValue(const String&, UnitTypes);
78     CSSPrimitiveValue(unsigned color); // RGB value
79     CSSPrimitiveValue(const Length&);
80     template<typename T> CSSPrimitiveValue(T); // Defined in CSSPrimitiveValueMappings.h
81     template<typename T> CSSPrimitiveValue(T* val) { init(PassRefPtr<T>(val)); }
82     template<typename T> CSSPrimitiveValue(PassRefPtr<T> val) { init(val); }
83
84     virtual ~CSSPrimitiveValue();
85
86     void cleanup();
87
88     unsigned short primitiveType() const { return m_type; }
89
90     /*
91      * computes a length in pixels out of the given CSSValue. Need the RenderStyle to get
92      * the fontinfo in case val is defined in em or ex.
93      *
94      * The metrics have to be a bit different for screen and printer output.
95      * For screen output we assume 1 inch == 72 px, for printer we assume 300 dpi
96      *
97      * this is screen/printer dependent, so we probably need a config option for this,
98      * and some tool to calibrate.
99      */
100     int computeLengthInt(RenderStyle*);
101     int computeLengthInt(RenderStyle*, double multiplier);
102     int computeLengthIntForLength(RenderStyle*);
103     int computeLengthIntForLength(RenderStyle*, double multiplier);
104     short computeLengthShort(RenderStyle*);
105     short computeLengthShort(RenderStyle*, double multiplier);
106     float computeLengthFloat(RenderStyle*, bool applyZoomFactor = true);
107     double computeLengthDouble(RenderStyle*, bool applyZoomFactor = true);
108
109     // use with care!!!
110     void setPrimitiveType(unsigned short type) { m_type = type; }
111
112     double getDoubleValue(unsigned short unitType, ExceptionCode&);
113     double getDoubleValue(unsigned short unitType);
114     double getDoubleValue() const { return m_value.num; }
115
116     void setFloatValue(unsigned short unitType, double floatValue, ExceptionCode&);
117     float getFloatValue(unsigned short unitType, ExceptionCode& ec) { return static_cast<float>(getDoubleValue(unitType, ec)); }
118     float getFloatValue(unsigned short unitType) { return static_cast<float>(getDoubleValue(unitType)); }
119     float getFloatValue() const { return static_cast<float>(m_value.num); }
120
121     int getIntValue(unsigned short unitType, ExceptionCode& ec) { return static_cast<int>(getDoubleValue(unitType, ec)); }
122     int getIntValue(unsigned short unitType) { return static_cast<int>(getDoubleValue(unitType)); }
123     int getIntValue() const { return static_cast<int>(m_value.num); }
124
125     void setStringValue(unsigned short stringType, const String& stringValue, ExceptionCode&);
126     String getStringValue(ExceptionCode&) const;
127     String getStringValue() const;
128
129     Counter* getCounterValue(ExceptionCode&) const;
130     Counter* getCounterValue() const { return m_type != CSS_COUNTER ? 0 : m_value.counter; }
131
132     Rect* getRectValue(ExceptionCode&) const;
133     Rect* getRectValue() const { return m_type != CSS_RECT ? 0 : m_value.rect; }
134
135     unsigned getRGBColorValue(ExceptionCode&) const;
136     unsigned getRGBColorValue() const { return m_type != CSS_RGBCOLOR ? 0 : m_value.rgbcolor; }
137
138     Pair* getPairValue(ExceptionCode&) const;
139     Pair* getPairValue() const { return m_type != CSS_PAIR ? 0 : m_value.pair; }
140
141     DashboardRegion* getDashboardRegionValue() const { return m_type != CSS_DASHBOARD_REGION ? 0 : m_value.region; }
142
143     virtual bool isPrimitiveValue() const { return true; }
144
145     virtual unsigned short cssValueType() const;
146
147     int getIdent();
148     template<typename T> operator T() const; // Defined in CSSPrimitiveValueMappings.h
149
150     virtual bool parseString(const String&, bool = false);
151     virtual String cssText() const;
152
153     virtual bool isQuirkValue() { return false; }
154
155 protected:
156     int m_type;
157     union {
158         int ident;
159         double num;
160         StringImpl* string;
161         Counter* counter;
162         Rect* rect;
163         unsigned rgbcolor;
164         Pair* pair;
165         DashboardRegion* region;
166     } m_value;
167
168 private:
169     template<typename T> operator T*(); // compile-time guard
170
171     void init(PassRefPtr<Counter>);
172     void init(PassRefPtr<Rect>);
173     void init(PassRefPtr<Pair>);
174     void init(PassRefPtr<DashboardRegion>); // FIXME: Why is dashboard region a primitive value? This makes no sense.
175 };
176
177 } // namespace WebCore
178
179 #endif // CSSPrimitiveValue_h