qquickpalette.cpp

Go to the documentation of this file.

// Copyright (C) 2020 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 "qquickpalette_p.h"
 
#include <QtQuick/private/qquickpalettecolorprovider_p.h>
 
QT_BEGIN_NAMESPACE
 
static constexpr bool is_valid(QPalette::ColorGroup cg) noexcept
{
    // use a switch to enable "unhandled enum" warnings:
    switch (cg) {
    case QPalette::Active:
    case QPalette::Disabled:
    case QPalette::Inactive:
        return true;
    case QPalette::NColorGroups:
    case QPalette::Current:
    case QPalette::All:
        return false;
    }
 
    // GCC 8.x does not tread __builtin_unreachable() as constexpr
#if defined(Q_CC_INTEL) || defined(Q_CC_CLANG) || (defined(Q_CC_GNU) && Q_CC_GNU >= 900)
    // NOLINTNEXTLINE(qt-use-unreachable-return): Triggers on Clang, breaking GCC 8
    Q_UNREACHABLE();
#endif
    return false;
}
 
QQuickPalette::QQuickPalette(QObject *parent)
    : QQuickColorGroup(parent)
    , m_currentGroup(defaultCurrentGroup())
{
}
 
QQuickColorGroup *QQuickPalette::active() const
{
    return colorGroup(QPalette::Active);
}
 
QQuickColorGroup *QQuickPalette::inactive() const
{
    return colorGroup(QPalette::Inactive);
}
 
QQuickColorGroup *QQuickPalette::disabled() const
{
    return colorGroup(QPalette::Disabled);
}
 
void QQuickPalette::resetActive()
{
    if (colorProvider().resetColor(QPalette::Active))
        Q_EMIT changed();
}
 
void QQuickPalette::resetInactive()
{
    if (colorProvider().resetColor(QPalette::Inactive))
        Q_EMIT changed();
}
 
void QQuickPalette::resetDisabled()
{
    if (colorProvider().resetColor(QPalette::Disabled))
        Q_EMIT changed();
}
 
QPalette::ColorGroup QQuickPalette::currentColorGroup() const
{
    return m_currentGroup;
}
 
void QQuickPalette::setCurrentGroup(QPalette::ColorGroup currentGroup)
{
    if (m_currentGroup != currentGroup) {
        m_currentGroup = currentGroup;
        Q_EMIT changed();
    }
}
 
void QQuickPalette::fromQPalette(QPalette palette)
{
    if (colorProvider().fromQPalette(std::move(palette))) {
        Q_EMIT changed();
    }
}
 
QPalette QQuickPalette::toQPalette() const
{
    return colorProvider().palette();
}
 
const QQuickAbstractPaletteProvider *QQuickPalette::paletteProvider() const
{
    return colorProvider().paletteProvider();
}
 
void QQuickPalette::setPaletteProvider(const QQuickAbstractPaletteProvider *paletteProvider)
{
    colorProvider().setPaletteProvider(paletteProvider);
}
 
void QQuickPalette::reset()
{
    if (colorProvider().reset()) {
        Q_EMIT changed();
    }
}
 
void QQuickPalette::inheritPalette(const QPalette &palette)
{
    if (colorProvider().inheritPalette(palette)) {
        Q_EMIT changed();
    }
}
 
void QQuickPalette::setActive(QQuickColorGroup *active)
{
    setColorGroup(QPalette::Active, active, &QQuickPalette::activeChanged);
}
 
void QQuickPalette::setInactive(QQuickColorGroup *inactive)
{
    setColorGroup(QPalette::Inactive, inactive, &QQuickPalette::inactiveChanged);
}
 
void QQuickPalette::setDisabled(QQuickColorGroup *disabled)
{
    setColorGroup(QPalette::Disabled, disabled, &QQuickPalette::disabledChanged);
}
 
 
void QQuickPalette::setColorGroup(QPalette::ColorGroup groupTag,
                                  const QQuickColorGroup::GroupPtr &group,
                                  void (QQuickPalette::*notifier)())
{
    if (isValidColorGroup(groupTag, group)) {
        if (colorProvider().copyColorGroup(groupTag, group->colorProvider())) {
            Q_EMIT (this->*notifier)();
            Q_EMIT changed();
        }
    }
}
 
QQuickColorGroup::GroupPtr QQuickPalette::colorGroup(QPalette::ColorGroup groupTag) const
{
    if (auto group = findColorGroup(groupTag)) {
        return group;
    }
 
    auto group = QQuickColorGroup::createWithParent(*const_cast<QQuickPalette*>(this));
    const_cast<QQuickPalette*>(this)->registerColorGroup(group, groupTag);
    return group;
}
 
QQuickColorGroup::GroupPtr QQuickPalette::findColorGroup(QPalette::ColorGroup groupTag) const
{
    Q_ASSERT(is_valid(groupTag));
    return m_colorGroups[groupTag];
}
 
void QQuickPalette::registerColorGroup(QQuickColorGroup *group, QPalette::ColorGroup groupTag)
{
    Q_ASSERT(is_valid(groupTag));
    auto &g = m_colorGroups[groupTag];
    if (g) {
        Q_ASSERT(g != group);
        g->deleteLater();
    }
    g = group;
 
    group->setGroupTag(groupTag);
 
    QQuickColorGroup::connect(group, &QQuickColorGroup::changed, this, &QQuickPalette::changed);
}
 
bool QQuickPalette::isValidColorGroup(QPalette::ColorGroup groupTag,
                                      const QQuickColorGroup::GroupPtr &colorGroup) const
{
    if (!colorGroup) {
        qWarning("Color group cannot be null.");
        return false;
    }
 
    if (!colorGroup->parent()) {
        qWarning("Color group should have a parent.");
        return false;
    }
 
    if (colorGroup->parent() && !qobject_cast<QQuickPalette*>(colorGroup->parent())) {
        qWarning("Color group should be a part of QQuickPalette.");
        return false;
    }
 
    if (groupTag == defaultGroupTag()) {
        qWarning("Register %i color group is not allowed."
                 " QQuickPalette is %i color group itself.", groupTag, groupTag);
        return false;
    }
 
    if (findColorGroup(groupTag) == colorGroup) {
        qWarning("The color group is already a part of the current palette.");
        return false;
    }
 
    return true;
}
 
QT_END_NAMESPACE
 
#include "moc_qquickpalette_p.cpp"