qcolor.cpp

Go to the documentation of this file.

// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qcolor.h"
#include "qcolor_p.h"
#include "qdrawhelper_p.h"
#include "qfloat16.h"
#include "qnamespace.h"
#include "qdatastream.h"
#include "qvariant.h"
#include "qdebug.h"
#include "private/qtools_p.h"
 
#include <algorithm>
#include <optional>
 
#include <stdio.h>
#include <limits.h>
 
QT_BEGIN_NAMESPACE
 
// QColor fits into QVariant's internal storage on 64bit systems.
// It could also fit on 32bit systems, but we cannot make it happen in Qt6, due to BC.
#if QT_VERSION >= QT_VERSION_CHECK(7,0,0) || QT_POINTER_SIZE > 4
static_assert(sizeof(QColor) <= QVariant::Private::MaxInternalSize);
#endif
 
static inline int hex2int(const char *s, int n)
{
    if (n < 0)
        return -1;
    int result = 0;
    for (; n > 0; --n) {
        result = result * 16;
        const int h = QtMiscUtils::fromHex(*s++);
        if (h < 0)
            return -1;
        result += h;
    }
    return result;
}
 
static std::optional<QRgba64> get_hex_rgb(const char *name, size_t len)
{
    if (name[0] != '#')
        return std::nullopt;
    name++;
    --len;
    int a, r, g, b;
    a = 65535;
    if (len == 12) {
        r = hex2int(name + 0, 4);
        g = hex2int(name + 4, 4);
        b = hex2int(name + 8, 4);
    } else if (len == 9) {
        r = hex2int(name + 0, 3);
        g = hex2int(name + 3, 3);
        b = hex2int(name + 6, 3);
        if (r == -1 || g == -1 || b == -1)
            return std::nullopt;
        r = (r << 4) | (r >> 8);
        g = (g << 4) | (g >> 8);
        b = (b << 4) | (b >> 8);
    } else if (len == 8) {
        a = hex2int(name + 0, 2) * 0x101;
        r = hex2int(name + 2, 2) * 0x101;
        g = hex2int(name + 4, 2) * 0x101;
        b = hex2int(name + 6, 2) * 0x101;
    } else if (len == 6) {
        r = hex2int(name + 0, 2) * 0x101;
        g = hex2int(name + 2, 2) * 0x101;
        b = hex2int(name + 4, 2) * 0x101;
    } else if (len == 3) {
        r = hex2int(name + 0, 1) * 0x1111;
        g = hex2int(name + 1, 1) * 0x1111;
        b = hex2int(name + 2, 1) * 0x1111;
    } else {
        r = g = b = -1;
    }
    if (uint(r) > 65535 || uint(g) > 65535 || uint(b) > 65535 || uint(a) > 65535)
        return std::nullopt;
    return qRgba64(r, g ,b, a);
}
 
std::optional<QRgb> qt_get_hex_rgb(const char *name)
{
    if (std::optional<QRgba64> rgba64 = get_hex_rgb(name, qstrlen(name)))
        return rgba64->toArgb32();
    return std::nullopt;
}
 
static std::optional<QRgba64> get_hex_rgb(const QChar *str, size_t len)
{
    if (len > 13)
        return std::nullopt;
    char tmp[16];
    for (size_t i = 0; i < len; ++i)
        tmp[i] = str[i].toLatin1();
    tmp[len] = 0;
    return get_hex_rgb(tmp, len);
}
 
static std::optional<QRgba64> get_hex_rgb(QAnyStringView name)
{
    return name.visit([] (auto name) {
        return get_hex_rgb(name.data(), name.size());
    });
}
 
#ifndef QT_NO_COLORNAMES
 
/*
  CSS color names = SVG 1.0 color names + transparent (rgba(0,0,0,0))
*/
 
#ifdef rgb
#  undef rgb
#endif
#define rgb(r,g,b) (0xff000000 | (r << 16) |  (g << 8) | b)
 
// keep this is in sync with QColorConstants
static constexpr struct RGBData {
    const char name[21];
    uint  value;
} rgbTbl[] = {
    { "aliceblue", rgb(240, 248, 255) },
    { "antiquewhite", rgb(250, 235, 215) },
    { "aqua", rgb( 0, 255, 255) },
    { "aquamarine", rgb(127, 255, 212) },
    { "azure", rgb(240, 255, 255) },
    { "beige", rgb(245, 245, 220) },
    { "bisque", rgb(255, 228, 196) },
    { "black", rgb( 0, 0, 0) },
    { "blanchedalmond", rgb(255, 235, 205) },
    { "blue", rgb( 0, 0, 255) },
    { "blueviolet", rgb(138, 43, 226) },
    { "brown", rgb(165, 42, 42) },
    { "burlywood", rgb(222, 184, 135) },
    { "cadetblue", rgb( 95, 158, 160) },
    { "chartreuse", rgb(127, 255, 0) },
    { "chocolate", rgb(210, 105, 30) },
    { "coral", rgb(255, 127, 80) },
    { "cornflowerblue", rgb(100, 149, 237) },
    { "cornsilk", rgb(255, 248, 220) },
    { "crimson", rgb(220, 20, 60) },
    { "cyan", rgb( 0, 255, 255) },
    { "darkblue", rgb( 0, 0, 139) },
    { "darkcyan", rgb( 0, 139, 139) },
    { "darkgoldenrod", rgb(184, 134, 11) },
    { "darkgray", rgb(169, 169, 169) },
    { "darkgreen", rgb( 0, 100, 0) },
    { "darkgrey", rgb(169, 169, 169) },
    { "darkkhaki", rgb(189, 183, 107) },
    { "darkmagenta", rgb(139, 0, 139) },
    { "darkolivegreen", rgb( 85, 107, 47) },
    { "darkorange", rgb(255, 140, 0) },
    { "darkorchid", rgb(153, 50, 204) },
    { "darkred", rgb(139, 0, 0) },
    { "darksalmon", rgb(233, 150, 122) },
    { "darkseagreen", rgb(143, 188, 143) },
    { "darkslateblue", rgb( 72, 61, 139) },
    { "darkslategray", rgb( 47, 79, 79) },
    { "darkslategrey", rgb( 47, 79, 79) },
    { "darkturquoise", rgb( 0, 206, 209) },
    { "darkviolet", rgb(148, 0, 211) },
    { "deeppink", rgb(255, 20, 147) },
    { "deepskyblue", rgb( 0, 191, 255) },
    { "dimgray", rgb(105, 105, 105) },
    { "dimgrey", rgb(105, 105, 105) },
    { "dodgerblue", rgb( 30, 144, 255) },
    { "firebrick", rgb(178, 34, 34) },
    { "floralwhite", rgb(255, 250, 240) },
    { "forestgreen", rgb( 34, 139, 34) },
    { "fuchsia", rgb(255, 0, 255) },
    { "gainsboro", rgb(220, 220, 220) },
    { "ghostwhite", rgb(248, 248, 255) },
    { "gold", rgb(255, 215, 0) },
    { "goldenrod", rgb(218, 165, 32) },
    { "gray", rgb(128, 128, 128) },
    { "green", rgb( 0, 128, 0) },
    { "greenyellow", rgb(173, 255, 47) },
    { "grey", rgb(128, 128, 128) },
    { "honeydew", rgb(240, 255, 240) },
    { "hotpink", rgb(255, 105, 180) },
    { "indianred", rgb(205, 92, 92) },
    { "indigo", rgb( 75, 0, 130) },
    { "ivory", rgb(255, 255, 240) },
    { "khaki", rgb(240, 230, 140) },
    { "lavender", rgb(230, 230, 250) },
    { "lavenderblush", rgb(255, 240, 245) },
    { "lawngreen", rgb(124, 252, 0) },
    { "lemonchiffon", rgb(255, 250, 205) },
    { "lightblue", rgb(173, 216, 230) },
    { "lightcoral", rgb(240, 128, 128) },
    { "lightcyan", rgb(224, 255, 255) },
    { "lightgoldenrodyellow", rgb(250, 250, 210) },
    { "lightgray", rgb(211, 211, 211) },
    { "lightgreen", rgb(144, 238, 144) },
    { "lightgrey", rgb(211, 211, 211) },
    { "lightpink", rgb(255, 182, 193) },
    { "lightsalmon", rgb(255, 160, 122) },
    { "lightseagreen", rgb( 32, 178, 170) },
    { "lightskyblue", rgb(135, 206, 250) },
    { "lightslategray", rgb(119, 136, 153) },
    { "lightslategrey", rgb(119, 136, 153) },
    { "lightsteelblue", rgb(176, 196, 222) },
    { "lightyellow", rgb(255, 255, 224) },
    { "lime", rgb( 0, 255, 0) },
    { "limegreen", rgb( 50, 205, 50) },
    { "linen", rgb(250, 240, 230) },
    { "magenta", rgb(255, 0, 255) },
    { "maroon", rgb(128, 0, 0) },
    { "mediumaquamarine", rgb(102, 205, 170) },
    { "mediumblue", rgb( 0, 0, 205) },
    { "mediumorchid", rgb(186, 85, 211) },
    { "mediumpurple", rgb(147, 112, 219) },
    { "mediumseagreen", rgb( 60, 179, 113) },
    { "mediumslateblue", rgb(123, 104, 238) },
    { "mediumspringgreen", rgb( 0, 250, 154) },
    { "mediumturquoise", rgb( 72, 209, 204) },
    { "mediumvioletred", rgb(199, 21, 133) },
    { "midnightblue", rgb( 25, 25, 112) },
    { "mintcream", rgb(245, 255, 250) },
    { "mistyrose", rgb(255, 228, 225) },
    { "moccasin", rgb(255, 228, 181) },
    { "navajowhite", rgb(255, 222, 173) },
    { "navy", rgb( 0, 0, 128) },
    { "oldlace", rgb(253, 245, 230) },
    { "olive", rgb(128, 128, 0) },
    { "olivedrab", rgb(107, 142, 35) },
    { "orange", rgb(255, 165, 0) },
    { "orangered", rgb(255, 69, 0) },
    { "orchid", rgb(218, 112, 214) },
    { "palegoldenrod", rgb(238, 232, 170) },
    { "palegreen", rgb(152, 251, 152) },
    { "paleturquoise", rgb(175, 238, 238) },
    { "palevioletred", rgb(219, 112, 147) },
    { "papayawhip", rgb(255, 239, 213) },
    { "peachpuff", rgb(255, 218, 185) },
    { "peru", rgb(205, 133, 63) },
    { "pink", rgb(255, 192, 203) },
    { "plum", rgb(221, 160, 221) },
    { "powderblue", rgb(176, 224, 230) },
    { "purple", rgb(128, 0, 128) },
    { "red", rgb(255, 0, 0) },
    { "rosybrown", rgb(188, 143, 143) },
    { "royalblue", rgb( 65, 105, 225) },
    { "saddlebrown", rgb(139, 69, 19) },
    { "salmon", rgb(250, 128, 114) },
    { "sandybrown", rgb(244, 164, 96) },
    { "seagreen", rgb( 46, 139, 87) },
    { "seashell", rgb(255, 245, 238) },
    { "sienna", rgb(160, 82, 45) },
    { "silver", rgb(192, 192, 192) },
    { "skyblue", rgb(135, 206, 235) },
    { "slateblue", rgb(106, 90, 205) },
    { "slategray", rgb(112, 128, 144) },
    { "slategrey", rgb(112, 128, 144) },
    { "snow", rgb(255, 250, 250) },
    { "springgreen", rgb( 0, 255, 127) },
    { "steelblue", rgb( 70, 130, 180) },
    { "tan", rgb(210, 180, 140) },
    { "teal", rgb( 0, 128, 128) },
    { "thistle", rgb(216, 191, 216) },
    { "tomato", rgb(255, 99, 71) },
    { "transparent", 0 },
    { "turquoise", rgb( 64, 224, 208) },
    { "violet", rgb(238, 130, 238) },
    { "wheat", rgb(245, 222, 179) },
    { "white", rgb(255, 255, 255) },
    { "whitesmoke", rgb(245, 245, 245) },
    { "yellow", rgb(255, 255, 0) },
    { "yellowgreen", rgb(154, 205, 50) }
};
 
static const int rgbTblSize = sizeof(rgbTbl) / sizeof(RGBData);
 
static_assert([] {
    for (auto e : rgbTbl) {
        for (auto it = e.name; *it ; ++it) {
            if (uchar(*it) > 127)
                return false;
        }
    }
    return true;
    }(), "the lookup code expects color names to be US-ASCII-only");
 
#undef rgb
 
inline bool operator<(const char *name, const RGBData &data)
{ return qstrcmp(name, data.name) < 0; }
inline bool operator<(const RGBData &data, const char *name)
{ return qstrcmp(data.name, name) < 0; }
 
static std::optional<QRgb> get_named_rgb_no_space(const char *name_no_space)
{
    const RGBData *r = std::lower_bound(rgbTbl, rgbTbl + rgbTblSize, name_no_space);
    if ((r != rgbTbl + rgbTblSize) && !(name_no_space < *r))
        return r->value;
    return std::nullopt;
}
 
namespace {
// named colors are US-ASCII (enforced by static_assert above):
static char to_char(char ch) noexcept { return ch; }
static char to_char(QChar ch) noexcept { return ch.toLatin1(); }
}
 
static std::optional<QRgb> get_named_rgb(QAnyStringView name)
{
    if (name.size() > 255)
        return std::nullopt;
    char name_no_space[256];
    int pos = 0;
    name.visit([&pos, &name_no_space] (auto name) {
        for (auto c : name) {
            if (c != u'\t' && c != u' ')
                name_no_space[pos++] = QtMiscUtils::toAsciiLower(to_char(c));
        }
    });
    name_no_space[pos] = 0;
 
    return get_named_rgb_no_space(name_no_space);
}
 
#endif // QT_NO_COLORNAMES
 
static QStringList get_colornames()
{
    QStringList lst;
#ifndef QT_NO_COLORNAMES
    lst.reserve(rgbTblSize);
    for (int i = 0; i < rgbTblSize; i++)
        lst << QLatin1StringView(rgbTbl[i].name);
#endif
    return lst;
}
 
#define QCOLOR_INT_RANGE_CHECK(fn, var) \
    do { \
        if (var < 0 || var > 255) { \
            qWarning(#fn": invalid value %d", var); \
            var = qMax(0, qMin(var, 255)); \
        } \
    } while (0)
 
#define QCOLOR_REAL_RANGE_CHECK(fn, var) \
    do { \
        if (var < 0.0f || var > 1.0f) { \
            qWarning(#fn": invalid value %g", var); \
            var = qMax(0.0f, qMin(var, 1.0f));      \
        } \
    } while (0)
 
/*****************************************************************************
  QColor member functions
 *****************************************************************************/
 
QColor::QColor(Qt::GlobalColor color) noexcept
{
#define QRGB(r, g, b) \
    QRgb(((0xffu << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff)))
#define QRGBA(r, g, b, a) \
    QRgb(((a & 0xff) << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff))
 
    static const QRgb global_colors[] = {
        QRGB(255, 255, 255), // Qt::color0
        QRGB(  0,   0,   0), // Qt::color1
        QRGB(  0,   0,   0), // black
        QRGB(255, 255, 255), // white
        /*
         * From the "The Palette Manager: How and Why" by Ron Gery,
         * March 23, 1992, archived on MSDN:
         *
         *     The Windows system palette is broken up into two
         *     sections, one with fixed colors and one with colors
         *     that can be changed by applications. The system palette
         *     predefines 20 entries; these colors are known as the
         *     static or reserved colors and consist of the 16 colors
         *     found in the Windows version 3.0 VGA driver and 4
         *     additional colors chosen for their visual appeal.  The
         *     DEFAULT_PALETTE stock object is, as the name implies,
         *     the default palette selected into a device context (DC)
         *     and consists of these static colors. Applications can
         *     set the remaining 236 colors using the Palette Manager.
         *
         * The 20 reserved entries have indices in [0,9] and
         * [246,255]. We reuse 17 of them.
         */
        QRGB(128, 128, 128), // index 248   medium gray
        QRGB(160, 160, 164), // index 247   light gray
        QRGB(192, 192, 192), // index 7     light gray
        QRGB(255,   0,   0), // index 249   red
        QRGB(  0, 255,   0), // index 250   green
        QRGB(  0,   0, 255), // index 252   blue
        QRGB(  0, 255, 255), // index 254   cyan
        QRGB(255,   0, 255), // index 253   magenta
        QRGB(255, 255,   0), // index 251   yellow
        QRGB(128,   0,   0), // index 1     dark red
        QRGB(  0, 128,   0), // index 2     dark green
        QRGB(  0,   0, 128), // index 4     dark blue
        QRGB(  0, 128, 128), // index 6     dark cyan
        QRGB(128,   0, 128), // index 5     dark magenta
        QRGB(128, 128,   0), // index 3     dark yellow
        QRGBA(0, 0, 0, 0)    //             transparent
    };
#undef QRGB
#undef QRGBA
 
    setRgb(qRed(global_colors[color]),
           qGreen(global_colors[color]),
           qBlue(global_colors[color]),
           qAlpha(global_colors[color]));
}
 
QColor::QColor(QRgb color) noexcept
{
    cspec = Rgb;
    ct.argb.alpha = 0xffff;
    ct.argb.red   = qRed(color)   * 0x101;
    ct.argb.green = qGreen(color) * 0x101;
    ct.argb.blue  = qBlue(color)  * 0x101;
    ct.argb.pad   = 0;
}
 
QColor::QColor(QRgba64 rgba64) noexcept
{
    setRgba64(rgba64);
}
 
QColor::QColor(Spec spec) noexcept
{
    switch (spec) {
    case Invalid:
        invalidate();
        break;
    case Rgb:
        setRgb(0, 0, 0);
        break;
    case Hsv:
        setHsv(0, 0, 0);
        break;
    case Cmyk:
        setCmyk(0, 0, 0, 0);
        break;
    case Hsl:
        setHsl(0, 0, 0, 0);
        break;
    case ExtendedRgb:
        cspec = spec;
        setRgbF(0, 0, 0, 0);
        break;
    }
}
 
// ### Qt 7: remove those after deprecating them for the last Qt 6 LTS release
QString QColor::name(NameFormat format) const
{
    switch (format) {
    case HexRgb:
        return u'#' + QStringView{QString::number(rgba() | 0x1000000, 16)}.right(6);
    case HexArgb:
        // it's called rgba() but it does return AARRGGBB
        return u'#' + QStringView{QString::number(rgba() | Q_INT64_C(0x100000000), 16)}.right(8);
    }
    return QString();
}
 
#if QT_DEPRECATED_SINCE(6, 6)
void QColor::setNamedColor(const QString &name)
{
    *this = fromString(qToAnyStringViewIgnoringNull(name));
}
 
void QColor::setNamedColor(QStringView name)
{
    *this = fromString(name);
}
 
void QColor::setNamedColor(QLatin1StringView name)
{
    *this = fromString(name);
}
 
bool QColor::isValidColor(const QString &name)
{
    return isValidColorName(qToAnyStringViewIgnoringNull(name));
}
 
bool QColor::isValidColor(QStringView name) noexcept
{
    return isValidColorName(name);
}
 
bool QColor::isValidColor(QLatin1StringView name) noexcept
{
    return isValidColorName(name);
}
#endif // QT_DEPRECATED_SINCE(6, 6)
 
bool QColor::isValidColorName(QAnyStringView name) noexcept
{
    return fromString(name).isValid();
}
 
QColor QColor::fromString(QAnyStringView name) noexcept
{
    if (!name.size())
        return {};
 
    if (name.front() == u'#') {
        if (std::optional<QRgba64> r = get_hex_rgb(name))
            return QColor::fromRgba64(*r);
#ifndef QT_NO_COLORNAMES
    } else if (std::optional<QRgb> r = get_named_rgb(name)) {
        return QColor::fromRgba(*r);
#endif
    }
 
    return {};
}
 
QStringList QColor::colorNames()
{
    return get_colornames();
}
 
void QColor::getHsvF(float *h, float *s, float *v, float *a) const
{
        if (!h || !s || !v)
        return;
 
    if (cspec != Invalid && cspec != Hsv) {
        toHsv().getHsvF(h, s, v, a);
        return;
    }
 
    *h = ct.ahsv.hue == USHRT_MAX ? -1.0f : ct.ahsv.hue / 36000.0f;
    *s = ct.ahsv.saturation / float(USHRT_MAX);
    *v = ct.ahsv.value / float(USHRT_MAX);
 
    if (a)
        *a = ct.ahsv.alpha / float(USHRT_MAX);
}
 
void QColor::getHsv(int *h, int *s, int *v, int *a) const
{
    if (!h || !s || !v)
        return;
 
    if (cspec != Invalid && cspec != Hsv) {
        toHsv().getHsv(h, s, v, a);
        return;
    }
 
    *h = ct.ahsv.hue == USHRT_MAX ? -1 : ct.ahsv.hue / 100;
    *s = qt_div_257(ct.ahsv.saturation);
    *v = qt_div_257(ct.ahsv.value);
 
    if (a)
        *a = qt_div_257(ct.ahsv.alpha);
}
 
void QColor::setHsvF(float h, float s, float v, float a)
{
    if (((h < 0.0f || h > 1.0f) && h != -1.0f)
        || (s < 0.0f || s > 1.0f)
        || (v < 0.0f || v > 1.0f)
        || (a < 0.0f || a > 1.0f)) {
        qWarning("QColor::setHsvF: HSV parameters out of range");
        invalidate();
        return;
    }
 
    cspec = Hsv;
    ct.ahsv.alpha      = qRound(a * USHRT_MAX);
    ct.ahsv.hue        = h == -1.0f ? USHRT_MAX : qRound(h * 36000.0f);
    ct.ahsv.saturation = qRound(s * USHRT_MAX);
    ct.ahsv.value      = qRound(v * USHRT_MAX);
    ct.ahsv.pad        = 0;
}
 
void QColor::setHsv(int h, int s, int v, int a)
{
    if (h < -1 || (uint)s > 255 || (uint)v > 255 || (uint)a > 255) {
        qWarning("QColor::setHsv: HSV parameters out of range");
        invalidate();
        return;
    }
 
    cspec = Hsv;
    ct.ahsv.alpha      = a * 0x101;
    ct.ahsv.hue        = h == -1 ? USHRT_MAX : (h % 360) * 100;
    ct.ahsv.saturation = s * 0x101;
    ct.ahsv.value      = v * 0x101;
    ct.ahsv.pad        = 0;
}
 
void QColor::getHslF(float *h, float *s, float *l, float *a) const
{
        if (!h || !s || !l)
        return;
 
    if (cspec != Invalid && cspec != Hsl) {
        toHsl().getHslF(h, s, l, a);
        return;
    }
 
    *h = ct.ahsl.hue == USHRT_MAX ? -1.0f : ct.ahsl.hue / 36000.0f;
    *s = ct.ahsl.saturation / float(USHRT_MAX);
    *l = ct.ahsl.lightness / float(USHRT_MAX);
 
    if (a)
        *a = ct.ahsl.alpha / float(USHRT_MAX);
}
 
void QColor::getHsl(int *h, int *s, int *l, int *a) const
{
    if (!h || !s || !l)
        return;
 
    if (cspec != Invalid && cspec != Hsl) {
        toHsl().getHsl(h, s, l, a);
        return;
    }
 
    *h = ct.ahsl.hue == USHRT_MAX ? -1 : ct.ahsl.hue / 100;
    *s = qt_div_257(ct.ahsl.saturation);
    *l = qt_div_257(ct.ahsl.lightness);
 
    if (a)
        *a = qt_div_257(ct.ahsl.alpha);
}
 
void QColor::setHslF(float h, float s, float l, float a)
{
    if (((h < 0.0f || h > 1.0f) && h != -1.0f)
        || (s < 0.0f || s > 1.0f)
        || (l < 0.0f || l > 1.0f)
        || (a < 0.0f || a > 1.0f)) {
        qWarning("QColor::setHslF: HSL parameters out of range");
        invalidate();
        return;
    }
 
    cspec = Hsl;
    ct.ahsl.alpha      = qRound(a * USHRT_MAX);
    ct.ahsl.hue        = h == -1.0f ? USHRT_MAX : qRound(h * 36000.0f);
    ct.ahsl.saturation = qRound(s * USHRT_MAX);
    ct.ahsl.lightness  = qRound(l * USHRT_MAX);
    ct.ahsl.pad        = 0;
}
 
void QColor::setHsl(int h, int s, int l, int a)
{
    if (h < -1 || (uint)s > 255 || (uint)l > 255 || (uint)a > 255) {
        qWarning("QColor::setHsl: HSL parameters out of range");
        invalidate();
        return;
    }
 
    cspec = Hsl;
    ct.ahsl.alpha      = a * 0x101;
    ct.ahsl.hue        = h == -1 ? USHRT_MAX : (h % 360) * 100;
    ct.ahsl.saturation = s * 0x101;
    ct.ahsl.lightness  = l * 0x101;
    ct.ahsl.pad        = 0;
}
 
static inline qfloat16 &castF16(quint16 &v)
{
    // this works because qfloat16 internally is a quint16
    return *reinterpret_cast<qfloat16 *>(&v);
}
 
static inline const qfloat16 &castF16(const quint16 &v)
{
    return *reinterpret_cast<const qfloat16 *>(&v);
}
 
void QColor::getRgbF(float *r, float *g, float *b, float *a) const
{
    if (!r || !g || !b)
        return;
 
    if (cspec != Invalid && cspec != Rgb && cspec != ExtendedRgb) {
        toRgb().getRgbF(r, g, b, a);
        return;
    }
 
    if (cspec == Rgb || cspec == Invalid) {
        *r = ct.argb.red   / float(USHRT_MAX);
        *g = ct.argb.green / float(USHRT_MAX);
        *b = ct.argb.blue  / float(USHRT_MAX);
        if (a)
            *a = ct.argb.alpha / float(USHRT_MAX);
    }  else {
        *r = castF16(ct.argbExtended.redF16);
        *g = castF16(ct.argbExtended.greenF16);
        *b = castF16(ct.argbExtended.blueF16);
        if (a)
            *a = castF16(ct.argbExtended.alphaF16);
    }
}
 
void QColor::getRgb(int *r, int *g, int *b, int *a) const
{
    if (!r || !g || !b)
        return;
 
    if (cspec != Invalid && cspec != Rgb) {
        toRgb().getRgb(r, g, b, a);
        return;
    }
 
    *r = qt_div_257(ct.argb.red);
    *g = qt_div_257(ct.argb.green);
    *b = qt_div_257(ct.argb.blue);
 
    if (a)
        *a = qt_div_257(ct.argb.alpha);
}
 
void QColor::setRgbF(float r, float g, float b, float a)
{
    if (a < 0.0f || a > 1.0f) {
        qWarning("QColor::setRgbF: Alpha parameter is out of range");
        invalidate();
        return;
    }
    if (r < 0.0f || r > 1.0f ||
        g < 0.0f || g > 1.0f ||
        b < 0.0f || b > 1.0f || cspec == ExtendedRgb) {
        cspec = ExtendedRgb;
        castF16(ct.argbExtended.redF16)   = qfloat16(r);
        castF16(ct.argbExtended.greenF16) = qfloat16(g);
        castF16(ct.argbExtended.blueF16)  = qfloat16(b);
        castF16(ct.argbExtended.alphaF16) = qfloat16(a);
        ct.argbExtended.pad   = 0;
        return;
    }
    cspec = Rgb;
    ct.argb.red   = qRound(r * USHRT_MAX);
    ct.argb.green = qRound(g * USHRT_MAX);
    ct.argb.blue  = qRound(b * USHRT_MAX);
    ct.argb.alpha = qRound(a * USHRT_MAX);
    ct.argb.pad   = 0;
}
 
void QColor::setRgb(int r, int g, int b, int a)
{
    if (!isRgbaValid(r, g, b, a)) {
        qWarning("QColor::setRgb: RGB parameters out of range");
        invalidate();
        return;
    }
 
    cspec = Rgb;
    ct.argb.alpha = a * 0x101;
    ct.argb.red   = r * 0x101;
    ct.argb.green = g * 0x101;
    ct.argb.blue  = b * 0x101;
    ct.argb.pad   = 0;
}
 
QRgb QColor::rgba() const noexcept
{
    if (cspec != Invalid && cspec != Rgb)
        return toRgb().rgba();
    return qRgba(qt_div_257(ct.argb.red), qt_div_257(ct.argb.green), qt_div_257(ct.argb.blue), qt_div_257(ct.argb.alpha));
}
 
void QColor::setRgba(QRgb rgba) noexcept
{
    cspec = Rgb;
    ct.argb.alpha = qAlpha(rgba) * 0x101;
    ct.argb.red   = qRed(rgba)   * 0x101;
    ct.argb.green = qGreen(rgba) * 0x101;
    ct.argb.blue  = qBlue(rgba)  * 0x101;
    ct.argb.pad   = 0;
}
 
QRgba64 QColor::rgba64() const noexcept
{
    if (cspec != Invalid && cspec != Rgb)
        return toRgb().rgba64();
    return qRgba64(ct.argb.red, ct.argb.green, ct.argb.blue, ct.argb.alpha);
}
 
void QColor::setRgba64(QRgba64 rgba) noexcept
{
    cspec = Rgb;
    ct.argb.alpha = rgba.alpha();
    ct.argb.red   = rgba.red();
    ct.argb.green = rgba.green();
    ct.argb.blue  = rgba.blue();
    ct.argb.pad   = 0;
}
 
QRgb QColor::rgb() const noexcept
{
    if (cspec != Invalid && cspec != Rgb)
        return toRgb().rgb();
    return qRgb(qt_div_257(ct.argb.red), qt_div_257(ct.argb.green), qt_div_257(ct.argb.blue));
}
 
void QColor::setRgb(QRgb rgb) noexcept
{
    cspec = Rgb;
    ct.argb.alpha = 0xffff;
    ct.argb.red   = qRed(rgb)   * 0x101;
    ct.argb.green = qGreen(rgb) * 0x101;
    ct.argb.blue  = qBlue(rgb)  * 0x101;
    ct.argb.pad   = 0;
}
 
int QColor::alpha() const noexcept
{
    if (cspec == ExtendedRgb)
        return qRound(float(castF16(ct.argbExtended.alphaF16)) * 255);
    return qt_div_257(ct.argb.alpha);
}
 
 
void QColor::setAlpha(int alpha)
{
    QCOLOR_INT_RANGE_CHECK("QColor::setAlpha", alpha);
    if (cspec == ExtendedRgb) {
        constexpr float f = 1.0f / 255;
        castF16(ct.argbExtended.alphaF16) = qfloat16(alpha * f);
        return;
    }
    ct.argb.alpha = alpha * 0x101;
}
 
float QColor::alphaF() const noexcept
{
    if (cspec == ExtendedRgb)
        return castF16(ct.argbExtended.alphaF16);
    return ct.argb.alpha / float(USHRT_MAX);
}
 
void QColor::setAlphaF(float alpha)
{
    QCOLOR_REAL_RANGE_CHECK("QColor::setAlphaF", alpha);
    if (cspec == ExtendedRgb) {
        castF16(ct.argbExtended.alphaF16) = qfloat16(alpha);
        return;
    }
    float tmp = alpha * USHRT_MAX;
    ct.argb.alpha = qRound(tmp);
}
 
 
int QColor::red() const noexcept
{
    if (cspec != Invalid && cspec != Rgb)
        return toRgb().red();
    return qt_div_257(ct.argb.red);
}
 
void QColor::setRed(int red)
{
    QCOLOR_INT_RANGE_CHECK("QColor::setRed", red);
    if (cspec != Rgb)
        setRgb(red, green(), blue(), alpha());
    else
        ct.argb.red = red * 0x101;
}
 
int QColor::green() const noexcept
{
    if (cspec != Invalid && cspec != Rgb)
        return toRgb().green();
    return qt_div_257(ct.argb.green);
}
 
void QColor::setGreen(int green)
{
    QCOLOR_INT_RANGE_CHECK("QColor::setGreen", green);
    if (cspec != Rgb)
        setRgb(red(), green, blue(), alpha());
    else
        ct.argb.green = green * 0x101;
}
 
 
int QColor::blue() const noexcept
{
    if (cspec != Invalid && cspec != Rgb)
        return toRgb().blue();
    return qt_div_257(ct.argb.blue);
}
 
 
void QColor::setBlue(int blue)
{
    QCOLOR_INT_RANGE_CHECK("QColor::setBlue", blue);
    if (cspec != Rgb)
        setRgb(red(), green(), blue, alpha());
    else
        ct.argb.blue = blue * 0x101;
}
 
float QColor::redF() const noexcept
{
    if (cspec == Rgb || cspec == Invalid)
        return ct.argb.red / float(USHRT_MAX);
    if (cspec == ExtendedRgb)
        return castF16(ct.argbExtended.redF16);
 
    return toRgb().redF();
}
 
 
void QColor::setRedF(float red)
{
    if (cspec == Rgb && red >= 0.0f && red <= 1.0f)
        ct.argb.red = qRound(red * USHRT_MAX);
    else if (cspec == ExtendedRgb)
        castF16(ct.argbExtended.redF16) = qfloat16(red);
    else
        setRgbF(red, greenF(), blueF(), alphaF());
}
 
float QColor::greenF() const noexcept
{
    if (cspec == Rgb || cspec == Invalid)
        return ct.argb.green / float(USHRT_MAX);
    if (cspec == ExtendedRgb)
        return castF16(ct.argbExtended.greenF16);
 
    return toRgb().greenF();
}
 
 
void QColor::setGreenF(float green)
{
    if (cspec == Rgb && green >= 0.0f && green <= 1.0f)
        ct.argb.green = qRound(green * USHRT_MAX);
    else if (cspec == ExtendedRgb)
        castF16(ct.argbExtended.greenF16) = qfloat16(green);
    else
        setRgbF(redF(), green, blueF(), alphaF());
}
 
float QColor::blueF() const noexcept
{
    if (cspec == Rgb || cspec == Invalid)
        return ct.argb.blue / float(USHRT_MAX);
    if (cspec == ExtendedRgb)
        return castF16(ct.argbExtended.blueF16);
 
    return toRgb().blueF();
}
 
void QColor::setBlueF(float blue)
{
    if (cspec == Rgb && blue >= 0.0f && blue <= 1.0f)
        ct.argb.blue = qRound(blue * USHRT_MAX);
    else if (cspec == ExtendedRgb)
        castF16(ct.argbExtended.blueF16) = qfloat16(blue);
    else
        setRgbF(redF(), greenF(), blue, alphaF());
}
 
int QColor::hue() const noexcept
{
    return hsvHue();
}
 
int QColor::hsvHue() const noexcept
{
    if (cspec != Invalid && cspec != Hsv)
        return toHsv().hue();
    return ct.ahsv.hue == USHRT_MAX ? -1 : ct.ahsv.hue / 100;
}
 
int QColor::saturation() const noexcept
{
    return hsvSaturation();
}
 
int QColor::hsvSaturation() const noexcept
{
    if (cspec != Invalid && cspec != Hsv)
        return toHsv().saturation();
    return qt_div_257(ct.ahsv.saturation);
}
 
int QColor::value() const noexcept
{
    if (cspec != Invalid && cspec != Hsv)
        return toHsv().value();
    return qt_div_257(ct.ahsv.value);
}
 
float QColor::hueF() const noexcept
{
    return hsvHueF();
}
 
float QColor::hsvHueF() const noexcept
{
    if (cspec != Invalid && cspec != Hsv)
        return toHsv().hueF();
    return ct.ahsv.hue == USHRT_MAX ? -1.0f : ct.ahsv.hue / 36000.0f;
}
 
float QColor::saturationF() const noexcept
{
    return hsvSaturationF();
}
 
float QColor::hsvSaturationF() const noexcept
{
    if (cspec != Invalid && cspec != Hsv)
        return toHsv().saturationF();
    return ct.ahsv.saturation / float(USHRT_MAX);
}
 
float QColor::valueF() const noexcept
{
    if (cspec != Invalid && cspec != Hsv)
        return toHsv().valueF();
    return ct.ahsv.value / float(USHRT_MAX);
}
 
int QColor::hslHue() const noexcept
{
    if (cspec != Invalid && cspec != Hsl)
        return toHsl().hslHue();
    return ct.ahsl.hue == USHRT_MAX ? -1 : ct.ahsl.hue / 100;
}
 
int QColor::hslSaturation() const noexcept
{
    if (cspec != Invalid && cspec != Hsl)
        return toHsl().hslSaturation();
    return qt_div_257(ct.ahsl.saturation);
}
 
int QColor::lightness() const noexcept
{
    if (cspec != Invalid && cspec != Hsl)
        return toHsl().lightness();
    return qt_div_257(ct.ahsl.lightness);
}
 
float QColor::hslHueF() const noexcept
{
    if (cspec != Invalid && cspec != Hsl)
        return toHsl().hslHueF();
    return ct.ahsl.hue == USHRT_MAX ? -1.0f : ct.ahsl.hue / 36000.0f;
}
 
float QColor::hslSaturationF() const noexcept
{
    if (cspec != Invalid && cspec != Hsl)
        return toHsl().hslSaturationF();
    return ct.ahsl.saturation / float(USHRT_MAX);
}
 
float QColor::lightnessF() const noexcept
{
    if (cspec != Invalid && cspec != Hsl)
        return toHsl().lightnessF();
    return ct.ahsl.lightness / float(USHRT_MAX);
}
 
int QColor::cyan() const noexcept
{
    if (cspec != Invalid && cspec != Cmyk)
        return toCmyk().cyan();
    return qt_div_257(ct.acmyk.cyan);
}
 
int QColor::magenta() const noexcept
{
    if (cspec != Invalid && cspec != Cmyk)
        return toCmyk().magenta();
    return qt_div_257(ct.acmyk.magenta);
}
 
int QColor::yellow() const noexcept
{
    if (cspec != Invalid && cspec != Cmyk)
        return toCmyk().yellow();
    return qt_div_257(ct.acmyk.yellow);
}
 
int QColor::black() const noexcept
{
    if (cspec != Invalid && cspec != Cmyk)
        return toCmyk().black();
    return qt_div_257(ct.acmyk.black);
}
 
float QColor::cyanF() const noexcept
{
    if (cspec != Invalid && cspec != Cmyk)
        return toCmyk().cyanF();
    return ct.acmyk.cyan / float(USHRT_MAX);
}
 
float QColor::magentaF() const noexcept
{
    if (cspec != Invalid && cspec != Cmyk)
        return toCmyk().magentaF();
    return ct.acmyk.magenta / float(USHRT_MAX);
}
 
float QColor::yellowF() const noexcept
{
    if (cspec != Invalid && cspec != Cmyk)
        return toCmyk().yellowF();
    return ct.acmyk.yellow / float(USHRT_MAX);
}
 
float QColor::blackF() const noexcept
{
    if (cspec != Invalid && cspec != Cmyk)
        return toCmyk().blackF();
    return ct.acmyk.black / float(USHRT_MAX);
}
 
QColor QColor::toExtendedRgb() const noexcept
{
    if (!isValid() || cspec == ExtendedRgb)
        return *this;
    if (cspec != Rgb)
        return toRgb().toExtendedRgb();
 
    constexpr float f = 1.0f / USHRT_MAX;
    QColor color;
    color.cspec = ExtendedRgb;
    castF16(color.ct.argbExtended.alphaF16) = qfloat16(ct.argb.alpha * f);
    castF16(color.ct.argbExtended.redF16)   = qfloat16(ct.argb.red   * f);
    castF16(color.ct.argbExtended.greenF16) = qfloat16(ct.argb.green * f);
    castF16(color.ct.argbExtended.blueF16)  = qfloat16(ct.argb.blue  * f);
    color.ct.argbExtended.pad = 0;
    return color;
}
 
QColor QColor::toRgb() const noexcept
{
    if (!isValid() || cspec == Rgb)
        return *this;
 
    QColor color;
    color.cspec = Rgb;
    if (cspec != ExtendedRgb)
        color.ct.argb.alpha = ct.argb.alpha;
    color.ct.argb.pad = 0;
 
    switch (cspec) {
    case Hsv:
        {
            if (ct.ahsv.saturation == 0 || ct.ahsv.hue == USHRT_MAX) {
                // achromatic case
                color.ct.argb.red = color.ct.argb.green = color.ct.argb.blue = ct.ahsv.value;
                break;
            }
 
            // chromatic case
            const float h = ct.ahsv.hue == 36000 ? 0.0f : ct.ahsv.hue / 6000.0f;
            const float s = ct.ahsv.saturation / float(USHRT_MAX);
            const float v = ct.ahsv.value / float(USHRT_MAX);
            const int i = int(h);
            const float f = h - i;
            const float p = v * (1.0f - s);
 
            if (i & 1) {
                const float q = v * (1.0f - (s * f));
 
                switch (i) {
                case 1:
                    color.ct.argb.red   = qRound(q * USHRT_MAX);
                    color.ct.argb.green = qRound(v * USHRT_MAX);
                    color.ct.argb.blue  = qRound(p * USHRT_MAX);
                    break;
                case 3:
                    color.ct.argb.red   = qRound(p * USHRT_MAX);
                    color.ct.argb.green = qRound(q * USHRT_MAX);
                    color.ct.argb.blue  = qRound(v * USHRT_MAX);
                    break;
                case 5:
                    color.ct.argb.red   = qRound(v * USHRT_MAX);
                    color.ct.argb.green = qRound(p * USHRT_MAX);
                    color.ct.argb.blue  = qRound(q * USHRT_MAX);
                    break;
                }
            } else {
                const float t = v * (1.0f - (s * (1.0f - f)));
 
                switch (i) {
                case 0:
                    color.ct.argb.red   = qRound(v * USHRT_MAX);
                    color.ct.argb.green = qRound(t * USHRT_MAX);
                    color.ct.argb.blue  = qRound(p * USHRT_MAX);
                    break;
                case 2:
                    color.ct.argb.red   = qRound(p * USHRT_MAX);
                    color.ct.argb.green = qRound(v * USHRT_MAX);
                    color.ct.argb.blue  = qRound(t * USHRT_MAX);
                    break;
                case 4:
                    color.ct.argb.red   = qRound(t * USHRT_MAX);
                    color.ct.argb.green = qRound(p * USHRT_MAX);
                    color.ct.argb.blue  = qRound(v * USHRT_MAX);
                    break;
                }
            }
            break;
        }
    case Hsl:
        {
            if (ct.ahsl.saturation == 0 || ct.ahsl.hue == USHRT_MAX) {
                // achromatic case
                color.ct.argb.red = color.ct.argb.green = color.ct.argb.blue = ct.ahsl.lightness;
            } else if (ct.ahsl.lightness == 0) {
                // lightness 0
                color.ct.argb.red = color.ct.argb.green = color.ct.argb.blue = 0;
            } else {
                // chromatic case
                const float h = ct.ahsl.hue == 36000 ? 0.0f : ct.ahsl.hue / 36000.0f;
                const float s = ct.ahsl.saturation / float(USHRT_MAX);
                const float l = ct.ahsl.lightness / float(USHRT_MAX);
 
                float temp2;
                if (l < 0.5f)
                    temp2 = l * (1.0f + s);
                else
                    temp2 = l + s - (l * s);
 
                const float temp1 = (2.0f * l) - temp2;
                float temp3[3] = { h + (1.0f / 3.0f),
                                   h,
                                   h - (1.0f / 3.0f) };
 
                for (int i = 0; i != 3; ++i) {
                    if (temp3[i] < 0.0f)
                        temp3[i] += 1.0f;
                    else if (temp3[i] > 1.0f)
                        temp3[i] -= 1.0f;
 
                    const float sixtemp3 = temp3[i] * 6.0f;
                    if (sixtemp3 < 1.0f)
                        color.ct.array[i+1] = qRound((temp1 + (temp2 - temp1) * sixtemp3) * USHRT_MAX);
                    else if ((temp3[i] * 2.0f) < 1.0f)
                        color.ct.array[i+1] = qRound(temp2 * USHRT_MAX);
                    else if ((temp3[i] * 3.0f) < 2.0f)
                        color.ct.array[i+1] = qRound((temp1 + (temp2 -temp1) * (2.0f /3.0f - temp3[i]) * 6.0f) * USHRT_MAX);
                    else
                        color.ct.array[i+1] = qRound(temp1 * USHRT_MAX);
                }
                color.ct.argb.red = color.ct.argb.red == 1 ? 0 : color.ct.argb.red;
                color.ct.argb.green = color.ct.argb.green == 1 ? 0 : color.ct.argb.green;
                color.ct.argb.blue = color.ct.argb.blue == 1 ? 0 : color.ct.argb.blue;
            }
            break;
        }
    case Cmyk:
        {
            const float c = ct.acmyk.cyan / float(USHRT_MAX);
            const float m = ct.acmyk.magenta / float(USHRT_MAX);
            const float y = ct.acmyk.yellow / float(USHRT_MAX);
            const float k = ct.acmyk.black / float(USHRT_MAX);
 
            color.ct.argb.red   = qRound((1.0f - (c * (1.0f - k) + k)) * USHRT_MAX);
            color.ct.argb.green = qRound((1.0f - (m * (1.0f - k) + k)) * USHRT_MAX);
            color.ct.argb.blue  = qRound((1.0f - (y * (1.0f - k) + k)) * USHRT_MAX);
            break;
        }
    case ExtendedRgb:
        color.ct.argb.alpha = qRound(USHRT_MAX * float(castF16(ct.argbExtended.alphaF16)));
        color.ct.argb.red   = qRound(USHRT_MAX * qBound(0.0f, float(castF16(ct.argbExtended.redF16)),   1.0f));
        color.ct.argb.green = qRound(USHRT_MAX * qBound(0.0f, float(castF16(ct.argbExtended.greenF16)), 1.0f));
        color.ct.argb.blue  = qRound(USHRT_MAX * qBound(0.0f, float(castF16(ct.argbExtended.blueF16)),  1.0f));
        break;
    default:
        break;
    }
 
    return color;
}
 
 
#define Q_MAX_3(a, b, c) ( ( a > b && a > c) ? a : (b > c ? b : c) )
#define Q_MIN_3(a, b, c) ( ( a < b && a < c) ? a : (b < c ? b : c) )
 
 
QColor QColor::toHsv() const noexcept
{
    if (!isValid() || cspec == Hsv)
        return *this;
 
    if (cspec != Rgb)
        return toRgb().toHsv();
 
    QColor color;
    color.cspec = Hsv;
    color.ct.ahsv.alpha = ct.argb.alpha;
    color.ct.ahsv.pad = 0;
 
    const float r = ct.argb.red   / float(USHRT_MAX);
    const float g = ct.argb.green / float(USHRT_MAX);
    const float b = ct.argb.blue  / float(USHRT_MAX);
    const float max = Q_MAX_3(r, g, b);
    const float min = Q_MIN_3(r, g, b);
    const float delta = max - min;
    color.ct.ahsv.value = qRound(max * USHRT_MAX);
    if (qFuzzyIsNull(delta)) {
        // achromatic case, hue is undefined
        color.ct.ahsv.hue = USHRT_MAX;
        color.ct.ahsv.saturation = 0;
    } else {
        // chromatic case
        float hue = 0;
        color.ct.ahsv.saturation = qRound((delta / max) * USHRT_MAX);
        if (qFuzzyCompare(r, max)) {
            hue = ((g - b) /delta);
        } else if (qFuzzyCompare(g, max)) {
            hue = (2.0f + (b - r) / delta);
        } else if (qFuzzyCompare(b, max)) {
            hue = (4.0f + (r - g) / delta);
        } else {
            Q_ASSERT_X(false, "QColor::toHsv", "internal error");
        }
        hue *= 60.0f;
        if (hue < 0.0f)
            hue += 360.0f;
        color.ct.ahsv.hue = qRound(hue * 100.0f);
    }
 
    return color;
}
 
QColor QColor::toHsl() const noexcept
{
    if (!isValid() || cspec == Hsl)
        return *this;
 
    if (cspec != Rgb)
        return toRgb().toHsl();
 
    QColor color;
    color.cspec = Hsl;
    color.ct.ahsl.alpha = ct.argb.alpha;
    color.ct.ahsl.pad = 0;
 
    const float r = ct.argb.red   / float(USHRT_MAX);
    const float g = ct.argb.green / float(USHRT_MAX);
    const float b = ct.argb.blue  / float(USHRT_MAX);
    const float max = Q_MAX_3(r, g, b);
    const float min = Q_MIN_3(r, g, b);
    const float delta = max - min;
    const float delta2 = max + min;
    const float lightness = 0.5f * delta2;
    color.ct.ahsl.lightness = qRound(lightness * USHRT_MAX);
    if (qFuzzyIsNull(delta)) {
        // achromatic case, hue is undefined
        color.ct.ahsl.hue = USHRT_MAX;
        color.ct.ahsl.saturation = 0;
    } else {
        // chromatic case
        float hue = 0;
        if (lightness < 0.5f)
            color.ct.ahsl.saturation = qRound((delta / delta2) * USHRT_MAX);
        else
            color.ct.ahsl.saturation = qRound((delta / (2.0f - delta2)) * USHRT_MAX);
        if (qFuzzyCompare(r, max)) {
            hue = ((g - b) /delta);
        } else if (qFuzzyCompare(g, max)) {
            hue = (2.0f + (b - r) / delta);
        } else if (qFuzzyCompare(b, max)) {
            hue = (4.0f + (r - g) / delta);
        } else {
            Q_ASSERT_X(false, "QColor::toHsv", "internal error");
        }
        hue *= 60.0f;
        if (hue < 0.0f)
            hue += 360.0f;
        color.ct.ahsl.hue = qRound(hue * 100.0f);
    }
 
    return color;
}
 
QColor QColor::toCmyk() const noexcept
{
    if (!isValid() || cspec == Cmyk)
        return *this;
    if (cspec != Rgb)
        return toRgb().toCmyk();
 
    QColor color;
    color.cspec = Cmyk;
    color.ct.acmyk.alpha = ct.argb.alpha;
 
    if (!ct.argb.red && !ct.argb.green && !ct.argb.blue) {
        // Avoid div-by-0 below
        color.ct.acmyk.cyan    = 0;
        color.ct.acmyk.magenta = 0;
        color.ct.acmyk.yellow  = 0;
        color.ct.acmyk.black   = USHRT_MAX;
    } else {
        // rgb -> cmy
        const float r = ct.argb.red   / float(USHRT_MAX);
        const float g = ct.argb.green / float(USHRT_MAX);
        const float b = ct.argb.blue  / float(USHRT_MAX);
        float c = 1.0f - r;
        float m = 1.0f - g;
        float y = 1.0f - b;
 
        // cmy -> cmyk
        const float k = qMin(c, qMin(m, y));
        c = (c - k) / (1.0f - k);
        m = (m - k) / (1.0f - k);
        y = (y - k) / (1.0f - k);
 
        color.ct.acmyk.cyan    = qRound(c * USHRT_MAX);
        color.ct.acmyk.magenta = qRound(m * USHRT_MAX);
        color.ct.acmyk.yellow  = qRound(y * USHRT_MAX);
        color.ct.acmyk.black   = qRound(k * USHRT_MAX);
    }
 
    return color;
}
 
QColor QColor::convertTo(QColor::Spec colorSpec) const noexcept
{
    if (colorSpec == cspec)
        return *this;
    switch (colorSpec) {
    case Rgb:
        return toRgb();
    case ExtendedRgb:
        return toExtendedRgb();
    case Hsv:
        return toHsv();
    case Cmyk:
        return toCmyk();
    case Hsl:
        return toHsl();
    case Invalid:
        break;
    }
    return QColor(); // must be invalid
}
 
 
QColor QColor::fromRgb(QRgb rgb) noexcept
{
    return fromRgb(qRed(rgb), qGreen(rgb), qBlue(rgb));
}
 
 
QColor QColor::fromRgba(QRgb rgba) noexcept
{
    return fromRgb(qRed(rgba), qGreen(rgba), qBlue(rgba), qAlpha(rgba));
}
 
QColor QColor::fromRgb(int r, int g, int b, int a)
{
    if (!isRgbaValid(r, g, b, a)) {
        qWarning("QColor::fromRgb: RGB parameters out of range");
        return QColor();
    }
 
    QColor color;
    color.cspec = Rgb;
    color.ct.argb.alpha = a * 0x101;
    color.ct.argb.red   = r * 0x101;
    color.ct.argb.green = g * 0x101;
    color.ct.argb.blue  = b * 0x101;
    color.ct.argb.pad   = 0;
    return color;
}
 
QColor QColor::fromRgbF(float r, float g, float b, float a)
{
    if (a < 0.0f || a > 1.0f) {
        qWarning("QColor::fromRgbF: Alpha parameter out of range");
        return QColor();
    }
 
    if (r < 0.0f || r > 1.0f
            || g < 0.0f || g > 1.0f
            || b < 0.0f || b > 1.0f) {
        QColor color;
        color.cspec = ExtendedRgb;
        castF16(color.ct.argbExtended.alphaF16) = qfloat16(a);
        castF16(color.ct.argbExtended.redF16)   = qfloat16(r);
        castF16(color.ct.argbExtended.greenF16) = qfloat16(g);
        castF16(color.ct.argbExtended.blueF16)  = qfloat16(b);
        color.ct.argbExtended.pad   = 0;
        return color;
    }
 
    QColor color;
    color.cspec = Rgb;
    color.ct.argb.alpha = qRound(a * USHRT_MAX);
    color.ct.argb.red   = qRound(r * USHRT_MAX);
    color.ct.argb.green = qRound(g * USHRT_MAX);
    color.ct.argb.blue  = qRound(b * USHRT_MAX);
    color.ct.argb.pad   = 0;
    return color;
}
 
 
QColor QColor::fromRgba64(ushort r, ushort g, ushort b, ushort a) noexcept
{
    QColor color;
    color.setRgba64(qRgba64(r, g, b, a));
    return color;
}
 
QColor QColor::fromRgba64(QRgba64 rgba64) noexcept
{
    QColor color;
    color.setRgba64(rgba64);
    return color;
}
 
QColor QColor::fromHsv(int h, int s, int v, int a)
{
    if (((h < 0 || h >= 360) && h != -1)
        || s < 0 || s > 255
        || v < 0 || v > 255
        || a < 0 || a > 255) {
        qWarning("QColor::fromHsv: HSV parameters out of range");
        return QColor();
    }
 
    QColor color;
    color.cspec = Hsv;
    color.ct.ahsv.alpha      = a * 0x101;
    color.ct.ahsv.hue        = h == -1 ? USHRT_MAX : (h % 360) * 100;
    color.ct.ahsv.saturation = s * 0x101;
    color.ct.ahsv.value      = v * 0x101;
    color.ct.ahsv.pad        = 0;
    return color;
}
 
QColor QColor::fromHsvF(float h, float s, float v, float a)
{
    if (((h < 0.0f || h > 1.0f) && h != -1.0f)
        || (s < 0.0f || s > 1.0f)
        || (v < 0.0f || v > 1.0f)
        || (a < 0.0f || a > 1.0f)) {
        qWarning("QColor::fromHsvF: HSV parameters out of range");
        return QColor();
    }
 
    QColor color;
    color.cspec = Hsv;
    color.ct.ahsv.alpha      = qRound(a * USHRT_MAX);
    color.ct.ahsv.hue        = h == -1.0f ? USHRT_MAX : qRound(h * 36000.0f);
    color.ct.ahsv.saturation = qRound(s * USHRT_MAX);
    color.ct.ahsv.value      = qRound(v * USHRT_MAX);
    color.ct.ahsv.pad        = 0;
    return color;
}
 
QColor QColor::fromHsl(int h, int s, int l, int a)
{
    if (((h < 0 || h >= 360) && h != -1)
        || s < 0 || s > 255
        || l < 0 || l > 255
        || a < 0 || a > 255) {
        qWarning("QColor::fromHsl: HSL parameters out of range");
        return QColor();
    }
 
    QColor color;
    color.cspec = Hsl;
    color.ct.ahsl.alpha      = a * 0x101;
    color.ct.ahsl.hue        = h == -1 ? USHRT_MAX : (h % 360) * 100;
    color.ct.ahsl.saturation = s * 0x101;
    color.ct.ahsl.lightness  = l * 0x101;
    color.ct.ahsl.pad        = 0;
    return color;
}
 
QColor QColor::fromHslF(float h, float s, float l, float a)
{
    if (((h < 0.0f || h > 1.0f) && h != -1.0f)
        || (s < 0.0f || s > 1.0f)
        || (l < 0.0f || l > 1.0f)
        || (a < 0.0f || a > 1.0f)) {
        qWarning("QColor::fromHslF: HSL parameters out of range");
        return QColor();
    }
 
    QColor color;
    color.cspec = Hsl;
    color.ct.ahsl.alpha      = qRound(a * USHRT_MAX);
    color.ct.ahsl.hue        = (h == -1.0f) ? USHRT_MAX : qRound(h * 36000.0f);
    if (color.ct.ahsl.hue == 36000)
        color.ct.ahsl.hue = 0;
    color.ct.ahsl.saturation = qRound(s * USHRT_MAX);
    color.ct.ahsl.lightness  = qRound(l * USHRT_MAX);
    color.ct.ahsl.pad        = 0;
    return color;
}
 
void QColor::getCmyk(int *c, int *m, int *y, int *k, int *a) const
{
    if (!c || !m || !y || !k)
        return;
 
    if (cspec != Invalid && cspec != Cmyk) {
        toCmyk().getCmyk(c, m, y, k, a);
        return;
    }
 
    *c = qt_div_257(ct.acmyk.cyan);
    *m = qt_div_257(ct.acmyk.magenta);
    *y = qt_div_257(ct.acmyk.yellow);
    *k = qt_div_257(ct.acmyk.black);
 
    if (a)
        *a = qt_div_257(ct.acmyk.alpha);
}
 
void QColor::getCmykF(float *c, float *m, float *y, float *k, float *a) const
{
    if (!c || !m || !y || !k)
        return;
 
    if (cspec != Invalid && cspec != Cmyk) {
        toCmyk().getCmykF(c, m, y, k, a);
        return;
    }
 
    *c = ct.acmyk.cyan    / float(USHRT_MAX);
    *m = ct.acmyk.magenta / float(USHRT_MAX);
    *y = ct.acmyk.yellow  / float(USHRT_MAX);
    *k = ct.acmyk.black   / float(USHRT_MAX);
 
    if (a)
        *a = ct.acmyk.alpha / float(USHRT_MAX);
}
 
void QColor::setCmyk(int c, int m, int y, int k, int a)
{
    if (c < 0 || c > 255
        || m < 0 || m > 255
        || y < 0 || y > 255
        || k < 0 || k > 255
        || a < 0 || a > 255) {
        qWarning("QColor::setCmyk: CMYK parameters out of range");
        invalidate();
        return;
    }
 
    cspec = Cmyk;
    ct.acmyk.alpha   = a * 0x101;
    ct.acmyk.cyan    = c * 0x101;
    ct.acmyk.magenta = m * 0x101;
    ct.acmyk.yellow  = y * 0x101;
    ct.acmyk.black   = k * 0x101;
}
 
void QColor::setCmykF(float c, float m, float y, float k, float a)
{
    if (c < 0.0f || c > 1.0f
        || m < 0.0f || m > 1.0f
        || y < 0.0f || y > 1.0f
        || k < 0.0f || k > 1.0f
        || a < 0.0f || a > 1.0f) {
        qWarning("QColor::setCmykF: CMYK parameters out of range");
        invalidate();
        return;
    }
 
    cspec = Cmyk;
    ct.acmyk.alpha   = qRound(a * USHRT_MAX);
    ct.acmyk.cyan    = qRound(c * USHRT_MAX);
    ct.acmyk.magenta = qRound(m * USHRT_MAX);
    ct.acmyk.yellow  = qRound(y * USHRT_MAX);
    ct.acmyk.black   = qRound(k * USHRT_MAX);
}
 
QColor QColor::fromCmyk(int c, int m, int y, int k, int a)
{
    if (c < 0 || c > 255
        || m < 0 || m > 255
        || y < 0 || y > 255
        || k < 0 || k > 255
        || a < 0 || a > 255) {
        qWarning("QColor::fromCmyk: CMYK parameters out of range");
        return QColor();
    }
 
    QColor color;
    color.cspec = Cmyk;
    color.ct.acmyk.alpha   = a * 0x101;
    color.ct.acmyk.cyan    = c * 0x101;
    color.ct.acmyk.magenta = m * 0x101;
    color.ct.acmyk.yellow  = y * 0x101;
    color.ct.acmyk.black   = k * 0x101;
    return color;
}
 
QColor QColor::fromCmykF(float c, float m, float y, float k, float a)
{
    if (c < 0.0f || c > 1.0f
        || m < 0.0f || m > 1.0f
        || y < 0.0f || y > 1.0f
        || k < 0.0f || k > 1.0f
        || a < 0.0f || a > 1.0f) {
        qWarning("QColor::fromCmykF: CMYK parameters out of range");
        return QColor();
    }
 
    QColor color;
    color.cspec = Cmyk;
    color.ct.acmyk.alpha   = qRound(a * USHRT_MAX);
    color.ct.acmyk.cyan    = qRound(c * USHRT_MAX);
    color.ct.acmyk.magenta = qRound(m * USHRT_MAX);
    color.ct.acmyk.yellow  = qRound(y * USHRT_MAX);
    color.ct.acmyk.black   = qRound(k * USHRT_MAX);
    return color;
}
 
QColor QColor::lighter(int factor) const noexcept
{
    if (factor <= 0)                                // invalid lightness factor
        return *this;
    else if (factor < 100)                        // makes color darker
        return darker(10000 / factor);
 
    QColor hsv = toHsv();
    int s = hsv.ct.ahsv.saturation;
    uint v = hsv.ct.ahsv.value;
 
    v = (factor*v)/100;
    if (v > USHRT_MAX) {
        // overflow... adjust saturation
        s -= v - USHRT_MAX;
        if (s < 0)
            s = 0;
        v = USHRT_MAX;
    }
 
    hsv.ct.ahsv.saturation = s;
    hsv.ct.ahsv.value = v;
 
    // convert back to same color spec as original color
    return hsv.convertTo(cspec);
}
 
QColor QColor::darker(int factor) const noexcept
{
    if (factor <= 0)                                // invalid darkness factor
        return *this;
    else if (factor < 100)                        // makes color lighter
        return lighter(10000 / factor);
 
    QColor hsv = toHsv();
    hsv.ct.ahsv.value = (hsv.ct.ahsv.value * 100) / factor;
 
    // convert back to same color spec as original color
    return hsv.convertTo(cspec);
}
 
QColor &QColor::operator=(Qt::GlobalColor color) noexcept
{
    return operator=(QColor(color));
}
 
bool QColor::operator==(const QColor &color) const noexcept
{
    if ((cspec == ExtendedRgb || color.cspec == ExtendedRgb) &&
               (cspec == color.cspec || cspec == Rgb || color.cspec == Rgb))  {
        return qFuzzyCompare(alphaF(), color.alphaF())
            && qFuzzyCompare(redF(), color.redF())
            && qFuzzyCompare(greenF(), color.greenF())
            && qFuzzyCompare(blueF(), color.blueF());
    } else {
        return (cspec == color.cspec
                && ct.argb.alpha == color.ct.argb.alpha
                && (((cspec == QColor::Hsv || cspec == QColor::Hsl)
                     && ((ct.ahsv.hue % 36000) == (color.ct.ahsv.hue % 36000)))
                    || (ct.argb.red == color.ct.argb.red))
                && ct.argb.green == color.ct.argb.green
                && ct.argb.blue  == color.ct.argb.blue
                && ct.argb.pad   == color.ct.argb.pad);
    }
}
 
bool QColor::operator!=(const QColor &color) const noexcept
{ return !operator==(color); }
 
 
QColor::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
 
void QColor::invalidate() noexcept
{
    cspec = Invalid;
    ct.argb.alpha = USHRT_MAX;
    ct.argb.red = 0;
    ct.argb.green = 0;
    ct.argb.blue = 0;
    ct.argb.pad = 0;
}
 
/*****************************************************************************
  QColor stream functions
 *****************************************************************************/
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QColor &c)
{
    QDebugStateSaver saver(dbg);
    if (!c.isValid())
        dbg.nospace() << "QColor(Invalid)";
    else if (c.spec() == QColor::Rgb)
        dbg.nospace() << "QColor(ARGB " << c.alphaF() << ", " << c.redF() << ", " << c.greenF() << ", " << c.blueF() << ')';
    else if (c.spec() == QColor::ExtendedRgb)
        dbg.nospace() << "QColor(Ext. ARGB " << c.alphaF() << ", " << c.redF() << ", " << c.greenF() << ", " << c.blueF() << ')';
    else if (c.spec() == QColor::Hsv)
        dbg.nospace() << "QColor(AHSV " << c.alphaF() << ", " << c.hueF() << ", " << c.saturationF() << ", " << c.valueF() << ')';
    else if (c.spec() == QColor::Cmyk)
        dbg.nospace() << "QColor(ACMYK " << c.alphaF() << ", " << c.cyanF() << ", " << c.magentaF() << ", " << c.yellowF() << ", "
                      << c.blackF()<< ')';
    else if (c.spec() == QColor::Hsl)
        dbg.nospace() << "QColor(AHSL " << c.alphaF() << ", " << c.hslHueF() << ", " << c.hslSaturationF() << ", " << c.lightnessF() << ')';
 
    return dbg;
}
#endif
 
#ifndef QT_NO_DATASTREAM
QDataStream &operator<<(QDataStream &stream, const QColor &color)
{
    if (stream.version() < 7) {
        if (!color.isValid())
            return stream << quint32(0x49000000);
        quint32 p = (quint32)color.rgb();
        if (stream.version() == 1) // Swap red and blue
            p = ((p << 16) & 0xff0000) | ((p >> 16) & 0xff) | (p & 0xff00ff00);
        return stream << p;
    }
 
    qint8   s = color.cspec;
    quint16 a = color.ct.argb.alpha;
    quint16 r = color.ct.argb.red;
    quint16 g = color.ct.argb.green;
    quint16 b = color.ct.argb.blue;
    quint16 p = color.ct.argb.pad;
 
    stream << s;
    stream << a;
    stream << r;
    stream << g;
    stream << b;
    stream << p;
 
    return stream;
}
 
QDataStream &operator>>(QDataStream &stream, QColor &color)
{
    if (stream.version() < 7) {
        quint32 p;
        stream >> p;
        if (p == 0x49000000) {
            color.invalidate();
            return stream;
        }
        if (stream.version() == 1) // Swap red and blue
            p = ((p << 16) & 0xff0000) | ((p >> 16) & 0xff) | (p & 0xff00ff00);
        color.setRgb(p);
        return stream;
    }
 
    qint8 s;
    quint16 a, r, g, b, p;
    stream >> s;
    stream >> a;
    stream >> r;
    stream >> g;
    stream >> b;
    stream >> p;
 
    color.cspec = QColor::Spec(s);
    color.ct.argb.alpha = a;
    color.ct.argb.red   = r;
    color.ct.argb.green = g;
    color.ct.argb.blue  = b;
    color.ct.argb.pad   = p;
 
    return stream;
}
#endif // QT_NO_DATASTREAM
 
// A table of precalculated results of 0x00ff00ff/alpha use by qUnpremultiply:
const uint qt_inv_premul_factor[256] = {
    0, 16711935, 8355967, 5570645, 4177983, 3342387, 2785322, 2387419,
    2088991, 1856881, 1671193, 1519266, 1392661, 1285533, 1193709, 1114129,
    1044495, 983055, 928440, 879575, 835596, 795806, 759633, 726605,
    696330, 668477, 642766, 618960, 596854, 576273, 557064, 539094,
    522247, 506422, 491527, 477483, 464220, 451673, 439787, 428511,
    417798, 407608, 397903, 388649, 379816, 371376, 363302, 355573,
    348165, 341059, 334238, 327685, 321383, 315319, 309480, 303853,
    298427, 293191, 288136, 283253, 278532, 273966, 269547, 265268,
    261123, 257106, 253211, 249431, 245763, 242201, 238741, 235379,
    232110, 228930, 225836, 222825, 219893, 217038, 214255, 211543,
    208899, 206320, 203804, 201348, 198951, 196611, 194324, 192091,
    189908, 187774, 185688, 183647, 181651, 179698, 177786, 175915,
    174082, 172287, 170529, 168807, 167119, 165464, 163842, 162251,
    160691, 159161, 157659, 156186, 154740, 153320, 151926, 150557,
    149213, 147893, 146595, 145321, 144068, 142837, 141626, 140436,
    139266, 138115, 136983, 135869, 134773, 133695, 132634, 131590,
    130561, 129549, 128553, 127572, 126605, 125653, 124715, 123792,
    122881, 121984, 121100, 120229, 119370, 118524, 117689, 116866,
    116055, 115254, 114465, 113686, 112918, 112160, 111412, 110675,
    109946, 109228, 108519, 107818, 107127, 106445, 105771, 105106,
    104449, 103800, 103160, 102527, 101902, 101284, 100674, 100071,
    99475, 98887, 98305, 97730, 97162, 96600, 96045, 95496,
    94954, 94417, 93887, 93362, 92844, 92331, 91823, 91322,
    90825, 90334, 89849, 89368, 88893, 88422, 87957, 87497,
    87041, 86590, 86143, 85702, 85264, 84832, 84403, 83979,
    83559, 83143, 82732, 82324, 81921, 81521, 81125, 80733,
    80345, 79961, 79580, 79203, 78829, 78459, 78093, 77729,
    77370, 77013, 76660, 76310, 75963, 75619, 75278, 74941,
    74606, 74275, 73946, 73620, 73297, 72977, 72660, 72346,
    72034, 71725, 71418, 71114, 70813, 70514, 70218, 69924,
    69633, 69344, 69057, 68773, 68491, 68211, 67934, 67659,
    67386, 67116, 66847, 66581, 66317, 66055, 65795, 65537
};
 
/*****************************************************************************
  QColor global functions (documentation only)
 *****************************************************************************/
 
QT_END_NAMESPACE