[WTF] Import std::optional reference implementation as WTF::Optional
[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 LengthRepeat;
42 class Pair;
43 class Quad;
44 class RGBColor;
45 class Rect;
46 class RenderStyle;
47
48 struct CSSFontFamily;
49 struct CSSParserValue;
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 UnitTypes {
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 next types are just used internally to allow us to translate back and forth from CSSPrimitiveValues to CSSParserValues.
126         CSS_PARSER_OPERATOR = 103,
127         CSS_PARSER_INTEGER = 104,
128         CSS_PARSER_HEXCOLOR = 105,
129
130         // This is used internally for unknown identifiers
131         CSS_PARSER_IDENTIFIER = 106,
132
133         // These are from CSS3 Values and Units, but that isn't a finished standard yet
134         CSS_TURN = 107,
135         CSS_REMS = 108,
136         CSS_CHS = 109,
137
138         // This is used internally for counter names (as opposed to counter values)
139         CSS_COUNTER_NAME = 110,
140
141         // This is used by the CSS Shapes draft
142         CSS_SHAPE = 111,
143
144         // Used by border images.
145         CSS_QUAD = 112,
146
147         CSS_CALC = 113,
148         CSS_CALC_PERCENTAGE_WITH_NUMBER = 114,
149         CSS_CALC_PERCENTAGE_WITH_LENGTH = 115,
150
151         CSS_FONT_FAMILY = 116,
152
153         CSS_PROPERTY_ID = 117,
154         CSS_VALUE_ID = 118,
155         
156         // More internal parse stuff for CSS variables
157         CSS_PARSER_WHITESPACE = 119,
158         
159         // This value is used to handle quirky margins in reflow roots (body, td, and th) like WinIE.
160         // The basic idea is that a stylesheet can use the value __qem (for quirky em) instead of em.
161         // When the quirky value is used, if you're in quirks mode, the margin will collapse away
162         // inside a table cell. This quirk is specified in the HTML spec but our impl is different.
163         CSS_QUIRKY_EMS = 120
164     };
165
166     // This enum follows the CSSParser::Units enum augmented with UNIT_FREQUENCY for frequencies.
167     enum UnitCategory {
168         UNumber,
169         UPercent,
170         ULength,
171         UAngle,
172         UTime,
173         UFrequency,
174 #if ENABLE(CSS_IMAGE_RESOLUTION) || ENABLE(RESOLUTION_MEDIA_QUERY)
175         UResolution,
176 #endif
177         UOther
178     };
179     static UnitCategory unitCategory(UnitTypes);
180
181     bool isAngle() const;
182     bool isAttr() const { return m_primitiveUnitType == CSS_ATTR; }
183     bool isCounter() const { return m_primitiveUnitType == CSS_COUNTER; }
184     bool isFontIndependentLength() const { return m_primitiveUnitType >= CSS_PX && m_primitiveUnitType <= CSS_PC; }
185     static bool isFontRelativeLength(UnitTypes);
186     bool isFontRelativeLength() const { return isFontRelativeLength(static_cast<UnitTypes>(m_primitiveUnitType)); }
187     
188     bool isQuirkyEms() const { return primitiveType() == UnitTypes::CSS_QUIRKY_EMS; }
189
190     static bool isViewportPercentageLength(UnitTypes type) { return type >= CSS_VW && type <= CSS_VMAX; }
191     bool isViewportPercentageLength() const { return isViewportPercentageLength(static_cast<UnitTypes>(m_primitiveUnitType)); }
192
193     static bool isLength(UnitTypes);
194     bool isLength() const { return isLength(static_cast<UnitTypes>(primitiveType())); }
195     bool isNumber() const { return primitiveType() == CSS_NUMBER; }
196     bool isPercentage() const { return primitiveType() == CSS_PERCENTAGE; }
197     bool isPx() const { return primitiveType() == CSS_PX; }
198     bool isRect() const { return m_primitiveUnitType == CSS_RECT; }
199 #if ENABLE(CSS_SCROLL_SNAP)
200     bool isLengthRepeat() const { return m_primitiveUnitType == CSS_LENGTH_REPEAT; }
201 #endif
202     bool isPair() const { return m_primitiveUnitType == CSS_PAIR; }
203     bool isPropertyID() const { return m_primitiveUnitType == CSS_PROPERTY_ID; }
204     bool isRGBColor() const { return m_primitiveUnitType == CSS_RGBCOLOR; }
205     bool isShape() const { return m_primitiveUnitType == CSS_SHAPE; }
206     bool isString() const { return m_primitiveUnitType == CSS_STRING; }
207     bool isFontFamily() const { return m_primitiveUnitType == CSS_FONT_FAMILY; }
208     bool isTime() const { return m_primitiveUnitType == CSS_S || m_primitiveUnitType == CSS_MS; }
209     bool isURI() const { return m_primitiveUnitType == CSS_URI; }
210     bool isCalculated() const { return m_primitiveUnitType == CSS_CALC; }
211     bool isCalculatedPercentageWithNumber() const { return primitiveType() == CSS_CALC_PERCENTAGE_WITH_NUMBER; }
212     bool isCalculatedPercentageWithLength() const { return primitiveType() == CSS_CALC_PERCENTAGE_WITH_LENGTH; }
213     bool isDotsPerInch() const { return primitiveType() == CSS_DPI; }
214     bool isDotsPerPixel() const { return primitiveType() == CSS_DPPX; }
215     bool isDotsPerCentimeter() const { return primitiveType() == CSS_DPCM; }
216
217     static bool isResolution(UnitTypes);
218     bool isResolution() const { return isResolution(static_cast<UnitTypes>(primitiveType())); }
219     bool isViewportPercentageWidth() const { return m_primitiveUnitType == CSS_VW; }
220     bool isViewportPercentageHeight() const { return m_primitiveUnitType == CSS_VH; }
221     bool isViewportPercentageMax() const { return m_primitiveUnitType == CSS_VMAX; }
222     bool isViewportPercentageMin() const { return m_primitiveUnitType == CSS_VMIN; }
223     bool isValueID() const { return m_primitiveUnitType == CSS_VALUE_ID; }
224     bool isFlex() const { return primitiveType() == CSS_FR; }
225     
226     bool isParserOperator() const { return primitiveType() == CSS_PARSER_OPERATOR; }
227     int parserOperator() const { return isParserOperator() ? m_value.parserOperator : 0; }
228
229     static Ref<CSSPrimitiveValue> createIdentifier(CSSValueID valueID) { return adoptRef(*new CSSPrimitiveValue(valueID)); }
230     static Ref<CSSPrimitiveValue> createIdentifier(CSSPropertyID propertyID) { return adoptRef(*new CSSPrimitiveValue(propertyID)); }
231     static Ref<CSSPrimitiveValue> createParserOperator(int parserOperator) { return adoptRef(*new CSSPrimitiveValue(parserOperator)); }
232
233     static Ref<CSSPrimitiveValue> create(double value, UnitTypes type) { return adoptRef(*new CSSPrimitiveValue(value, type)); }
234     static Ref<CSSPrimitiveValue> create(const String& value, UnitTypes type) { return adoptRef(*new CSSPrimitiveValue(value, type)); }
235     static Ref<CSSPrimitiveValue> create(const Length& value, const RenderStyle& style) { return adoptRef(*new CSSPrimitiveValue(value, style)); }
236     static Ref<CSSPrimitiveValue> create(const LengthSize& value, const RenderStyle& style) { return adoptRef(*new CSSPrimitiveValue(value, style)); }
237
238     template<typename T> static Ref<CSSPrimitiveValue> create(T&&);
239
240     // This value is used to handle quirky margins in reflow roots (body, td, and th) like WinIE.
241     // The basic idea is that a stylesheet can use the value __qem (for quirky em) instead of em.
242     // When the quirky value is used, if you're in quirks mode, the margin will collapse away
243     // inside a table cell.
244     static Ref<CSSPrimitiveValue> createAllowingMarginQuirk(double value, UnitTypes);
245
246     ~CSSPrimitiveValue();
247
248     void cleanup();
249
250     WEBCORE_EXPORT unsigned short primitiveType() const;
251     WEBCORE_EXPORT ExceptionOr<void> setFloatValue(unsigned short unitType, double floatValue);
252     WEBCORE_EXPORT ExceptionOr<float> getFloatValue(unsigned short unitType) const;
253     WEBCORE_EXPORT ExceptionOr<void> setStringValue(unsigned short stringType, const String& stringValue);
254     WEBCORE_EXPORT ExceptionOr<String> getStringValue() const;
255     WEBCORE_EXPORT ExceptionOr<Counter&> getCounterValue() const;
256     WEBCORE_EXPORT ExceptionOr<Rect&> getRectValue() const;
257     WEBCORE_EXPORT ExceptionOr<Ref<RGBColor>> getRGBColorValue() const;
258
259     double computeDegrees() const;
260     
261     bool buildParserValue(CSSParserValue*) const;
262     
263     enum TimeUnit { Seconds, Milliseconds };
264     template<typename T, TimeUnit timeUnit> T computeTime() const;
265
266     template<typename T> T computeLength(const CSSToLengthConversionData&) const;
267     template<int> Length convertToLength(const CSSToLengthConversionData&) const;
268
269     bool convertingToLengthRequiresNonNullStyle(int lengthConversion) const;
270
271     double doubleValue(UnitTypes) const;
272     double doubleValue() const;
273
274     template<typename T> inline T value(UnitTypes type) const { return clampTo<T>(doubleValue(type)); }
275     template<typename T> inline T value() const { return clampTo<T>(doubleValue()); }
276
277     float floatValue(UnitTypes type) const { return value<float>(type); }
278     float floatValue() const { return value<float>(); }
279
280     int intValue(UnitTypes type) const { return value<int>(type); }
281     int intValue() const { return value<int>(); }
282
283     WEBCORE_EXPORT String stringValue() const;
284
285     const Color& color() const { ASSERT(m_primitiveUnitType == CSS_RGBCOLOR); return *m_value.color; }
286     Counter* counterValue() const { return m_primitiveUnitType != CSS_COUNTER ? nullptr : m_value.counter; }
287     CSSCalcValue* cssCalcValue() const { return m_primitiveUnitType != CSS_CALC ? nullptr : m_value.calc; }
288     const CSSFontFamily& fontFamily() const { ASSERT(m_primitiveUnitType == CSS_FONT_FAMILY); return *m_value.fontFamily; }
289     Pair* pairValue() const { return m_primitiveUnitType != CSS_PAIR ? nullptr : m_value.pair; }
290     CSSPropertyID propertyID() const { return m_primitiveUnitType == CSS_PROPERTY_ID ? m_value.propertyID : CSSPropertyInvalid; }
291     Quad* quadValue() const { return m_primitiveUnitType != CSS_QUAD ? nullptr : m_value.quad; }
292     Rect* rectValue() const { return m_primitiveUnitType != CSS_RECT ? nullptr : m_value.rect; }
293     CSSBasicShape* shapeValue() const { return m_primitiveUnitType != CSS_SHAPE ? nullptr : m_value.shape; }
294     CSSValueID valueID() const { return m_primitiveUnitType == CSS_VALUE_ID ? m_value.valueID : CSSValueInvalid; }
295
296 #if ENABLE(CSS_SCROLL_SNAP)
297     LengthRepeat* lengthRepeatValue() const { return m_primitiveUnitType != CSS_LENGTH_REPEAT ? nullptr : m_value.lengthRepeat; }
298 #endif
299 #if ENABLE(DASHBOARD_SUPPORT)
300     DashboardRegion* dashboardRegionValue() const { return m_primitiveUnitType != CSS_DASHBOARD_REGION ? nullptr : m_value.region; }
301 #endif
302
303     template<typename T> inline operator T() const; // Defined in CSSPrimitiveValueMappings.h
304
305     String customCSSText() const;
306
307     // FIXME-NEWPARSER: Can ditch the boolean and just use the unit type once old parser is gone.
308     bool isQuirkValue() const { return m_isQuirkValue || primitiveType() == CSS_QUIRKY_EMS; }
309
310     Ref<CSSPrimitiveValue> cloneForCSSOM() const;
311     void setCSSOMSafe() { m_isCSSOMSafe = true; }
312
313     bool equals(const CSSPrimitiveValue&) const;
314
315     static UnitTypes canonicalUnitTypeForCategory(UnitCategory);
316     static double conversionToCanonicalUnitsScaleFactor(UnitTypes);
317
318     static double computeNonCalcLengthDouble(const CSSToLengthConversionData&, UnitTypes, double value);
319
320 #if COMPILER(MSVC)
321     // FIXME: This should be private, but for some reason MSVC then fails to invoke it from LazyNeverDestroyed::construct.
322 public:
323 #else
324 private:
325     friend class CSSValuePool;
326     friend class LazyNeverDestroyed<CSSPrimitiveValue>;
327 #endif
328
329     CSSPrimitiveValue(CSSValueID);
330     CSSPrimitiveValue(CSSPropertyID);
331     CSSPrimitiveValue(int parserOperator);
332     CSSPrimitiveValue(const Color&);
333     CSSPrimitiveValue(const Length&);
334     CSSPrimitiveValue(const Length&, const RenderStyle&);
335     CSSPrimitiveValue(const LengthSize&, const RenderStyle&);
336     CSSPrimitiveValue(const String&, UnitTypes);
337     CSSPrimitiveValue(double, UnitTypes);
338
339     template<typename T> CSSPrimitiveValue(T); // Defined in CSSPrimitiveValueMappings.h
340     template<typename T> CSSPrimitiveValue(RefPtr<T>&&);
341     template<typename T> CSSPrimitiveValue(Ref<T>&&);
342
343     static void create(int); // compile-time guard
344     static void create(unsigned); // compile-time guard
345     template<typename T> operator T*(); // compile-time guard
346
347     void init(const Length&);
348     void init(const LengthSize&, const RenderStyle&);
349     void init(Ref<CSSBasicShape>&&);
350     void init(RefPtr<CSSCalcValue>&&);
351     void init(Ref<Counter>&&);
352     void init(Ref<Pair>&&);
353     void init(Ref<Quad>&&);
354     void init(Ref<Rect>&&);
355
356 #if ENABLE(CSS_SCROLL_SNAP)
357     void init(Ref<LengthRepeat>&&);
358 #endif
359 #if ENABLE(DASHBOARD_SUPPORT)
360     void init(RefPtr<DashboardRegion>&&); // FIXME: Dashboard region should not be a primitive value.
361 #endif
362
363     std::optional<double> doubleValueInternal(UnitTypes targetUnitType) const;
364
365     double computeLengthDouble(const CSSToLengthConversionData&) const;
366
367     ALWAYS_INLINE String formatNumberForCustomCSSText() const;
368     template<unsigned characterCount> ALWAYS_INLINE Ref<StringImpl> formatNumberValue(const char (&characters)[characterCount]) const;
369     NEVER_INLINE Ref<StringImpl> formatNumberValue(const char* suffix, unsigned suffixLength) const;
370
371     union {
372         CSSPropertyID propertyID;
373         CSSValueID valueID;
374         int parserOperator;
375         double num;
376         StringImpl* string;
377         Counter* counter;
378         Rect* rect;
379         Quad* quad;
380         const Color* color;
381         Pair* pair;
382         DashboardRegion* region;
383         CSSBasicShape* shape;
384         CSSCalcValue* calc;
385         const CSSFontFamily* fontFamily;
386 #if ENABLE(CSS_SCROLL_SNAP)
387         LengthRepeat* lengthRepeat;
388 #endif
389     } m_value;
390 };
391
392 inline bool CSSPrimitiveValue::isAngle() const
393 {
394     return m_primitiveUnitType == CSS_DEG
395         || m_primitiveUnitType == CSS_RAD
396         || m_primitiveUnitType == CSS_GRAD
397         || m_primitiveUnitType == CSS_TURN;
398 }
399
400 inline bool CSSPrimitiveValue::isFontRelativeLength(UnitTypes type)
401 {
402     return type == CSS_EMS
403         || type == CSS_EXS
404         || type == CSS_REMS
405         || type == CSS_CHS
406         || type == CSS_QUIRKY_EMS;
407 }
408
409 inline bool CSSPrimitiveValue::isLength(UnitTypes type)
410 {
411     return (type >= CSS_EMS && type <= CSS_PC)
412         || type == CSS_REMS
413         || type == CSS_CHS
414         || isViewportPercentageLength(type)
415         || type == CSS_QUIRKY_EMS;
416 }
417
418 inline bool CSSPrimitiveValue::isResolution(UnitTypes type)
419 {
420     return type >= CSS_DPPX && type <= CSS_DPCM;
421 }
422
423 template<typename T> inline Ref<CSSPrimitiveValue> CSSPrimitiveValue::create(T&& value)
424 {
425     return adoptRef(*new CSSPrimitiveValue(std::forward<T>(value)));
426 }
427
428 inline Ref<CSSPrimitiveValue> CSSPrimitiveValue::createAllowingMarginQuirk(double value, UnitTypes type)
429 {
430     auto result = adoptRef(*new CSSPrimitiveValue(value, type));
431     result->m_isQuirkValue = true;
432     return result;
433 }
434
435 template<typename T, CSSPrimitiveValue::TimeUnit timeUnit> inline T CSSPrimitiveValue::computeTime() const
436 {
437     if (timeUnit == Seconds && primitiveType() == CSS_S)
438         return value<T>();
439     if (timeUnit == Seconds && primitiveType() == CSS_MS)
440         return value<T>() / 1000;
441     if (timeUnit == Milliseconds && primitiveType() == CSS_MS)
442         return value<T>();
443     if (timeUnit == Milliseconds && primitiveType() == CSS_S)
444         return value<T>() * 1000;
445     ASSERT_NOT_REACHED();
446     return 0;
447 }
448
449 template<typename T> inline CSSPrimitiveValue::CSSPrimitiveValue(RefPtr<T>&& value)
450     : CSSValue(PrimitiveClass)
451 {
452     init(WTFMove(value));
453 }
454
455 template<typename T> inline CSSPrimitiveValue::CSSPrimitiveValue(Ref<T>&& value)
456     : CSSValue(PrimitiveClass)
457 {
458     init(WTFMove(value));
459 }
460
461 } // namespace WebCore
462
463 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSPrimitiveValue, isPrimitiveValue())