1/*
2 * Copyright (C) 2003, 2004, 2005, 2006, 2008 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 COMPUTER, 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 COMPUTER, 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#include "config.h"
27#include "platform/graphics/Color.h"
28
29#include "platform/Decimal.h"
30#include "wtf/Assertions.h"
31#include "wtf/HexNumber.h"
32#include "wtf/MathExtras.h"
33#include "wtf/dtoa.h"
34#include "wtf/text/StringBuilder.h"
35
36namespace blink {
37
38#if !COMPILER(MSVC)
39// FIXME: Use C++11 strong enums to avoid static data member with initializer definition problems.
40const RGBA32 Color::black;
41const RGBA32 Color::white;
42const RGBA32 Color::darkGray;
43const RGBA32 Color::gray;
44const RGBA32 Color::lightGray;
45const RGBA32 Color::transparent;
46#endif
47
48static const RGBA32 lightenedBlack = 0xFF545454;
49static const RGBA32 darkenedWhite = 0xFFABABAB;
50
51RGBA32 makeRGB(int r, int g, int b)
52{
53    return 0xFF000000 | std::max(0, std::min(r, 255)) << 16 | std::max(0, std::min(g, 255)) << 8 | std::max(0, std::min(b, 255));
54}
55
56RGBA32 makeRGBA(int r, int g, int b, int a)
57{
58    return std::max(0, std::min(a, 255)) << 24 | std::max(0, std::min(r, 255)) << 16 | std::max(0, std::min(g, 255)) << 8 | std::max(0, std::min(b, 255));
59}
60
61static int colorFloatToRGBAByte(float f)
62{
63    // We use lroundf and 255 instead of nextafterf(256, 0) to match CG's rounding
64    return std::max(0, std::min(static_cast<int>(lroundf(255.0f * f)), 255));
65}
66
67RGBA32 makeRGBA32FromFloats(float r, float g, float b, float a)
68{
69    return colorFloatToRGBAByte(a) << 24 | colorFloatToRGBAByte(r) << 16 | colorFloatToRGBAByte(g) << 8 | colorFloatToRGBAByte(b);
70}
71
72RGBA32 colorWithOverrideAlpha(RGBA32 color, float overrideAlpha)
73{
74    RGBA32 rgbOnly = color & 0x00FFFFFF;
75    RGBA32 rgba = rgbOnly | colorFloatToRGBAByte(overrideAlpha) << 24;
76    return rgba;
77}
78
79static double calcHue(double temp1, double temp2, double hueVal)
80{
81    if (hueVal < 0.0)
82        hueVal++;
83    else if (hueVal > 1.0)
84        hueVal--;
85    if (hueVal * 6.0 < 1.0)
86        return temp1 + (temp2 - temp1) * hueVal * 6.0;
87    if (hueVal * 2.0 < 1.0)
88        return temp2;
89    if (hueVal * 3.0 < 2.0)
90        return temp1 + (temp2 - temp1) * (2.0 / 3.0 - hueVal) * 6.0;
91    return temp1;
92}
93
94// Explanation of this algorithm can be found in the CSS3 Color Module
95// specification at http://www.w3.org/TR/css3-color/#hsl-color with further
96// explanation available at http://en.wikipedia.org/wiki/HSL_color_space
97
98// all values are in the range of 0 to 1.0
99RGBA32 makeRGBAFromHSLA(double hue, double saturation, double lightness, double alpha)
100{
101    const double scaleFactor = nextafter(256.0, 0.0);
102
103    if (!saturation) {
104        int greyValue = static_cast<int>(lightness * scaleFactor);
105        return makeRGBA(greyValue, greyValue, greyValue, static_cast<int>(alpha * scaleFactor));
106    }
107
108    double temp2 = lightness < 0.5 ? lightness * (1.0 + saturation) : lightness + saturation - lightness * saturation;
109    double temp1 = 2.0 * lightness - temp2;
110
111    return makeRGBA(static_cast<int>(calcHue(temp1, temp2, hue + 1.0 / 3.0) * scaleFactor),
112                    static_cast<int>(calcHue(temp1, temp2, hue) * scaleFactor),
113                    static_cast<int>(calcHue(temp1, temp2, hue - 1.0 / 3.0) * scaleFactor),
114                    static_cast<int>(alpha * scaleFactor));
115}
116
117RGBA32 makeRGBAFromCMYKA(float c, float m, float y, float k, float a)
118{
119    double colors = 1 - k;
120    int r = static_cast<int>(nextafter(256, 0) * (colors * (1 - c)));
121    int g = static_cast<int>(nextafter(256, 0) * (colors * (1 - m)));
122    int b = static_cast<int>(nextafter(256, 0) * (colors * (1 - y)));
123    return makeRGBA(r, g, b, static_cast<float>(nextafter(256, 0) * a));
124}
125
126// originally moved here from the CSS parser
127template <typename CharacterType>
128static inline bool parseHexColorInternal(const CharacterType* name, unsigned length, RGBA32& rgb)
129{
130    if (length != 3 && length != 6)
131        return false;
132    unsigned value = 0;
133    for (unsigned i = 0; i < length; ++i) {
134        if (!isASCIIHexDigit(name[i]))
135            return false;
136        value <<= 4;
137        value |= toASCIIHexValue(name[i]);
138    }
139    if (length == 6) {
140        rgb = 0xFF000000 | value;
141        return true;
142    }
143    // #abc converts to #aabbcc
144    rgb = 0xFF000000
145        | (value & 0xF00) << 12 | (value & 0xF00) << 8
146        | (value & 0xF0) << 8 | (value & 0xF0) << 4
147        | (value & 0xF) << 4 | (value & 0xF);
148    return true;
149}
150
151bool Color::parseHexColor(const LChar* name, unsigned length, RGBA32& rgb)
152{
153    return parseHexColorInternal(name, length, rgb);
154}
155
156bool Color::parseHexColor(const UChar* name, unsigned length, RGBA32& rgb)
157{
158    return parseHexColorInternal(name, length, rgb);
159}
160
161bool Color::parseHexColor(const String& name, RGBA32& rgb)
162{
163    unsigned length = name.length();
164
165    if (!length)
166        return false;
167    if (name.is8Bit())
168        return parseHexColor(name.characters8(), name.length(), rgb);
169    return parseHexColor(name.characters16(), name.length(), rgb);
170}
171
172int differenceSquared(const Color& c1, const Color& c2)
173{
174    int dR = c1.red() - c2.red();
175    int dG = c1.green() - c2.green();
176    int dB = c1.blue() - c2.blue();
177    return dR * dR + dG * dG + dB * dB;
178}
179
180bool Color::setFromString(const String& name)
181{
182    if (name[0] != '#')
183        return setNamedColor(name);
184    if (name.is8Bit())
185        return parseHexColor(name.characters8() + 1, name.length() - 1, m_color);
186    return parseHexColor(name.characters16() + 1, name.length() - 1, m_color);
187}
188
189String Color::serializedAsCSSComponentValue() const
190{
191    StringBuilder result;
192    result.reserveCapacity(32);
193    bool colorHasAlpha = hasAlpha();
194    if (colorHasAlpha)
195        result.appendLiteral("rgba(");
196    else
197        result.appendLiteral("rgb(");
198
199    result.appendNumber(static_cast<unsigned char>(red()));
200    result.appendLiteral(", ");
201
202    result.appendNumber(static_cast<unsigned char>(green()));
203    result.appendLiteral(", ");
204
205    result.appendNumber(static_cast<unsigned char>(blue()));
206    if (colorHasAlpha) {
207        result.appendLiteral(", ");
208
209        NumberToStringBuffer buffer;
210        const char* alphaString = numberToFixedPrecisionString(alpha() / 255.0f, 6, buffer, true);
211        result.append(alphaString, strlen(alphaString));
212    }
213
214    result.append(')');
215    return result.toString();
216}
217
218String Color::serialized() const
219{
220    if (!hasAlpha()) {
221        StringBuilder builder;
222        builder.reserveCapacity(7);
223        builder.append('#');
224        appendByteAsHex(red(), builder, Lowercase);
225        appendByteAsHex(green(), builder, Lowercase);
226        appendByteAsHex(blue(), builder, Lowercase);
227        return builder.toString();
228    }
229
230    StringBuilder result;
231    result.reserveCapacity(28);
232
233    result.appendLiteral("rgba(");
234    result.appendNumber(red());
235    result.appendLiteral(", ");
236    result.appendNumber(green());
237    result.appendLiteral(", ");
238    result.appendNumber(blue());
239    result.appendLiteral(", ");
240
241    if (!alpha())
242        result.append('0');
243    else {
244        result.append(Decimal::fromDouble(alpha() / 255.0).toString());
245    }
246
247    result.append(')');
248    return result.toString();
249}
250
251String Color::nameForRenderTreeAsText() const
252{
253    if (alpha() < 0xFF)
254        return String::format("#%02X%02X%02X%02X", red(), green(), blue(), alpha());
255    return String::format("#%02X%02X%02X", red(), green(), blue());
256}
257
258static inline const NamedColor* findNamedColor(const String& name)
259{
260    char buffer[64]; // easily big enough for the longest color name
261    unsigned length = name.length();
262    if (length > sizeof(buffer) - 1)
263        return 0;
264    for (unsigned i = 0; i < length; ++i) {
265        UChar c = name[i];
266        if (!c || c > 0x7F)
267            return 0;
268        buffer[i] = toASCIILower(static_cast<char>(c));
269    }
270    buffer[length] = '\0';
271    return findColor(buffer, length);
272}
273
274bool Color::setNamedColor(const String& name)
275{
276    const NamedColor* foundColor = findNamedColor(name);
277    m_color = foundColor ? foundColor->ARGBValue : 0;
278    return foundColor;
279}
280
281Color Color::light() const
282{
283    // Hardcode this common case for speed.
284    if (m_color == black)
285        return lightenedBlack;
286
287    const float scaleFactor = nextafterf(256.0f, 0.0f);
288
289    float r, g, b, a;
290    getRGBA(r, g, b, a);
291
292    float v = std::max(r, std::max(g, b));
293
294    if (v == 0.0f)
295        // Lightened black with alpha.
296        return Color(0x54, 0x54, 0x54, alpha());
297
298    float multiplier = std::min(1.0f, v + 0.33f) / v;
299
300    return Color(static_cast<int>(multiplier * r * scaleFactor),
301                 static_cast<int>(multiplier * g * scaleFactor),
302                 static_cast<int>(multiplier * b * scaleFactor),
303                 alpha());
304}
305
306Color Color::dark() const
307{
308    // Hardcode this common case for speed.
309    if (m_color == white)
310        return darkenedWhite;
311
312    const float scaleFactor = nextafterf(256.0f, 0.0f);
313
314    float r, g, b, a;
315    getRGBA(r, g, b, a);
316
317    float v = std::max(r, std::max(g, b));
318    float multiplier = std::max(0.0f, (v - 0.33f) / v);
319
320    return Color(static_cast<int>(multiplier * r * scaleFactor),
321                 static_cast<int>(multiplier * g * scaleFactor),
322                 static_cast<int>(multiplier * b * scaleFactor),
323                 alpha());
324}
325
326Color Color::combineWithAlpha(float otherAlpha) const
327{
328    return colorWithOverrideAlpha(rgb(), (alpha() / 255.f) * otherAlpha);
329}
330
331static int blendComponent(int c, int a)
332{
333    // We use white.
334    float alpha = a / 255.0f;
335    int whiteBlend = 255 - a;
336    c -= whiteBlend;
337    return static_cast<int>(c / alpha);
338}
339
340const int cStartAlpha = 153; // 60%
341const int cEndAlpha = 204; // 80%;
342const int cAlphaIncrement = 17; // Increments in between.
343
344Color Color::blend(const Color& source) const
345{
346    if (!alpha() || !source.hasAlpha())
347        return source;
348
349    if (!source.alpha())
350        return *this;
351
352    int d = 255 * (alpha() + source.alpha()) - alpha() * source.alpha();
353    int a = d / 255;
354    int r = (red() * alpha() * (255 - source.alpha()) + 255 * source.alpha() * source.red()) / d;
355    int g = (green() * alpha() * (255 - source.alpha()) + 255 * source.alpha() * source.green()) / d;
356    int b = (blue() * alpha() * (255 - source.alpha()) + 255 * source.alpha() * source.blue()) / d;
357    return Color(r, g, b, a);
358}
359
360Color Color::blendWithWhite() const
361{
362    // If the color contains alpha already, we leave it alone.
363    if (hasAlpha())
364        return *this;
365
366    Color newColor;
367    for (int alpha = cStartAlpha; alpha <= cEndAlpha; alpha += cAlphaIncrement) {
368        // We have a solid color.  Convert to an equivalent color that looks the same when blended with white
369        // at the current alpha.  Try using less transparency if the numbers end up being negative.
370        int r = blendComponent(red(), alpha);
371        int g = blendComponent(green(), alpha);
372        int b = blendComponent(blue(), alpha);
373
374        newColor = Color(r, g, b, alpha);
375
376        if (r >= 0 && g >= 0 && b >= 0)
377            break;
378    }
379    return newColor;
380}
381
382void Color::getRGBA(float& r, float& g, float& b, float& a) const
383{
384    r = red() / 255.0f;
385    g = green() / 255.0f;
386    b = blue() / 255.0f;
387    a = alpha() / 255.0f;
388}
389
390void Color::getRGBA(double& r, double& g, double& b, double& a) const
391{
392    r = red() / 255.0;
393    g = green() / 255.0;
394    b = blue() / 255.0;
395    a = alpha() / 255.0;
396}
397
398void Color::getHSL(double& hue, double& saturation, double& lightness) const
399{
400    // http://en.wikipedia.org/wiki/HSL_color_space. This is a direct copy of
401    // the algorithm therein, although it's 360^o based and we end up wanting
402    // [0...1) based. It's clearer if we stick to 360^o until the end.
403    double r = static_cast<double>(red()) / 255.0;
404    double g = static_cast<double>(green()) / 255.0;
405    double b = static_cast<double>(blue()) / 255.0;
406    double max = std::max(std::max(r, g), b);
407    double min = std::min(std::min(r, g), b);
408
409    if (max == min)
410        hue = 0.0;
411    else if (max == r)
412        hue = (60.0 * ((g - b) / (max - min))) + 360.0;
413    else if (max == g)
414        hue = (60.0 * ((b - r) / (max - min))) + 120.0;
415    else
416        hue = (60.0 * ((r - g) / (max - min))) + 240.0;
417
418    if (hue >= 360.0)
419        hue -= 360.0;
420
421    // makeRGBAFromHSLA assumes that hue is in [0...1).
422    hue /= 360.0;
423
424    lightness = 0.5 * (max + min);
425    if (max == min)
426        saturation = 0.0;
427    else if (lightness <= 0.5)
428        saturation = ((max - min) / (max + min));
429    else
430        saturation = ((max - min) / (2.0 - (max + min)));
431}
432
433Color colorFromPremultipliedARGB(RGBA32 pixelColor)
434{
435    int alpha = alphaChannel(pixelColor);
436    if (alpha && alpha < 255) {
437        return Color::createUnchecked(
438            redChannel(pixelColor) * 255 / alpha,
439            greenChannel(pixelColor) * 255 / alpha,
440            blueChannel(pixelColor) * 255 / alpha,
441            alpha);
442    } else
443        return Color(pixelColor);
444}
445
446RGBA32 premultipliedARGBFromColor(const Color& color)
447{
448    unsigned pixelColor;
449
450    unsigned alpha = color.alpha();
451    if (alpha < 255) {
452        pixelColor = Color::createUnchecked(
453            (color.red() * alpha  + 254) / 255,
454            (color.green() * alpha  + 254) / 255,
455            (color.blue() * alpha  + 254) / 255,
456            alpha).rgb();
457    } else
458         pixelColor = color.rgb();
459
460    return pixelColor;
461}
462
463} // namespace blink
464