6d1f3a9d2fe2ddead0099427b3687b1ab14f07fb
[WebKit-https.git] / WebCore / css / CSSPrimitiveValue.h
1 /*
2  * This file is part of the DOM implementation for KDE.
3  *
4  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
5  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
6  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  */
23
24 #ifndef CSSPrimitiveValue_h
25 #define CSSPrimitiveValue_h
26
27 #include "CSSValue.h"
28 #include <wtf/PassRefPtr.h>
29
30 namespace WebCore {
31
32 class Counter;
33 class DashboardRegion;
34 struct Length;
35 class Pair;
36 class Rect;
37 class RenderStyle;
38 class StringImpl;
39
40 typedef int ExceptionCode;
41
42 class CSSPrimitiveValue : public CSSValue {
43 public:
44     enum UnitTypes {
45         CSS_UNKNOWN = 0,
46         CSS_NUMBER = 1,
47         CSS_PERCENTAGE = 2,
48         CSS_EMS = 3,
49         CSS_EXS = 4,
50         CSS_PX = 5,
51         CSS_CM = 6,
52         CSS_MM = 7,
53         CSS_IN = 8,
54         CSS_PT = 9,
55         CSS_PC = 10,
56         CSS_DEG = 11,
57         CSS_RAD = 12,
58         CSS_GRAD = 13,
59         CSS_MS = 14,
60         CSS_S = 15,
61         CSS_HZ = 16,
62         CSS_KHZ = 17,
63         CSS_DIMENSION = 18,
64         CSS_STRING = 19,
65         CSS_URI = 20,
66         CSS_IDENT = 21,
67         CSS_ATTR = 22,
68         CSS_COUNTER = 23,
69         CSS_RECT = 24,
70         CSS_RGBCOLOR = 25,
71         CSS_PAIR = 100, // We envision this being exposed as a means of getting computed style values for pairs (border-spacing/radius, background-position, etc.)
72         CSS_DASHBOARD_REGION = 101 // FIXME: What on earth is this doing as a primitive value? It should not be!
73     };
74
75     // FIXME: int vs. unsigned overloading is too tricky for color vs. ident
76     CSSPrimitiveValue();
77     CSSPrimitiveValue(int ident);
78     CSSPrimitiveValue(double, UnitTypes);
79     CSSPrimitiveValue(const String&, UnitTypes);
80     CSSPrimitiveValue(unsigned color); // RGB value
81     CSSPrimitiveValue(const Length&);
82     template<typename T> CSSPrimitiveValue(T); // Defined in CSSPrimitiveValueMappings.h
83     template<typename T> CSSPrimitiveValue(T* val) { init(PassRefPtr<T>(val)); }
84     template<typename T> CSSPrimitiveValue(PassRefPtr<T> val) { init(val); }
85
86     virtual ~CSSPrimitiveValue();
87
88     void cleanup();
89
90     unsigned short primitiveType() const { return m_type; }
91
92     /*
93      * computes a length in pixels out of the given CSSValue. Need the RenderStyle to get
94      * the fontinfo in case val is defined in em or ex.
95      *
96      * The metrics have to be a bit different for screen and printer output.
97      * For screen output we assume 1 inch == 72 px, for printer we assume 300 dpi
98      *
99      * this is screen/printer dependent, so we probably need a config option for this,
100      * and some tool to calibrate.
101      */
102     int computeLengthInt(RenderStyle*);
103     int computeLengthInt(RenderStyle*, double multiplier);
104     int computeLengthIntForLength(RenderStyle*);
105     int computeLengthIntForLength(RenderStyle*, double multiplier);
106     short computeLengthShort(RenderStyle*);
107     short computeLengthShort(RenderStyle*, double multiplier);
108     float computeLengthFloat(RenderStyle*, bool applyZoomFactor = true);
109     double computeLengthDouble(RenderStyle*, bool applyZoomFactor = true);
110
111     // use with care!!!
112     void setPrimitiveType(unsigned short type) { m_type = type; }
113
114     double getDoubleValue(unsigned short unitType);
115     double getDoubleValue() const { return m_value.num; }
116
117     void setFloatValue(unsigned short unitType, double floatValue, ExceptionCode&);
118     float getFloatValue(unsigned short unitType) { return static_cast<float>(getDoubleValue(unitType)); }
119     float getFloatValue() const { return static_cast<float>(m_value.num); }
120     int getIntValue(unsigned short unitType) { return static_cast<int>(getDoubleValue(unitType)); }
121     int getIntValue() const { return static_cast<int>(m_value.num); }
122
123     void setStringValue(unsigned short stringType, const String& stringValue, ExceptionCode&);
124     String getStringValue() const;
125
126     Counter* getCounterValue () const { return m_type != CSS_COUNTER ? 0 : m_value.counter; }
127     Rect* getRectValue () const { return m_type != CSS_RECT ? 0 : m_value.rect; }
128     unsigned getRGBColorValue() const { return m_type != CSS_RGBCOLOR ? 0 : m_value.rgbcolor; }
129     Pair* getPairValue() const { return m_type != CSS_PAIR ? 0 : m_value.pair; }
130
131     DashboardRegion* getDashboardRegionValue () const { return m_type != CSS_DASHBOARD_REGION ? 0 : m_value.region; }
132
133     virtual bool isPrimitiveValue() const { return true; }
134
135     virtual unsigned short cssValueType() const;
136
137     int getIdent();
138     template<typename T> operator T() const; // Defined in CSSPrimitiveValueMappings.h
139
140     virtual bool parseString(const String&, bool = false);
141     virtual String cssText() const;
142
143     virtual bool isQuirkValue() { return false; }
144
145 protected:
146     int m_type;
147     union {
148         int ident;
149         double num;
150         StringImpl* string;
151         Counter* counter;
152         Rect* rect;
153         unsigned rgbcolor;
154         Pair* pair;
155         DashboardRegion* region;
156     } m_value;
157
158 private:
159     template<typename T> operator T*(); // compile-time guard
160
161     void init(PassRefPtr<Counter>);
162     void init(PassRefPtr<Rect>);
163     void init(PassRefPtr<Pair>);
164     void init(PassRefPtr<DashboardRegion>); // FIXME: Why is dashboard region a primitive value? This makes no sense.
165 };
166
167 } // namespace WebCore
168
169 #endif // CSSPrimitiveValue_h