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