WebEditorClient should properly write to m_rangeForCandidates
[WebKit.git] / Source / WebCore / platform / graphics / Color.h
1 /*
2  * Copyright (C) 2003-2006, 2010, 2015 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef Color_h
27 #define Color_h
28
29 #include "ColorSpace.h"
30 #include "PlatformExportMacros.h"
31 #include <algorithm>
32 #include <cmath>
33 #include <unicode/uchar.h>
34 #include <wtf/Forward.h>
35 #include <wtf/text/LChar.h>
36
37 #if USE(CG)
38 typedef struct CGColor* CGColorRef;
39 #endif
40
41 #if PLATFORM(GTK)
42 typedef struct _GdkColor GdkColor;
43 #ifndef GTK_API_VERSION_2
44 typedef struct _GdkRGBA GdkRGBA;
45 #endif
46 #endif
47
48 namespace WebCore {
49
50 class TextStream;
51
52 typedef unsigned RGBA32; // Deprecated: Type for an RGBA quadruplet. Use RGBA class instead.
53
54 WEBCORE_EXPORT RGBA32 makeRGB(int r, int g, int b);
55 WEBCORE_EXPORT RGBA32 makeRGBA(int r, int g, int b, int a);
56
57 WEBCORE_EXPORT RGBA32 colorWithOverrideAlpha(RGBA32 color, float overrideAlpha);
58 WEBCORE_EXPORT RGBA32 makeRGBA32FromFloats(float r, float g, float b, float a);
59 RGBA32 makeRGBAFromHSLA(double h, double s, double l, double a);
60 RGBA32 makeRGBAFromCMYKA(float c, float m, float y, float k, float a);
61
62 inline int redChannel(RGBA32 color) { return (color >> 16) & 0xFF; }
63 inline int greenChannel(RGBA32 color) { return (color >> 8) & 0xFF; }
64 inline int blueChannel(RGBA32 color) { return color & 0xFF; }
65 inline int alphaChannel(RGBA32 color) { return (color >> 24) & 0xFF; }
66
67 uint8_t roundAndClampColorChannel(int);
68 uint8_t roundAndClampColorChannel(float);
69
70 class RGBA {
71 public:
72     RGBA(); // all channels zero, including alpha
73     RGBA(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha);
74     RGBA(uint8_t red, uint8_t green, uint8_t blue); // opaque, alpha of 1
75
76     uint8_t red() const;
77     uint8_t green() const;
78     uint8_t blue() const;
79     uint8_t alpha() const;
80
81     bool hasAlpha() const;
82
83 private:
84     friend class Color;
85
86     unsigned m_integer { 0 };
87 };
88
89 bool operator==(const RGBA&, const RGBA&);
90 bool operator!=(const RGBA&, const RGBA&);
91
92 class Color {
93     WTF_MAKE_FAST_ALLOCATED;
94 public:
95     Color() : m_color(0), m_valid(false) { }
96     Color(RGBA, ColorSpace);
97
98     // FIXME: Remove all these constructors and creation functions and replace the ones that are still needed with free functions.
99     Color(RGBA32 color, bool valid = true) : m_color(color), m_valid(valid) { ASSERT(!m_color || m_valid); }
100     Color(int r, int g, int b) : m_color(makeRGB(r, g, b)), m_valid(true) { }
101     Color(int r, int g, int b, int a) : m_color(makeRGBA(r, g, b, a)), m_valid(true) { }
102     // Color is currently limited to 32bit RGBA, perhaps some day we'll support better colors
103     Color(float r, float g, float b, float a) : m_color(makeRGBA32FromFloats(r, g, b, a)), m_valid(true) { }
104     // Creates a new color from the specific CMYK and alpha values.
105     Color(float c, float m, float y, float k, float a) : m_color(makeRGBAFromCMYKA(c, m, y, k, a)), m_valid(true) { }
106     WEBCORE_EXPORT explicit Color(const String&);
107     explicit Color(const char*);
108     static Color createUnchecked(int r, int g, int b)
109     {
110         RGBA32 color = 0xFF000000 | r << 16 | g << 8 | b;
111         return Color(color);
112     }
113     static Color createUnchecked(int r, int g, int b, int a)
114     {
115         RGBA32 color = a << 24 | r << 16 | g << 8 | b;
116         return Color(color);
117     }
118
119     // Returns the color serialized according to HTML5
120     // <https://html.spec.whatwg.org/multipage/scripting.html#fill-and-stroke-styles> (10 September 2015)
121     WEBCORE_EXPORT String serialized() const;
122
123     String cssText() const;
124
125     // Returns the color serialized as either #RRGGBB or #RRGGBBAA
126     // The latter format is not a valid CSS color, and should only be seen in DRT dumps.
127     String nameForRenderTreeAsText() const;
128
129     void setNamedColor(const String&);
130
131     // FIXME: Remove this after moving clients to all use OptionalColor instead.
132     bool isValid() const { return m_valid; }
133
134     bool hasAlpha() const { return alpha() < 255; }
135
136     int red() const { return redChannel(m_color); }
137     int green() const { return greenChannel(m_color); }
138     int blue() const { return blueChannel(m_color); }
139     int alpha() const { return alphaChannel(m_color); }
140     
141     RGBA32 rgb() const { return m_color; } // Preserve the alpha.
142     void setRGB(int r, int g, int b) { m_color = makeRGB(r, g, b); m_valid = true; }
143     void setRGB(RGBA32 rgb) { m_color = rgb; m_valid = true; }
144     WEBCORE_EXPORT void getRGBA(float& r, float& g, float& b, float& a) const;
145     WEBCORE_EXPORT void getRGBA(double& r, double& g, double& b, double& a) const;
146     WEBCORE_EXPORT void getHSL(double& h, double& s, double& l) const;
147
148     Color light() const;
149     Color dark() const;
150
151     bool isDark() const;
152
153     // This is an implementation of Porter-Duff's "source-over" equation
154     Color blend(const Color&) const;
155     Color blendWithWhite() const;
156
157 #if PLATFORM(GTK)
158     Color(const GdkColor&);
159     // We can't sensibly go back to GdkColor without losing the alpha value
160 #ifndef GTK_API_VERSION_2
161     Color(const GdkRGBA&);
162     operator GdkRGBA() const;
163 #endif
164 #endif
165
166 #if USE(CG)
167     WEBCORE_EXPORT Color(CGColorRef);
168 #endif
169
170     static bool parseHexColor(const String&, RGBA32&);
171     static bool parseHexColor(const LChar*, unsigned, RGBA32&);
172     static bool parseHexColor(const UChar*, unsigned, RGBA32&);
173
174     static const RGBA32 black = 0xFF000000;
175     WEBCORE_EXPORT static const RGBA32 white = 0xFFFFFFFF;
176     static const RGBA32 darkGray = 0xFF808080;
177     static const RGBA32 gray = 0xFFA0A0A0;
178     static const RGBA32 lightGray = 0xFFC0C0C0;
179     WEBCORE_EXPORT static const RGBA32 transparent = 0x00000000;
180     static const RGBA32 cyan = 0xFF00FFFF;
181
182 #if PLATFORM(IOS)
183     static const RGBA32 compositionFill = 0x3CAFC0E3;
184 #else
185     static const RGBA32 compositionFill = 0xFFE1DD55;
186 #endif
187
188 private:
189     RGBA32 m_color;
190     bool m_valid;
191 };
192
193 class OptionalColor : public Color {
194 public:
195     OptionalColor();
196     OptionalColor(const Color&);
197
198     explicit operator bool() const;
199
200 private:
201     // FIXME: Change to use Optional<Color>?
202     // FIXME: Convert all callers to use Optional<Color>?
203     bool m_isEngaged;
204     Color m_color;
205 };
206
207 bool operator==(const Color&, const Color&);
208 bool operator!=(const Color&, const Color&);
209
210 Color colorFromPremultipliedARGB(RGBA32);
211 RGBA32 premultipliedARGBFromColor(const Color&);
212
213 Color blend(const Color& from, const Color& to, double progress, bool blendPremultiplied = true);
214
215 int differenceSquared(const Color&, const Color&);
216
217 uint16_t fastDivideBy255(uint16_t);
218
219 #if USE(CG)
220 WEBCORE_EXPORT CGColorRef cachedCGColor(const Color&);
221 #endif
222
223 inline RGBA::RGBA()
224 {
225 }
226
227 inline RGBA::RGBA(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha)
228     : m_integer(alpha << 24 | red << 16 | green << 8 | blue)
229 {
230 }
231
232 inline RGBA::RGBA(uint8_t red, uint8_t green, uint8_t blue)
233     : m_integer(0xFF000000 | red << 16 | green << 8 | blue)
234 {
235 }
236
237 inline uint8_t RGBA::red() const
238 {
239     return m_integer >> 16;
240 }
241
242 inline uint8_t RGBA::green() const
243 {
244     return m_integer >> 8;
245 }
246
247 inline uint8_t RGBA::blue() const
248 {
249     return m_integer;
250 }
251
252 inline uint8_t RGBA::alpha() const
253 {
254     return m_integer >> 24;
255 }
256
257 inline bool RGBA::hasAlpha() const
258 {
259     return (m_integer & 0xFF000000) != 0xFF000000;
260 }
261
262 inline Color::Color(RGBA color, ColorSpace space)
263     : m_color(color.m_integer)
264     , m_valid(true)
265 {
266     ASSERT_UNUSED(space, space == ColorSpaceSRGB);
267 }
268
269 inline bool operator==(const Color& a, const Color& b)
270 {
271     return a.rgb() == b.rgb() && a.isValid() == b.isValid();
272 }
273
274 inline bool operator!=(const Color& a, const Color& b)
275 {
276     return !(a == b);
277 }
278
279 inline uint8_t roundAndClampColorChannel(int value)
280 {
281     return std::max(0, std::min(255, value));
282 }
283
284 inline uint8_t roundAndClampColorChannel(float value)
285 {
286     return std::max(0.f, std::min(255.f, std::round(value)));
287 }
288
289 inline uint16_t fastDivideBy255(uint16_t value)
290 {
291     // While this is an approximate algorithm for division by 255, it gives perfectly accurate results for 16-bit values.
292     // FIXME: Since this gives accurate results for 16-bit values, we should get this optimization into compilers like clang.
293     uint16_t approximation = value >> 8;
294     uint16_t remainder = value - (approximation * 255) + 1;
295     return approximation + (remainder >> 8);
296 }
297
298 WEBCORE_EXPORT TextStream& operator<<(TextStream&, const Color&);
299
300 } // namespace WebCore
301
302 #endif // Color_h