Remove excessive include directives from WebCore/css
[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 #pragma once
23
24 #include "CSSPropertyNames.h"
25 #include "CSSValue.h"
26 #include "CSSValueKeywords.h"
27 #include "Color.h"
28 #include "LayoutUnit.h"
29 #include <utility>
30 #include <wtf/Forward.h>
31 #include <wtf/MathExtras.h>
32
33 namespace WebCore {
34
35 class CSSBasicShape;
36 class CSSCalcValue;
37 class CSSToLengthConversionData;
38 class Counter;
39 class DashboardRegion;
40 class DeprecatedCSSOMPrimitiveValue;
41 class Pair;
42 class Quad;
43 class RGBColor;
44 class Rect;
45 class RenderStyle;
46
47 struct CSSFontFamily;
48 struct Length;
49 struct LengthSize;
50
51 // Max/min values for CSS, needs to slightly smaller/larger than the true max/min values to allow for rounding without overflowing.
52 // Subtract two (rather than one) to allow for values to be converted to float and back without exceeding the LayoutUnit::max.
53 const int maxValueForCssLength = intMaxForLayoutUnit - 2;
54 const int minValueForCssLength = intMinForLayoutUnit + 2;
55
56 // Dimension calculations are imprecise, often resulting in values of e.g.
57 // 44.99998. We need to round if we're really close to the next integer value.
58 template<typename T> inline T roundForImpreciseConversion(double value)
59 {
60     value += (value < 0) ? -0.01 : +0.01;
61     return ((value > std::numeric_limits<T>::max()) || (value < std::numeric_limits<T>::min())) ? 0 : static_cast<T>(value);
62 }
63
64 template<> inline float roundForImpreciseConversion(double value)
65 {
66     double ceiledValue = ceil(value);
67     double proximityToNextInt = ceiledValue - value;
68     if (proximityToNextInt <= 0.01 && value > 0)
69         return static_cast<float>(ceiledValue);
70     if (proximityToNextInt >= 0.99 && value < 0)
71         return static_cast<float>(floor(value));
72     return static_cast<float>(value);
73 }
74
75 class CSSPrimitiveValue final : public CSSValue {
76 public:
77     enum UnitType {
78         CSS_UNKNOWN = 0,
79         CSS_NUMBER = 1,
80         CSS_PERCENTAGE = 2,
81         CSS_EMS = 3,
82         CSS_EXS = 4,
83         CSS_PX = 5,
84         CSS_CM = 6,
85         CSS_MM = 7,
86         CSS_IN = 8,
87         CSS_PT = 9,
88         CSS_PC = 10,
89         CSS_DEG = 11,
90         CSS_RAD = 12,
91         CSS_GRAD = 13,
92         CSS_MS = 14,
93         CSS_S = 15,
94         CSS_HZ = 16,
95         CSS_KHZ = 17,
96         CSS_DIMENSION = 18,
97         CSS_STRING = 19,
98         CSS_URI = 20,
99         CSS_IDENT = 21,
100         CSS_ATTR = 22,
101         CSS_COUNTER = 23,
102         CSS_RECT = 24,
103         CSS_RGBCOLOR = 25,
104         // From CSS Values and Units. Viewport-percentage Lengths (vw/vh/vmin/vmax).
105         CSS_VW = 26,
106         CSS_VH = 27,
107         CSS_VMIN = 28,
108         CSS_VMAX = 29,
109         CSS_DPPX = 30,
110         CSS_DPI = 31,
111         CSS_DPCM = 32,
112         CSS_FR = 33,
113         CSS_PAIR = 100, // We envision this being exposed as a means of getting computed style values for pairs (border-spacing/radius, background-position, etc.)
114 #if ENABLE(DASHBOARD_SUPPORT)
115         CSS_DASHBOARD_REGION = 101, // FIXME: Dashboard region should not be a primitive value.
116 #endif
117         CSS_UNICODE_RANGE = 102,
118
119         // These are from CSS3 Values and Units, but that isn't a finished standard yet
120         CSS_TURN = 107,
121         CSS_REMS = 108,
122         CSS_CHS = 109,
123
124         // This is used internally for counter names (as opposed to counter values)
125         CSS_COUNTER_NAME = 110,
126
127         // This is used by the CSS Shapes draft
128         CSS_SHAPE = 111,
129
130         // Used by border images.
131         CSS_QUAD = 112,
132
133         CSS_CALC = 113,
134         CSS_CALC_PERCENTAGE_WITH_NUMBER = 114,
135         CSS_CALC_PERCENTAGE_WITH_LENGTH = 115,
136
137         CSS_FONT_FAMILY = 116,
138
139         CSS_PROPERTY_ID = 117,
140         CSS_VALUE_ID = 118,
141         
142         // This value is used to handle quirky margins in reflow roots (body, td, and th) like WinIE.
143         // The basic idea is that a stylesheet can use the value __qem (for quirky em) instead of em.
144         // When the quirky value is used, if you're in quirks mode, the margin will collapse away
145         // inside a table cell. This quirk is specified in the HTML spec but our impl is different.
146         CSS_QUIRKY_EMS = 120
147     };
148
149     // This enum follows the CSSParser::Units enum augmented with UNIT_FREQUENCY for frequencies.
150     enum UnitCategory {
151         UNumber,
152         UPercent,
153         ULength,
154         UAngle,
155         UTime,
156         UFrequency,
157 #if ENABLE(CSS_IMAGE_RESOLUTION) || ENABLE(RESOLUTION_MEDIA_QUERY)
158         UResolution,
159 #endif
160         UOther
161     };
162     static UnitCategory unitCategory(UnitType);
163
164     bool isAngle() const;
165     bool isAttr() const { return m_primitiveUnitType == CSS_ATTR; }
166     bool isCounter() const { return m_primitiveUnitType == CSS_COUNTER; }
167     bool isFontIndependentLength() const { return m_primitiveUnitType >= CSS_PX && m_primitiveUnitType <= CSS_PC; }
168     static bool isFontRelativeLength(UnitType);
169     bool isFontRelativeLength() const { return isFontRelativeLength(static_cast<UnitType>(m_primitiveUnitType)); }
170     
171     bool isQuirkyEms() const { return primitiveType() == UnitType::CSS_QUIRKY_EMS; }
172
173     static bool isViewportPercentageLength(UnitType type) { return type >= CSS_VW && type <= CSS_VMAX; }
174     bool isViewportPercentageLength() const { return isViewportPercentageLength(static_cast<UnitType>(m_primitiveUnitType)); }
175
176     static bool isLength(UnitType);
177     bool isLength() const { return isLength(static_cast<UnitType>(primitiveType())); }
178     bool isNumber() const { return primitiveType() == CSS_NUMBER; }
179     bool isPercentage() const { return primitiveType() == CSS_PERCENTAGE; }
180     bool isPx() const { return primitiveType() == CSS_PX; }
181     bool isRect() const { return m_primitiveUnitType == CSS_RECT; }
182     bool isPair() const { return m_primitiveUnitType == CSS_PAIR; }
183     bool isPropertyID() const { return m_primitiveUnitType == CSS_PROPERTY_ID; }
184     bool isRGBColor() const { return m_primitiveUnitType == CSS_RGBCOLOR; }
185     bool isShape() const { return m_primitiveUnitType == CSS_SHAPE; }
186     bool isString() const { return m_primitiveUnitType == CSS_STRING; }
187     bool isFontFamily() const { return m_primitiveUnitType == CSS_FONT_FAMILY; }
188     bool isTime() const { return m_primitiveUnitType == CSS_S || m_primitiveUnitType == CSS_MS; }
189     bool isURI() const { return m_primitiveUnitType == CSS_URI; }
190     bool isCalculated() const { return m_primitiveUnitType == CSS_CALC; }
191     bool isCalculatedPercentageWithNumber() const { return primitiveType() == CSS_CALC_PERCENTAGE_WITH_NUMBER; }
192     bool isCalculatedPercentageWithLength() const { return primitiveType() == CSS_CALC_PERCENTAGE_WITH_LENGTH; }
193     bool isDotsPerInch() const { return primitiveType() == CSS_DPI; }
194     bool isDotsPerPixel() const { return primitiveType() == CSS_DPPX; }
195     bool isDotsPerCentimeter() const { return primitiveType() == CSS_DPCM; }
196
197     static bool isResolution(UnitType);
198     bool isResolution() const { return isResolution(static_cast<UnitType>(primitiveType())); }
199     bool isViewportPercentageWidth() const { return m_primitiveUnitType == CSS_VW; }
200     bool isViewportPercentageHeight() const { return m_primitiveUnitType == CSS_VH; }
201     bool isViewportPercentageMax() const { return m_primitiveUnitType == CSS_VMAX; }
202     bool isViewportPercentageMin() const { return m_primitiveUnitType == CSS_VMIN; }
203     bool isValueID() const { return m_primitiveUnitType == CSS_VALUE_ID; }
204     bool isFlex() const { return primitiveType() == CSS_FR; }
205
206     static Ref<CSSPrimitiveValue> createIdentifier(CSSValueID valueID) { return adoptRef(*new CSSPrimitiveValue(valueID)); }
207     static Ref<CSSPrimitiveValue> createIdentifier(CSSPropertyID propertyID) { return adoptRef(*new CSSPrimitiveValue(propertyID)); }
208
209     static Ref<CSSPrimitiveValue> create(double value, UnitType type) { return adoptRef(*new CSSPrimitiveValue(value, type)); }
210     static Ref<CSSPrimitiveValue> create(const String& value, UnitType type) { return adoptRef(*new CSSPrimitiveValue(value, type)); }
211     static Ref<CSSPrimitiveValue> create(const Length& value, const RenderStyle& style) { return adoptRef(*new CSSPrimitiveValue(value, style)); }
212     static Ref<CSSPrimitiveValue> create(const LengthSize& value, const RenderStyle& style) { return adoptRef(*new CSSPrimitiveValue(value, style)); }
213
214     template<typename T> static Ref<CSSPrimitiveValue> create(T&&);
215
216     // This value is used to handle quirky margins in reflow roots (body, td, and th) like WinIE.
217     // The basic idea is that a stylesheet can use the value __qem (for quirky em) instead of em.
218     // When the quirky value is used, if you're in quirks mode, the margin will collapse away
219     // inside a table cell.
220     static Ref<CSSPrimitiveValue> createAllowingMarginQuirk(double value, UnitType);
221
222     ~CSSPrimitiveValue();
223
224     void cleanup();
225
226     WEBCORE_EXPORT unsigned short primitiveType() const;
227     WEBCORE_EXPORT ExceptionOr<void> setFloatValue(unsigned short unitType, double floatValue);
228     WEBCORE_EXPORT ExceptionOr<float> getFloatValue(unsigned short unitType) const;
229     WEBCORE_EXPORT ExceptionOr<void> setStringValue(unsigned short stringType, const String& stringValue);
230     WEBCORE_EXPORT ExceptionOr<String> getStringValue() const;
231     WEBCORE_EXPORT ExceptionOr<Counter&> getCounterValue() const;
232     WEBCORE_EXPORT ExceptionOr<Rect&> getRectValue() const;
233     WEBCORE_EXPORT ExceptionOr<Ref<RGBColor>> getRGBColorValue() const;
234
235     double computeDegrees() const;
236     
237     enum TimeUnit { Seconds, Milliseconds };
238     template<typename T, TimeUnit timeUnit> T computeTime() const;
239
240     template<typename T> T computeLength(const CSSToLengthConversionData&) const;
241     template<int> Length convertToLength(const CSSToLengthConversionData&) const;
242
243     bool convertingToLengthRequiresNonNullStyle(int lengthConversion) const;
244
245     double doubleValue(UnitType) const;
246     double doubleValue() const;
247
248     template<typename T> inline T value(UnitType type) const { return clampTo<T>(doubleValue(type)); }
249     template<typename T> inline T value() const { return clampTo<T>(doubleValue()); }
250
251     float floatValue(UnitType type) const { return value<float>(type); }
252     float floatValue() const { return value<float>(); }
253
254     int intValue(UnitType type) const { return value<int>(type); }
255     int intValue() const { return value<int>(); }
256
257     WEBCORE_EXPORT String stringValue() const;
258
259     const Color& color() const { ASSERT(m_primitiveUnitType == CSS_RGBCOLOR); return *m_value.color; }
260     Counter* counterValue() const { return m_primitiveUnitType != CSS_COUNTER ? nullptr : m_value.counter; }
261     CSSCalcValue* cssCalcValue() const { return m_primitiveUnitType != CSS_CALC ? nullptr : m_value.calc; }
262     const CSSFontFamily& fontFamily() const { ASSERT(m_primitiveUnitType == CSS_FONT_FAMILY); return *m_value.fontFamily; }
263     Pair* pairValue() const { return m_primitiveUnitType != CSS_PAIR ? nullptr : m_value.pair; }
264     CSSPropertyID propertyID() const { return m_primitiveUnitType == CSS_PROPERTY_ID ? m_value.propertyID : CSSPropertyInvalid; }
265     Quad* quadValue() const { return m_primitiveUnitType != CSS_QUAD ? nullptr : m_value.quad; }
266     Rect* rectValue() const { return m_primitiveUnitType != CSS_RECT ? nullptr : m_value.rect; }
267     CSSBasicShape* shapeValue() const { return m_primitiveUnitType != CSS_SHAPE ? nullptr : m_value.shape; }
268     CSSValueID valueID() const { return m_primitiveUnitType == CSS_VALUE_ID ? m_value.valueID : CSSValueInvalid; }
269
270 #if ENABLE(DASHBOARD_SUPPORT)
271     DashboardRegion* dashboardRegionValue() const { return m_primitiveUnitType != CSS_DASHBOARD_REGION ? nullptr : m_value.region; }
272 #endif
273
274     template<typename T> inline operator T() const; // Defined in CSSPrimitiveValueMappings.h
275
276     String customCSSText() const;
277
278     // FIXME-NEWPARSER: Can ditch the boolean and just use the unit type once old parser is gone.
279     bool isQuirkValue() const { return m_isQuirkValue || primitiveType() == CSS_QUIRKY_EMS; }
280
281     bool equals(const CSSPrimitiveValue&) const;
282
283     static UnitType canonicalUnitTypeForCategory(UnitCategory);
284     static double conversionToCanonicalUnitsScaleFactor(UnitType);
285
286     static double computeNonCalcLengthDouble(const CSSToLengthConversionData&, UnitType, double value);
287
288     Ref<DeprecatedCSSOMPrimitiveValue> createDeprecatedCSSOMPrimitiveWrapper() const;
289
290 #if COMPILER(MSVC)
291     // FIXME: This should be private, but for some reason MSVC then fails to invoke it from LazyNeverDestroyed::construct.
292 public:
293 #else
294 private:
295     friend class CSSValuePool;
296     friend class LazyNeverDestroyed<CSSPrimitiveValue>;
297 #endif
298
299     CSSPrimitiveValue(CSSValueID);
300     CSSPrimitiveValue(CSSPropertyID);
301     CSSPrimitiveValue(const Color&);
302     CSSPrimitiveValue(const Length&);
303     CSSPrimitiveValue(const Length&, const RenderStyle&);
304     CSSPrimitiveValue(const LengthSize&, const RenderStyle&);
305     CSSPrimitiveValue(const String&, UnitType);
306     CSSPrimitiveValue(double, UnitType);
307
308     template<typename T> CSSPrimitiveValue(T); // Defined in CSSPrimitiveValueMappings.h
309     template<typename T> CSSPrimitiveValue(RefPtr<T>&&);
310     template<typename T> CSSPrimitiveValue(Ref<T>&&);
311
312     static void create(int); // compile-time guard
313     static void create(unsigned); // compile-time guard
314     template<typename T> operator T*(); // compile-time guard
315
316     void init(const Length&);
317     void init(const LengthSize&, const RenderStyle&);
318     void init(Ref<CSSBasicShape>&&);
319     void init(RefPtr<CSSCalcValue>&&);
320     void init(Ref<Counter>&&);
321     void init(Ref<Pair>&&);
322     void init(Ref<Quad>&&);
323     void init(Ref<Rect>&&);
324
325 #if ENABLE(DASHBOARD_SUPPORT)
326     void init(RefPtr<DashboardRegion>&&); // FIXME: Dashboard region should not be a primitive value.
327 #endif
328
329     std::optional<double> doubleValueInternal(UnitType targetUnitType) const;
330
331     double computeLengthDouble(const CSSToLengthConversionData&) const;
332
333     ALWAYS_INLINE String formatNumberForCustomCSSText() const;
334     template<unsigned characterCount> ALWAYS_INLINE Ref<StringImpl> formatNumberValue(const char (&characters)[characterCount]) const;
335     NEVER_INLINE Ref<StringImpl> formatNumberValue(const char* suffix, unsigned suffixLength) const;
336
337     union {
338         CSSPropertyID propertyID;
339         CSSValueID valueID;
340         double num;
341         StringImpl* string;
342         Counter* counter;
343         Rect* rect;
344         Quad* quad;
345         const Color* color;
346         Pair* pair;
347         DashboardRegion* region;
348         CSSBasicShape* shape;
349         CSSCalcValue* calc;
350         const CSSFontFamily* fontFamily;
351     } m_value;
352 };
353
354 inline bool CSSPrimitiveValue::isAngle() const
355 {
356     return m_primitiveUnitType == CSS_DEG
357         || m_primitiveUnitType == CSS_RAD
358         || m_primitiveUnitType == CSS_GRAD
359         || m_primitiveUnitType == CSS_TURN;
360 }
361
362 inline bool CSSPrimitiveValue::isFontRelativeLength(UnitType type)
363 {
364     return type == CSS_EMS
365         || type == CSS_EXS
366         || type == CSS_REMS
367         || type == CSS_CHS
368         || type == CSS_QUIRKY_EMS;
369 }
370
371 inline bool CSSPrimitiveValue::isLength(UnitType type)
372 {
373     return (type >= CSS_EMS && type <= CSS_PC)
374         || type == CSS_REMS
375         || type == CSS_CHS
376         || isViewportPercentageLength(type)
377         || type == CSS_QUIRKY_EMS;
378 }
379
380 inline bool CSSPrimitiveValue::isResolution(UnitType type)
381 {
382     return type >= CSS_DPPX && type <= CSS_DPCM;
383 }
384
385 template<typename T> inline Ref<CSSPrimitiveValue> CSSPrimitiveValue::create(T&& value)
386 {
387     return adoptRef(*new CSSPrimitiveValue(std::forward<T>(value)));
388 }
389
390 inline Ref<CSSPrimitiveValue> CSSPrimitiveValue::createAllowingMarginQuirk(double value, UnitType type)
391 {
392     auto result = adoptRef(*new CSSPrimitiveValue(value, type));
393     result->m_isQuirkValue = true;
394     return result;
395 }
396
397 template<typename T, CSSPrimitiveValue::TimeUnit timeUnit> inline T CSSPrimitiveValue::computeTime() const
398 {
399     if (timeUnit == Seconds && primitiveType() == CSS_S)
400         return value<T>();
401     if (timeUnit == Seconds && primitiveType() == CSS_MS)
402         return value<T>() / 1000;
403     if (timeUnit == Milliseconds && primitiveType() == CSS_MS)
404         return value<T>();
405     if (timeUnit == Milliseconds && primitiveType() == CSS_S)
406         return value<T>() * 1000;
407     ASSERT_NOT_REACHED();
408     return 0;
409 }
410
411 template<typename T> inline CSSPrimitiveValue::CSSPrimitiveValue(RefPtr<T>&& value)
412     : CSSValue(PrimitiveClass)
413 {
414     init(WTFMove(value));
415 }
416
417 template<typename T> inline CSSPrimitiveValue::CSSPrimitiveValue(Ref<T>&& value)
418     : CSSValue(PrimitiveClass)
419 {
420     init(WTFMove(value));
421 }
422
423 } // namespace WebCore
424
425 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSPrimitiveValue, isPrimitiveValue())