1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/* representation of simple property values within CSS declarations */
#ifndef nsCSSValue_h___
#define nsCSSValue_h___
#include "mozilla/Attributes.h"
#include "mozilla/CORSMode.h"
#include "mozilla/EnumTypeTraits.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/ServoBindingTypes.h"
#include "mozilla/URLExtraData.h"
#include "mozilla/UniquePtr.h"
#include "nsCoord.h"
#include "nsTArray.h"
#include <type_traits>
// XXX Avoid including this here by moving function bodies to the cpp file
#include "mozilla/FloatingPoint.h"
class imgRequestProxy;
class nsAtom;
class nsIContent;
class nsIPrincipal;
class nsIURI;
class nsPresContext;
template <class T>
class nsPtrHashKey;
struct RawServoCssUrlData;
namespace mozilla {
class CSSStyleSheet;
} // namespace mozilla
// Forward declaration copied here since ServoBindings.h #includes nsCSSValue.h.
extern "C" {
mozilla::URLExtraData* Servo_CssUrlData_GetExtraData(const RawServoCssUrlData*);
bool Servo_CssUrlData_IsLocalRef(const RawServoCssUrlData* url);
}
enum nsCSSUnit : uint32_t {
eCSSUnit_Null = 0, // (n/a) null unit, value is not specified
eCSSUnit_Integer = 70, // (int) simple value
eCSSUnit_Enumerated = 71, // (int) value has enumerated meaning
eCSSUnit_Percent = 100, // (float) (1.0 == 100%) value is percentage of
// something
eCSSUnit_Number = 101, // (float) value is numeric (usually multiplier,
// different behavior than percent)
// Font relative measure
eCSSUnit_EM = 800, // (float) == current font size
eCSSUnit_XHeight = 801, // (float) distance from top of lower case x to
// baseline
eCSSUnit_Char = 802, // (float) number of characters, used for width with
// monospace font
eCSSUnit_RootEM = 803, // (float) == root element font size
// Screen relative measure
eCSSUnit_Point = 900, // (float) 4/3 of a CSS pixel
eCSSUnit_Inch = 901, // (float) 96 CSS pixels
eCSSUnit_Millimeter = 902, // (float) 96/25.4 CSS pixels
eCSSUnit_Centimeter = 903, // (float) 96/2.54 CSS pixels
eCSSUnit_Pica = 904, // (float) 12 points == 16 CSS pixls
eCSSUnit_Quarter = 905, // (float) 96/101.6 CSS pixels
eCSSUnit_Pixel = 906, // (float) CSS pixel unit
// Angular units
eCSSUnit_Degree = 1000, // (float) 360 per circle
// Frequency units
eCSSUnit_Hertz = 2000, // (float) 1/seconds
eCSSUnit_Kilohertz = 2001, // (float) 1000 Hertz
// Time units
eCSSUnit_Seconds = 3000, // (float) Standard time
eCSSUnit_Milliseconds = 3001, // (float) 1/1000 second
// Flexible fraction (CSS Grid)
eCSSUnit_FlexFraction = 4000, // (float) Fraction of free space
};
struct nsCSSValuePair;
struct nsCSSValuePair_heap;
struct nsCSSValueList;
struct nsCSSValueList_heap;
struct nsCSSValueSharedList;
struct nsCSSValuePairList;
struct nsCSSValuePairList_heap;
class nsCSSValue {
public:
explicit nsCSSValue() : mUnit(eCSSUnit_Null) {}
nsCSSValue(int32_t aValue, nsCSSUnit aUnit);
nsCSSValue(float aValue, nsCSSUnit aUnit);
nsCSSValue(const nsCSSValue& aCopy);
nsCSSValue(nsCSSValue&& aOther) : mUnit(aOther.mUnit), mValue(aOther.mValue) {
aOther.mUnit = eCSSUnit_Null;
}
template <typename T, typename = std::enable_if_t<std::is_enum<T>::value>>
explicit nsCSSValue(T aValue) : mUnit(eCSSUnit_Enumerated) {
static_assert(mozilla::EnumTypeFitsWithin<T, int32_t>::value,
"aValue must be an enum that fits within mValue.mInt");
mValue.mInt = static_cast<int32_t>(aValue);
}
nsCSSValue& operator=(const nsCSSValue& aCopy);
nsCSSValue& operator=(nsCSSValue&& aCopy);
bool operator==(const nsCSSValue& aOther) const;
bool operator!=(const nsCSSValue& aOther) const { return !(*this == aOther); }
nsCSSUnit GetUnit() const { return mUnit; }
bool IsLengthUnit() const {
return eCSSUnit_EM <= mUnit && mUnit <= eCSSUnit_Pixel;
}
bool IsLengthPercentUnit() const {
return IsLengthUnit() || mUnit == eCSSUnit_Percent;
}
/**
* What the spec calls relative length units is, for us, split
* between relative length units and pixel length units.
*
* A "relative" length unit is a multiple of some derived metric,
* such as a font em-size, which itself was controlled by an input CSS
* length. Relative length units should not be scaled by zooming, since
* the underlying CSS length would already have been scaled.
*/
bool IsRelativeLengthUnit() const {
return eCSSUnit_EM <= mUnit && mUnit <= eCSSUnit_RootEM;
}
/**
* A "pixel" length unit is a some multiple of CSS pixels.
*/
static bool IsPixelLengthUnit(nsCSSUnit aUnit) {
return eCSSUnit_Point <= aUnit && aUnit <= eCSSUnit_Pixel;
}
bool IsPixelLengthUnit() const { return IsPixelLengthUnit(mUnit); }
static bool IsPercentLengthUnit(nsCSSUnit aUnit) {
return aUnit == eCSSUnit_Percent;
}
bool IsPercentLengthUnit() { return IsPercentLengthUnit(mUnit); }
static bool IsFloatUnit(nsCSSUnit aUnit) { return eCSSUnit_Number <= aUnit; }
bool IsAngularUnit() const { return eCSSUnit_Degree == mUnit; }
bool IsFrequencyUnit() const {
return eCSSUnit_Hertz <= mUnit && mUnit <= eCSSUnit_Kilohertz;
}
bool IsTimeUnit() const {
return eCSSUnit_Seconds <= mUnit && mUnit <= eCSSUnit_Milliseconds;
}
int32_t GetIntValue() const {
MOZ_ASSERT(mUnit == eCSSUnit_Integer || mUnit == eCSSUnit_Enumerated,
"not an int value");
return mValue.mInt;
}
float GetPercentValue() const {
MOZ_ASSERT(mUnit == eCSSUnit_Percent, "not a percent value");
return mValue.mFloat;
}
float GetFloatValue() const {
MOZ_ASSERT(eCSSUnit_Number <= mUnit, "not a float value");
MOZ_ASSERT(!std::isnan(mValue.mFloat));
return mValue.mFloat;
}
float GetAngleValue() const {
MOZ_ASSERT(eCSSUnit_Degree == mUnit, "not an angle value");
return mValue.mFloat;
}
// Converts any angle to radians.
double GetAngleValueInRadians() const;
// Converts any angle to degrees.
double GetAngleValueInDegrees() const;
nscoord GetPixelLength() const;
void Reset() { mUnit = eCSSUnit_Null; }
~nsCSSValue() { Reset(); }
public:
void SetIntValue(int32_t aValue, nsCSSUnit aUnit);
template <typename T, typename = std::enable_if_t<std::is_enum<T>::value>>
void SetEnumValue(T aValue) {
static_assert(mozilla::EnumTypeFitsWithin<T, int32_t>::value,
"aValue must be an enum that fits within mValue.mInt");
SetIntValue(static_cast<int32_t>(aValue), eCSSUnit_Enumerated);
}
void SetPercentValue(float aValue);
void SetFloatValue(float aValue, nsCSSUnit aUnit);
// converts the nscoord to pixels
void SetIntegerCoordValue(nscoord aCoord);
protected:
nsCSSUnit mUnit;
union {
int32_t mInt;
float mFloat;
} mValue;
};
#endif /* nsCSSValue_h___ */
|
