3e4d91f431cd82c17989645f5661a6fb6303cb02
[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 Length;
50 struct LengthSize;
51
52 // Max/min values for CSS, needs to slightly smaller/larger than the true max/min values to allow for rounding without overflowing.
53 // Subtract two (rather than one) to allow for values to be converted to float and back without exceeding the LayoutUnit::max.
54 const int maxValueForCssLength = intMaxForLayoutUnit - 2;
55 const int minValueForCssLength = intMinForLayoutUnit + 2;
56
57 // Dimension calculations are imprecise, often resulting in values of e.g.
58 // 44.99998. We need to round if we're really close to the next integer value.
59 template<typename T> inline T roundForImpreciseConversion(double value)
60 {
61     value += (value < 0) ? -0.01 : +0.01;
62     return ((value > std::numeric_limits<T>::max()) || (value < std::numeric_limits<T>::min())) ? 0 : static_cast<T>(value);
63 }
64
65 template<> inline float roundForImpreciseConversion(double value)
66 {
67     double ceiledValue = ceil(value);
68     double proximityToNextInt = ceiledValue - value;
69     if (proximityToNextInt <= 0.01 && value > 0)
70         return static_cast<float>(ceiledValue);
71     if (proximityToNextInt >= 0.99 && value < 0)
72         return static_cast<float>(floor(value));
73     return static_cast<float>(value);
74 }
75
76 class CSSPrimitiveValue final : public CSSValue {
77 public:
78     enum UnitTypes {
79         CSS_UNKNOWN = 0,
80         CSS_NUMBER = 1,
81         CSS_PERCENTAGE = 2,
82         CSS_EMS = 3,
83         CSS_EXS = 4,
84         CSS_PX = 5,
85         CSS_CM = 6,
86         CSS_MM = 7,
87         CSS_IN = 8,
88         CSS_PT = 9,
89         CSS_PC = 10,
90         CSS_DEG = 11,
91         CSS_RAD = 12,
92         CSS_GRAD = 13,
93         CSS_MS = 14,
94         CSS_S = 15,
95         CSS_HZ = 16,
96         CSS_KHZ = 17,
97         CSS_DIMENSION = 18,
98         CSS_STRING = 19,
99         CSS_URI = 20,
100         CSS_IDENT = 21,
101         CSS_ATTR = 22,
102         CSS_COUNTER = 23,
103         CSS_RECT = 24,
104         CSS_RGBCOLOR = 25,
105         // From CSS Values and Units. Viewport-percentage Lengths (vw/vh/vmin/vmax).
106         CSS_VW = 26,
107         CSS_VH = 27,
108         CSS_VMIN = 28,
109         CSS_VMAX = 29,
110         CSS_DPPX = 30,
111         CSS_DPI = 31,
112         CSS_DPCM = 32,
113         CSS_FR = 33,
114 #if ENABLE(CSS_SCROLL_SNAP)
115         // FIXME-NEWPARSER: Remove once new parser lands.
116         CSS_LENGTH_REPEAT = 34,
117 #endif
118         CSS_PAIR = 100, // We envision this being exposed as a means of getting computed style values for pairs (border-spacing/radius, background-position, etc.)
119 #if ENABLE(DASHBOARD_SUPPORT)
120         CSS_DASHBOARD_REGION = 101, // FIXME: Dashboard region should not be a primitive value.
121 #endif
122         CSS_UNICODE_RANGE = 102,
123
124         // These are from CSS3 Values and Units, but that isn't a finished standard yet
125         CSS_TURN = 107,
126         CSS_REMS = 108,
127         CSS_CHS = 109,
128
129         // This is used internally for counter names (as opposed to counter values)
130         CSS_COUNTER_NAME = 110,
131
132         // This is used by the CSS Shapes draft
133         CSS_SHAPE = 111,
134
135         // Used by border images.
136         CSS_QUAD = 112,
137
138         CSS_CALC = 113,
139         CSS_CALC_PERCENTAGE_WITH_NUMBER = 114,
140         CSS_CALC_PERCENTAGE_WITH_LENGTH = 115,
141
142         CSS_FONT_FAMILY = 116,
143
144         CSS_PROPERTY_ID = 117,
145         CSS_VALUE_ID = 118,
146         
147         // This value is used to handle quirky margins in reflow roots (body, td, and th) like WinIE.
148         // The basic idea is that a stylesheet can use the value __qem (for quirky em) instead of em.
149         // When the quirky value is used, if you're in quirks mode, the margin will collapse away
150         // inside a table cell. This quirk is specified in the HTML spec but our impl is different.
151         CSS_QUIRKY_EMS = 120
152     };
153
154     // This enum follows the CSSParser::Units enum augmented with UNIT_FREQUENCY for frequencies.
155     enum UnitCategory {
156         UNumber,
157         UPercent,
158         ULength,
159         UAngle,
160         UTime,
161         UFrequency,
162 #if ENABLE(CSS_IMAGE_RESOLUTION) || ENABLE(RESOLUTION_MEDIA_QUERY)
163         UResolution,
164 #endif
165         UOther
166     };
167     static UnitCategory unitCategory(UnitTypes);
168
169     bool isAngle() const;
170     bool isAttr() const { return m_primitiveUnitType == CSS_ATTR; }
171     bool isCounter() const { return m_primitiveUnitType == CSS_COUNTER; }
172     bool isFontIndependentLength() const { return m_primitiveUnitType >= CSS_PX && m_primitiveUnitType <= CSS_PC; }
173     static bool isFontRelativeLength(UnitTypes);
174     bool isFontRelativeLength() const { return isFontRelativeLength(static_cast<UnitTypes>(m_primitiveUnitType)); }
175     
176     bool isQuirkyEms() const { return primitiveType() == UnitTypes::CSS_QUIRKY_EMS; }
177
178     static bool isViewportPercentageLength(UnitTypes type) { return type >= CSS_VW && type <= CSS_VMAX; }
179     bool isViewportPercentageLength() const { return isViewportPercentageLength(static_cast<UnitTypes>(m_primitiveUnitType)); }
180
181     static bool isLength(UnitTypes);
182     bool isLength() const { return isLength(static_cast<UnitTypes>(primitiveType())); }
183     bool isNumber() const { return primitiveType() == CSS_NUMBER; }
184     bool isPercentage() const { return primitiveType() == CSS_PERCENTAGE; }
185     bool isPx() const { return primitiveType() == CSS_PX; }
186     bool isRect() const { return m_primitiveUnitType == CSS_RECT; }
187 #if ENABLE(CSS_SCROLL_SNAP)
188     bool isLengthRepeat() const { return m_primitiveUnitType == CSS_LENGTH_REPEAT; }
189 #endif
190     bool isPair() const { return m_primitiveUnitType == CSS_PAIR; }
191     bool isPropertyID() const { return m_primitiveUnitType == CSS_PROPERTY_ID; }
192     bool isRGBColor() const { return m_primitiveUnitType == CSS_RGBCOLOR; }
193     bool isShape() const { return m_primitiveUnitType == CSS_SHAPE; }
194     bool isString() const { return m_primitiveUnitType == CSS_STRING; }
195     bool isFontFamily() const { return m_primitiveUnitType == CSS_FONT_FAMILY; }
196     bool isTime() const { return m_primitiveUnitType == CSS_S || m_primitiveUnitType == CSS_MS; }
197     bool isURI() const { return m_primitiveUnitType == CSS_URI; }
198     bool isCalculated() const { return m_primitiveUnitType == CSS_CALC; }
199     bool isCalculatedPercentageWithNumber() const { return primitiveType() == CSS_CALC_PERCENTAGE_WITH_NUMBER; }
200     bool isCalculatedPercentageWithLength() const { return primitiveType() == CSS_CALC_PERCENTAGE_WITH_LENGTH; }
201     bool isDotsPerInch() const { return primitiveType() == CSS_DPI; }
202     bool isDotsPerPixel() const { return primitiveType() == CSS_DPPX; }
203     bool isDotsPerCentimeter() const { return primitiveType() == CSS_DPCM; }
204
205     static bool isResolution(UnitTypes);
206     bool isResolution() const { return isResolution(static_cast<UnitTypes>(primitiveType())); }
207     bool isViewportPercentageWidth() const { return m_primitiveUnitType == CSS_VW; }
208     bool isViewportPercentageHeight() const { return m_primitiveUnitType == CSS_VH; }
209     bool isViewportPercentageMax() const { return m_primitiveUnitType == CSS_VMAX; }
210     bool isViewportPercentageMin() const { return m_primitiveUnitType == CSS_VMIN; }
211     bool isValueID() const { return m_primitiveUnitType == CSS_VALUE_ID; }
212     bool isFlex() const { return primitiveType() == CSS_FR; }
213
214     static Ref<CSSPrimitiveValue> createIdentifier(CSSValueID valueID) { return adoptRef(*new CSSPrimitiveValue(valueID)); }
215     static Ref<CSSPrimitiveValue> createIdentifier(CSSPropertyID propertyID) { return adoptRef(*new CSSPrimitiveValue(propertyID)); }
216
217     static Ref<CSSPrimitiveValue> create(double value, UnitTypes type) { return adoptRef(*new CSSPrimitiveValue(value, type)); }
218     static Ref<CSSPrimitiveValue> create(const String& value, UnitTypes type) { return adoptRef(*new CSSPrimitiveValue(value, type)); }
219     static Ref<CSSPrimitiveValue> create(const Length& value, const RenderStyle& style) { return adoptRef(*new CSSPrimitiveValue(value, style)); }
220     static Ref<CSSPrimitiveValue> create(const LengthSize& value, const RenderStyle& style) { return adoptRef(*new CSSPrimitiveValue(value, style)); }
221
222     template<typename T> static Ref<CSSPrimitiveValue> create(T&&);
223
224     // This value is used to handle quirky margins in reflow roots (body, td, and th) like WinIE.
225     // The basic idea is that a stylesheet can use the value __qem (for quirky em) instead of em.
226     // When the quirky value is used, if you're in quirks mode, the margin will collapse away
227     // inside a table cell.
228     static Ref<CSSPrimitiveValue> createAllowingMarginQuirk(double value, UnitTypes);
229
230     ~CSSPrimitiveValue();
231
232     void cleanup();
233
234     WEBCORE_EXPORT unsigned short primitiveType() const;
235     WEBCORE_EXPORT ExceptionOr<void> setFloatValue(unsigned short unitType, double floatValue);
236     WEBCORE_EXPORT ExceptionOr<float> getFloatValue(unsigned short unitType) const;
237     WEBCORE_EXPORT ExceptionOr<void> setStringValue(unsigned short stringType, const String& stringValue);
238     WEBCORE_EXPORT ExceptionOr<String> getStringValue() const;
239     WEBCORE_EXPORT ExceptionOr<Counter&> getCounterValue() const;
240     WEBCORE_EXPORT ExceptionOr<Rect&> getRectValue() const;
241     WEBCORE_EXPORT ExceptionOr<Ref<RGBColor>> getRGBColorValue() const;
242
243     double computeDegrees() const;
244     
245     enum TimeUnit { Seconds, Milliseconds };
246     template<typename T, TimeUnit timeUnit> T computeTime() const;
247
248     template<typename T> T computeLength(const CSSToLengthConversionData&) const;
249     template<int> Length convertToLength(const CSSToLengthConversionData&) const;
250
251     bool convertingToLengthRequiresNonNullStyle(int lengthConversion) const;
252
253     double doubleValue(UnitTypes) const;
254     double doubleValue() const;
255
256     template<typename T> inline T value(UnitTypes type) const { return clampTo<T>(doubleValue(type)); }
257     template<typename T> inline T value() const { return clampTo<T>(doubleValue()); }
258
259     float floatValue(UnitTypes type) const { return value<float>(type); }
260     float floatValue() const { return value<float>(); }
261
262     int intValue(UnitTypes type) const { return value<int>(type); }
263     int intValue() const { return value<int>(); }
264
265     WEBCORE_EXPORT String stringValue() const;
266
267     const Color& color() const { ASSERT(m_primitiveUnitType == CSS_RGBCOLOR); return *m_value.color; }
268     Counter* counterValue() const { return m_primitiveUnitType != CSS_COUNTER ? nullptr : m_value.counter; }
269     CSSCalcValue* cssCalcValue() const { return m_primitiveUnitType != CSS_CALC ? nullptr : m_value.calc; }
270     const CSSFontFamily& fontFamily() const { ASSERT(m_primitiveUnitType == CSS_FONT_FAMILY); return *m_value.fontFamily; }
271     Pair* pairValue() const { return m_primitiveUnitType != CSS_PAIR ? nullptr : m_value.pair; }
272     CSSPropertyID propertyID() const { return m_primitiveUnitType == CSS_PROPERTY_ID ? m_value.propertyID : CSSPropertyInvalid; }
273     Quad* quadValue() const { return m_primitiveUnitType != CSS_QUAD ? nullptr : m_value.quad; }
274     Rect* rectValue() const { return m_primitiveUnitType != CSS_RECT ? nullptr : m_value.rect; }
275     CSSBasicShape* shapeValue() const { return m_primitiveUnitType != CSS_SHAPE ? nullptr : m_value.shape; }
276     CSSValueID valueID() const { return m_primitiveUnitType == CSS_VALUE_ID ? m_value.valueID : CSSValueInvalid; }
277
278 #if ENABLE(CSS_SCROLL_SNAP)
279     LengthRepeat* lengthRepeatValue() const { return m_primitiveUnitType != CSS_LENGTH_REPEAT ? nullptr : m_value.lengthRepeat; }
280 #endif
281 #if ENABLE(DASHBOARD_SUPPORT)
282     DashboardRegion* dashboardRegionValue() const { return m_primitiveUnitType != CSS_DASHBOARD_REGION ? nullptr : m_value.region; }
283 #endif
284
285     template<typename T> inline operator T() const; // Defined in CSSPrimitiveValueMappings.h
286
287     String customCSSText() const;
288
289     // FIXME-NEWPARSER: Can ditch the boolean and just use the unit type once old parser is gone.
290     bool isQuirkValue() const { return m_isQuirkValue || primitiveType() == CSS_QUIRKY_EMS; }
291
292     Ref<CSSPrimitiveValue> cloneForCSSOM() const;
293     void setCSSOMSafe() { m_isCSSOMSafe = true; }
294
295     bool equals(const CSSPrimitiveValue&) const;
296
297     static UnitTypes canonicalUnitTypeForCategory(UnitCategory);
298     static double conversionToCanonicalUnitsScaleFactor(UnitTypes);
299
300     static double computeNonCalcLengthDouble(const CSSToLengthConversionData&, UnitTypes, double value);
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&, UnitTypes);
318     CSSPrimitiveValue(double, UnitTypes);
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(UnitTypes 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(UnitTypes 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(UnitTypes 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(UnitTypes 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, UnitTypes 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())