qpalette.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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 "qpalette.h"
#include "qguiapplication.h"
#include "qguiapplication_p.h"
#include "qdatastream.h"
#include "qvariant.h"
#include "qdebug.h"
 
#include <QtCore/qmetaobject.h>
 
QT_BEGIN_NAMESPACE
 
static int qt_palette_count = 1;
 
static constexpr QPalette::ResolveMask colorRoleOffset(QPalette::ColorGroup colorGroup)
{
    // Exclude NoRole; that bit is used for AccentColor
    return (qToUnderlying(QPalette::NColorRoles) - 1) * qToUnderlying(colorGroup);
}
 
static constexpr QPalette::ResolveMask bitPosition(QPalette::ColorGroup colorGroup,
                                                   QPalette::ColorRole colorRole)
{
    // Map AccentColor into NoRole for resolving purposes
    if (colorRole == QPalette::AccentColor)
        colorRole = QPalette::NoRole;
 
    return colorRole + colorRoleOffset(colorGroup);
}
 
static_assert(bitPosition(QPalette::ColorGroup(QPalette::NColorGroups - 1),
                              QPalette::ColorRole(QPalette::NColorRoles - 1))
                  < sizeof(QPalette::ResolveMask) * CHAR_BIT,
                  "The resolve mask type is not wide enough to fit the entire bit mask.");
 
class QPalettePrivate
{
public:
    class Data : public QSharedData {
    public:
        // Every instance of Data has to have a unique serial number, even
        // if it gets created by copying another - we wouldn't create a copy
        // in the first place if the serial number should be the same!
        Data(const Data &other)
            : QSharedData(other)
        {
            for (int grp = 0; grp < int(QPalette::NColorGroups); grp++) {
                for (int role = 0; role < int(QPalette::NColorRoles); role++)
                    br[grp][role] = other.br[grp][role];
            }
        }
        Data() = default;
 
        QBrush br[QPalette::NColorGroups][QPalette::NColorRoles];
        const int ser_no = qt_palette_count++;
    };
 
    QPalettePrivate(const QExplicitlySharedDataPointer<Data> &data)
        : ref(1), data(data)
    { }
    QPalettePrivate()
        : QPalettePrivate(QExplicitlySharedDataPointer<Data>(new Data))
    { }
 
    QAtomicInt ref;
    QPalette::ResolveMask resolveMask = {0};
    static inline int qt_palette_private_count = 0;
    int detach_no = ++qt_palette_private_count;
    QExplicitlySharedDataPointer<Data> data;
};
 
static QColor qt_mix_colors(QColor a, QColor b)
{
    return QColor((a.red() + b.red()) / 2, (a.green() + b.green()) / 2,
                  (a.blue() + b.blue()) / 2, (a.alpha() + b.alpha()) / 2);
}
 
static void qt_placeholder_from_text(QPalette &pal, int alpha = 50)
{
    if (alpha < 0 or alpha > 100)
        return;
 
    for (int cg = 0; cg < int(QPalette::NColorGroups); ++cg) {
        const QPalette::ColorGroup group = QPalette::ColorGroup(cg);
 
        // skip if the brush has been set already
        if (!pal.isBrushSet(group, QPalette::PlaceholderText)) {
            QColor c = pal.color(group, QPalette::Text);
            const int a = (c.alpha() * alpha) / 100;
            c.setAlpha(a);
            pal.setColor(group, QPalette::PlaceholderText, c);
        }
    }
}
 
static void qt_ensure_default_accent_color(QPalette &pal)
{
    // have a lighter/darker factor handy, depending on dark/light heuristics
    const int lighter = pal.base().color().lightness() > pal.text().color().lightness() ? 130 : 70;
 
    // Act only for color groups where no accent color is set
    for (int i = 0; i < QPalette::NColorGroups; ++i) {
        const QPalette::ColorGroup group = static_cast<QPalette::ColorGroup>(i);
        if (!pal.isBrushSet(group, QPalette::AccentColor)) {
            // Default to highlight if available, otherwise use a shade of base
            const QBrush accentBrush = pal.isBrushSet(group, QPalette::Highlight)
                                     ? pal.brush(group, QPalette::Highlight)
                                     : pal.brush(group, QPalette::Base).color().lighter(lighter);
            pal.setBrush(group, QPalette::AccentColor, accentBrush);
        }
    }
}
 
static void qt_palette_from_color(QPalette &pal, const QColor &button)
{
    int h, s, v;
    button.getHsv(&h, &s, &v);
    // inactive and active are the same..
    const QBrush whiteBrush = QBrush(Qt::white);
    const QBrush blackBrush = QBrush(Qt::black);
    const QBrush baseBrush = v > 128 ? whiteBrush : blackBrush;
    const QBrush foregroundBrush = v > 128 ? blackBrush : whiteBrush;
    const QBrush buttonBrush = QBrush(button);
    const QBrush buttonBrushDark = QBrush(button.darker());
    const QBrush buttonBrushDark150 = QBrush(button.darker(150));
    const QBrush buttonBrushLight150 = QBrush(button.lighter(150));
    pal.setColorGroup(QPalette::Active, foregroundBrush, buttonBrush, buttonBrushLight150,
                      buttonBrushDark, buttonBrushDark150, foregroundBrush, whiteBrush,
                      baseBrush, buttonBrush);
    pal.setColorGroup(QPalette::Inactive, foregroundBrush, buttonBrush, buttonBrushLight150,
                      buttonBrushDark, buttonBrushDark150, foregroundBrush, whiteBrush,
                      baseBrush, buttonBrush);
    pal.setColorGroup(QPalette::Disabled, buttonBrushDark, buttonBrush, buttonBrushLight150,
                      buttonBrushDark, buttonBrushDark150, buttonBrushDark,
                      whiteBrush, buttonBrush, buttonBrush);
 
    qt_placeholder_from_text(pal);
    qt_ensure_default_accent_color(pal);
}
 
QPalette::QPalette()
    : d(nullptr)
{
    // Initialize to application palette if present, else default to black.
    // This makes it possible to instantiate QPalette outside QGuiApplication,
    // for example in the platform plugins.
    if (QGuiApplicationPrivate::app_pal) {
        d = QGuiApplicationPrivate::app_pal->d;
        d->ref.ref();
        setResolveMask(0);
    } else {
        init();
        qt_palette_from_color(*this, Qt::black);
        d->resolveMask = 0;
    }
}
 
QPalette::QPalette(const QColor &button)
{
    init();
    qt_palette_from_color(*this, button);
}
 
QPalette::QPalette(Qt::GlobalColor button)
{
    init();
    qt_palette_from_color(*this, button);
}
 
QPalette::QPalette(const QBrush &windowText, const QBrush &button,
                   const QBrush &light, const QBrush &dark,
                   const QBrush &mid, const QBrush &text,
                   const QBrush &bright_text, const QBrush &base,
                   const QBrush &window)
{
    init();
    setColorGroup(All, windowText, button, light, dark, mid, text, bright_text,
                  base, window);
 
    qt_placeholder_from_text(*this);
    qt_ensure_default_accent_color(*this);
}
 
 
QPalette::QPalette(const QColor &windowText, const QColor &window,
                   const QColor &light, const QColor &dark, const QColor &mid,
                   const QColor &text, const QColor &base)
{
    init();
    const QBrush windowBrush(window);
    const QBrush lightBrush(light);
    setColorGroup(All, QBrush(windowText), windowBrush, lightBrush,
                  QBrush(dark), QBrush(mid), QBrush(text), lightBrush,
                  QBrush(base), windowBrush);
}
 
QPalette::QPalette(const QColor &button, const QColor &window)
{
    init();
    int h, s, v;
    window.getHsv(&h, &s, &v);
 
    const QBrush windowBrush = QBrush(window);
    const QBrush whiteBrush = QBrush(Qt::white);
    const QBrush blackBrush = QBrush(Qt::black);
    const QBrush baseBrush = v > 128 ? whiteBrush : blackBrush;
    const QBrush foregroundBrush = v > 128 ? blackBrush : whiteBrush;
    const QBrush disabledForeground = QBrush(Qt::darkGray);
 
    const QBrush buttonBrush = QBrush(button);
    const QBrush buttonBrushDark = QBrush(button.darker());
    const QBrush buttonBrushDark150 = QBrush(button.darker(150));
    const QBrush buttonBrushLight150 = QBrush(button.lighter(150));
 
    //inactive and active are identical
    setColorGroup(Inactive, foregroundBrush, buttonBrush, buttonBrushLight150, buttonBrushDark,
                  buttonBrushDark150, foregroundBrush, whiteBrush, baseBrush,
                  windowBrush);
    setColorGroup(Active, foregroundBrush, buttonBrush, buttonBrushLight150, buttonBrushDark,
                  buttonBrushDark150, foregroundBrush, whiteBrush, baseBrush,
                  windowBrush);
    setColorGroup(Disabled, disabledForeground, buttonBrush, buttonBrushLight150,
                  buttonBrushDark, buttonBrushDark150, disabledForeground,
                  whiteBrush, baseBrush, windowBrush);
 
    qt_placeholder_from_text(*this);
    qt_ensure_default_accent_color(*this);
}
 
QPalette::QPalette(const QPalette &p)
    : d(p.d), currentGroup(p.currentGroup)
{
    d->ref.ref();
}
 
QPalette::~QPalette()
{
    if (d && !d->ref.deref())
        delete d;
}
 
void QPalette::init()
{
    d = new QPalettePrivate;
}
 
QPalette &QPalette::operator=(const QPalette &p)
{
    p.d->ref.ref();
    currentGroup = p.currentGroup;
    if (d && !d->ref.deref())
        delete d;
    d = p.d;
    return *this;
}
 
QPalette::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
 
const QBrush &QPalette::brush(ColorGroup gr, ColorRole cr) const
{
    Q_ASSERT(cr < NColorRoles);
    if (gr >= (int)NColorGroups) {
        if (gr == Current) {
            gr = currentGroup;
        } else {
            qWarning("QPalette::brush: Unknown ColorGroup: %d", (int)gr);
            gr = Active;
        }
    }
    return d->data->br[gr][cr];
}
 
void QPalette::setBrush(ColorGroup cg, ColorRole cr, const QBrush &b)
{
    Q_ASSERT(cr < NColorRoles);
 
    if (cg == All) {
        for (uint i = 0; i < NColorGroups; i++)
            setBrush(ColorGroup(i), cr, b);
        return;
    }
 
    if (cg == Current) {
        cg = currentGroup;
    } else if (cg >= NColorGroups) {
        qWarning("QPalette::setBrush: Unknown ColorGroup: %d", cg);
        cg = Active;
    }
 
    const auto newResolveMask = d->resolveMask | ResolveMask(1) << bitPosition(cg, cr);
    const auto valueChanged = d->data->br[cg][cr] != b;
 
    if (valueChanged) {
        detach();
        d->data.detach();
        d->data->br[cg][cr] = b;
    } else if (d->resolveMask != newResolveMask) {
        detach();
    }
 
    d->resolveMask = newResolveMask;
}
 
bool QPalette::isBrushSet(ColorGroup cg, ColorRole cr) const
{
    // NoRole has no resolve mask and should never be set anyway
    if (cr == NoRole)
        return false;
 
    if (cg == Current)
        cg = currentGroup;
 
    if (cg >= NColorGroups) {
        qWarning() << "Wrong color group:" << cg;
        return false;
    }
 
    if (cr >= NColorRoles) {
        qWarning() << "Wrong color role:" << cr;
        return false;
    }
 
    return d->resolveMask & (ResolveMask(1) << bitPosition(cg, cr));
}
 
void QPalette::detach()
{
    if (d->ref.loadRelaxed() != 1) {
        QPalettePrivate *x = new QPalettePrivate(d->data);
        x->resolveMask = d->resolveMask;
        if (!d->ref.deref())
            delete d;
        d = x;
    } else {
        d->detach_no = ++QPalettePrivate::qt_palette_private_count;
    }
}
 
bool QPalette::operator==(const QPalette &p) const
{
    if (isCopyOf(p) || d->data == p.d->data)
        return true;
    for(int grp = 0; grp < (int)NColorGroups; grp++) {
        for(int role = 0; role < (int)NColorRoles; role++) {
            // Dont't verify NoRole, because it has no resolve bit
            if (role == NoRole)
                continue;
            if (d->data->br[grp][role] != p.d->data->br[grp][role])
                return false;
        }
    }
    return true;
}
 
bool QPalette::isEqual(QPalette::ColorGroup group1, QPalette::ColorGroup group2) const
{
    if (group1 >= (int)NColorGroups) {
        if (group1 == Current) {
            group1 = currentGroup;
        } else {
            qWarning("QPalette::brush: Unknown ColorGroup(1): %d", (int)group1);
            group1 = Active;
        }
    }
    if (group2 >= (int)NColorGroups) {
        if (group2 == Current) {
            group2 = currentGroup;
        } else {
            qWarning("QPalette::brush: Unknown ColorGroup(2): %d", (int)group2);
            group2 = Active;
        }
    }
    if (group1 == group2)
        return true;
    for(int role = 0; role < (int)NColorRoles; role++) {
        if (d->data->br[group1][role] != d->data->br[group2][role])
                return false;
    }
    return true;
}
 
qint64 QPalette::cacheKey() const
{
    return (((qint64) d->data->ser_no) << 32) | ((qint64) (d->detach_no));
}
 
static constexpr QPalette::ResolveMask allResolveMask()
{
    QPalette::ResolveMask mask = {0};
    for (int role = 0; role < int(QPalette::NColorRoles); ++role) {
        for (int grp = 0; grp < int(QPalette::NColorGroups); ++grp) {
            mask |= (QPalette::ResolveMask(1) << bitPosition(QPalette::ColorGroup(grp), QPalette::ColorRole(role)));
        }
    }
    return mask;
}
 
QPalette QPalette::resolve(const QPalette &other) const
{
    if ((*this == other && d->resolveMask == other.d->resolveMask)
        || d->resolveMask == 0) {
        QPalette o = other;
        o.setResolveMask(d->resolveMask);
        return o;
    }
 
    if (d->resolveMask == allResolveMask())
        return *this;
 
    QPalette palette(*this);
    palette.detach();
 
    for (int role = 0; role < int(NColorRoles); ++role) {
        // Don't resolve NoRole, its bits are needed for AccentColor (see bitPosition)
        if (role == NoRole)
            continue;
 
        for (int grp = 0; grp < int(NColorGroups); ++grp) {
            if (!(d->resolveMask & (ResolveMask(1) << bitPosition(ColorGroup(grp), ColorRole(role))))) {
                palette.d->data.detach();
                palette.d->data->br[grp][role] = other.d->data->br[grp][role];
            }
        }
    }
 
    palette.d->resolveMask |= other.d->resolveMask;
 
    return palette;
}
 
QPalette::ResolveMask QPalette::resolveMask() const
{
    return d->resolveMask;
}
 
void QPalette::setResolveMask(QPalette::ResolveMask mask)
{
    if (mask == d->resolveMask)
        return;
 
    detach();
    d->resolveMask = mask;
}
 
/*****************************************************************************
  QPalette stream functions
 *****************************************************************************/
 
#ifndef QT_NO_DATASTREAM
 
static const int NumOldRoles = 7;
static const int oldRoles[7] = { QPalette::WindowText, QPalette::Window, QPalette::Light,
                                 QPalette::Dark, QPalette::Mid, QPalette::Text, QPalette::Base };
 
QDataStream &operator<<(QDataStream &s, const QPalette &p)
{
    for (int grp = 0; grp < (int)QPalette::NColorGroups; grp++) {
        if (s.version() == 1) {
            // Qt 1.x
            for (int i = 0; i < NumOldRoles; ++i)
                s << p.d->data->br[grp][oldRoles[i]].color();
        } else {
            int max = (int)QPalette::NColorRoles;
            if (s.version() <= QDataStream::Qt_2_1)
                max = QPalette::HighlightedText + 1;
            else if (s.version() <= QDataStream::Qt_4_3)
                max = QPalette::AlternateBase + 1;
            else if (s.version() <= QDataStream::Qt_5_11)
                max = QPalette::ToolTipText + 1;
            else if (s.version() <= QDataStream::Qt_6_5)
                max = QPalette::PlaceholderText + 1;
 
            for (int r = 0; r < max; r++)
                s << p.d->data->br[grp][r];
        }
    }
    return s;
}
 
static void readV1ColorGroup(QDataStream &s, QPalette &pal, QPalette::ColorGroup grp)
{
    for (int i = 0; i < NumOldRoles; ++i) {
        QColor col;
        s >> col;
        pal.setColor(grp, (QPalette::ColorRole)oldRoles[i], col);
    }
}
 
QDataStream &operator>>(QDataStream &s, QPalette &p)
{
    if (s.version() == 1) {
        p = QPalette();
        readV1ColorGroup(s, p, QPalette::Active);
        readV1ColorGroup(s, p, QPalette::Disabled);
        readV1ColorGroup(s, p, QPalette::Inactive);
    } else {
        int max = QPalette::NColorRoles;
        if (s.version() <= QDataStream::Qt_2_1) {
            p = QPalette();
            max = QPalette::HighlightedText + 1;
        } else if (s.version() <= QDataStream::Qt_4_3) {
            p = QPalette();
            max = QPalette::AlternateBase + 1;
        } else if (s.version() <= QDataStream::Qt_5_11) {
            p = QPalette();
            max = QPalette::ToolTipText + 1;
        } else if (s.version() <= QDataStream::Qt_6_5) {
            p = QPalette();
            max = QPalette::PlaceholderText + 1;
        }
 
 
        QBrush tmp;
        for(int grp = 0; grp < (int)QPalette::NColorGroups; ++grp) {
            const QPalette::ColorGroup group = static_cast<QPalette::ColorGroup>(grp);
            for(int role = 0; role < max; ++role) {
                s >> tmp;
                p.setBrush(group, (QPalette::ColorRole)role, tmp);
            }
 
            // AccentColor defaults to Highlight for stream versions that don't have it.
            if (s.version() < QDataStream::Qt_6_6)
                p.setBrush(group, QPalette::AccentColor, p.brush(group, QPalette::Highlight));
        }
 
    }
    return s;
}
#endif //QT_NO_DATASTREAM
 
bool QPalette::isCopyOf(const QPalette &p) const
{
    return d == p.d;
}
 
void QPalette::setColorGroup(ColorGroup cg, const QBrush &windowText, const QBrush &button,
                             const QBrush &light, const QBrush &dark, const QBrush &mid,
                             const QBrush &text, const QBrush &bright_text, const QBrush &base,
                             const QBrush &window)
{
    QBrush alt_base = QBrush(qt_mix_colors(base.color(), button.color()));
    QBrush mid_light = QBrush(qt_mix_colors(button.color(), light.color()));
    QColor toolTipBase(255, 255, 220);
    QColor toolTipText(0, 0, 0);
 
    setColorGroup(cg, windowText, button, light, dark, mid, text, bright_text, base,
                  alt_base, window, mid_light, text,
                  QBrush(Qt::black), QBrush(Qt::darkBlue), QBrush(Qt::white),
                  QBrush(Qt::blue), QBrush(Qt::magenta), QBrush(toolTipBase),
                  QBrush(toolTipText));
 
    for (int cr = Highlight; cr <= LinkVisited; ++cr) {
        if (cg == All) {
            for (int group = Active; group < NColorGroups; ++group) {
                d->resolveMask &= ~(ResolveMask(1) << bitPosition(ColorGroup(group), ColorRole(cr)));
            }
        } else {
            d->resolveMask &= ~(ResolveMask(1) << bitPosition(ColorGroup(cg), ColorRole(cr)));
        }
    }
}
 
 
void
QPalette::setColorGroup(ColorGroup cg, const QBrush &foreground, const QBrush &button,
                        const QBrush &light, const QBrush &dark, const QBrush &mid,
                        const QBrush &text, const QBrush &bright_text,
                        const QBrush &base, const QBrush &alternate_base,
                        const QBrush &background, const QBrush &midlight,
                        const QBrush &button_text, const QBrush &shadow,
                        const QBrush &highlight, const QBrush &highlighted_text,
                        const QBrush &link, const QBrush &link_visited)
{
    setColorGroup(cg, foreground, button, light, dark, mid,
                  text, bright_text, base, alternate_base, background,
                  midlight, button_text, shadow, highlight, highlighted_text,
                  link, link_visited, background, foreground);
}
 
void QPalette::setColorGroup(ColorGroup cg, const QBrush &foreground, const QBrush &button,
                             const QBrush &light, const QBrush &dark, const QBrush &mid,
                             const QBrush &text, const QBrush &bright_text,
                             const QBrush &base, const QBrush &alternate_base,
                             const QBrush &background, const QBrush &midlight,
                             const QBrush &button_text, const QBrush &shadow,
                             const QBrush &highlight, const QBrush &highlighted_text,
                             const QBrush &link, const QBrush &link_visited,
                             const QBrush &toolTipBase, const QBrush &toolTipText)
{
    setBrush(cg, WindowText, foreground);
    setBrush(cg, Button, button);
    setBrush(cg, Light, light);
    setBrush(cg, Dark, dark);
    setBrush(cg, Mid, mid);
    setBrush(cg, Text, text);
    setBrush(cg, BrightText, bright_text);
    setBrush(cg, Base, base);
    setBrush(cg, AlternateBase, alternate_base);
    setBrush(cg, Window, background);
    setBrush(cg, Midlight, midlight);
    setBrush(cg, ButtonText, button_text);
    setBrush(cg, Shadow, shadow);
    setBrush(cg, Highlight, highlight);
    setBrush(cg, HighlightedText, highlighted_text);
    setBrush(cg, Link, link);
    setBrush(cg, LinkVisited, link_visited);
    setBrush(cg, ToolTipBase, toolTipBase);
    setBrush(cg, ToolTipText, toolTipText);
}
 
#ifndef QT_NO_DEBUG_STREAM
static QString groupsToString(const QPalette &p, QPalette::ColorRole cr)
{
    const auto groupEnum = QMetaEnum::fromType<QPalette::ColorGroup>();
 
    QString groupString;
    for (int group = 0; group < QPalette::NColorGroups; ++group) {
        const auto cg = QPalette::ColorGroup(group);
 
        if (p.isBrushSet(cg, cr)) {
            const auto &color = p.color(cg, cr);
            groupString += QString::fromUtf8(groupEnum.valueToKey(cg)) + u':' +
                           color.name(QColor::HexArgb) + u',';
        }
    }
    groupString.chop(1);
 
    return groupString;
}
 
static QString rolesToString(const QPalette &p)
{
    const auto roleEnum = QMetaEnum::fromType<QPalette::ColorRole>();
 
    QString roleString;
    for (int role = 0; role < QPalette::NColorRoles; ++role) {
        const auto cr = QPalette::ColorRole(role);
 
        auto groupString = groupsToString(p, cr);
        if (!groupString.isEmpty())
            roleString += QString::fromUtf8(roleEnum.valueToKey(cr)) + QStringLiteral(":[") +
                          groupString + QStringLiteral("],");
    }
    roleString.chop(1);
 
    return roleString;
}
 
QDebug operator<<(QDebug dbg, const QPalette &p)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace();
 
    dbg << "QPalette(resolve=" << Qt::hex << Qt::showbase << p.resolveMask();
 
    auto roleString = rolesToString(p);
    if (!roleString.isEmpty())
        dbg << ',' << roleString;
 
    dbg << ')';
 
    return dbg;
 }
#endif
 
QT_END_NAMESPACE
 
#include "moc_qpalette.cpp"