qstylehints.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 <qstylehints.h>
#include "qstylehints_p.h"
#include <qpa/qplatformintegration.h>
#include <qpa/qplatformtheme.h>
#include <private/qguiapplication_p.h>
#include <qdebug.h>
 
QT_BEGIN_NAMESPACE
 
static inline QVariant hint(QPlatformIntegration::StyleHint h)
{
    return QGuiApplicationPrivate::platformIntegration()->styleHint(h);
}
 
static inline QVariant themeableHint(QPlatformTheme::ThemeHint th,
                                     QPlatformIntegration::StyleHint ih)
{
    if (!QCoreApplication::instance()) {
        qWarning("Must construct a QGuiApplication before accessing a platform theme hint.");
        return QVariant();
    }
    if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme()) {
        const QVariant themeHint = theme->themeHint(th);
        if (themeHint.isValid())
            return themeHint;
    }
    return QGuiApplicationPrivate::platformIntegration()->styleHint(ih);
}
 
static inline QVariant themeableHint(QPlatformTheme::ThemeHint th)
{
    if (!QCoreApplication::instance()) {
        qWarning("Must construct a QGuiApplication before accessing a platform theme hint.");
        return QVariant();
    }
    if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme()) {
        const QVariant themeHint = theme->themeHint(th);
        if (themeHint.isValid())
            return themeHint;
    }
    return QPlatformTheme::defaultThemeHint(th);
}
 
QStyleHints::QStyleHints()
    : QObject(*new QStyleHintsPrivate(), nullptr)
{
}
 
void  QStyleHints::setMouseDoubleClickInterval(int mouseDoubleClickInterval)
{
    Q_D(QStyleHints);
    if (d->m_mouseDoubleClickInterval == mouseDoubleClickInterval)
        return;
    d->m_mouseDoubleClickInterval = mouseDoubleClickInterval;
    emit mouseDoubleClickIntervalChanged(mouseDoubleClickInterval);
}
 
int QStyleHints::mouseDoubleClickInterval() const
{
    Q_D(const QStyleHints);
    return d->m_mouseDoubleClickInterval >= 0 ?
           d->m_mouseDoubleClickInterval :
           themeableHint(QPlatformTheme::MouseDoubleClickInterval, QPlatformIntegration::MouseDoubleClickInterval).toInt();
}
 
int QStyleHints::mouseDoubleClickDistance() const
{
    Q_D(const QStyleHints);
    return d->m_mouseDoubleClickDistance >= 0 ?
                d->m_mouseDoubleClickDistance :
                themeableHint(QPlatformTheme::MouseDoubleClickDistance, QPlatformIntegration::MouseDoubleClickDistance).toInt();
}
 
int QStyleHints::touchDoubleTapDistance() const
{
    Q_D(const QStyleHints);
    return d->m_touchDoubleTapDistance >= 0 ?
                d->m_touchDoubleTapDistance :
                themeableHint(QPlatformTheme::TouchDoubleTapDistance).toInt();
}
 
Qt::ColorScheme QStyleHints::colorScheme() const
{
    Q_D(const QStyleHints);
    return d->colorScheme();
}
 
void QStyleHints::setColorScheme(Qt::ColorScheme scheme)
{
    if (!QCoreApplication::instance()) {
        qWarning("Must construct a QGuiApplication before accessing a platform theme hint.");
        return;
    }
    if (QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme())
        theme->requestColorScheme(scheme);
}
 
void QStyleHints::setMousePressAndHoldInterval(int mousePressAndHoldInterval)
{
    Q_D(QStyleHints);
    if (d->m_mousePressAndHoldInterval == mousePressAndHoldInterval)
        return;
    d->m_mousePressAndHoldInterval = mousePressAndHoldInterval;
    emit mousePressAndHoldIntervalChanged(mousePressAndHoldInterval);
}
 
int QStyleHints::mousePressAndHoldInterval() const
{
    Q_D(const QStyleHints);
    return d->m_mousePressAndHoldInterval >= 0 ?
           d->m_mousePressAndHoldInterval :
           themeableHint(QPlatformTheme::MousePressAndHoldInterval, QPlatformIntegration::MousePressAndHoldInterval).toInt();
}
 
void QStyleHints::setStartDragDistance(int startDragDistance)
{
    Q_D(QStyleHints);
    if (d->m_startDragDistance == startDragDistance)
        return;
    d->m_startDragDistance = startDragDistance;
    emit startDragDistanceChanged(startDragDistance);
}
 
int QStyleHints::startDragDistance() const
{
    Q_D(const QStyleHints);
    return d->m_startDragDistance >= 0 ?
           d->m_startDragDistance :
           themeableHint(QPlatformTheme::StartDragDistance, QPlatformIntegration::StartDragDistance).toInt();
}
 
void QStyleHints::setStartDragTime(int startDragTime)
{
    Q_D(QStyleHints);
    if (d->m_startDragTime == startDragTime)
        return;
    d->m_startDragTime = startDragTime;
    emit startDragTimeChanged(startDragTime);
}
 
int QStyleHints::startDragTime() const
{
    Q_D(const QStyleHints);
    return d->m_startDragTime >= 0 ?
           d->m_startDragTime :
           themeableHint(QPlatformTheme::StartDragTime, QPlatformIntegration::StartDragTime).toInt();
}
 
int QStyleHints::startDragVelocity() const
{
    return themeableHint(QPlatformTheme::StartDragVelocity, QPlatformIntegration::StartDragVelocity).toInt();
}
 
void QStyleHints::setKeyboardInputInterval(int keyboardInputInterval)
{
    Q_D(QStyleHints);
    if (d->m_keyboardInputInterval == keyboardInputInterval)
        return;
    d->m_keyboardInputInterval = keyboardInputInterval;
    emit keyboardInputIntervalChanged(keyboardInputInterval);
}
 
int QStyleHints::keyboardInputInterval() const
{
    Q_D(const QStyleHints);
    return d->m_keyboardInputInterval >= 0 ?
           d->m_keyboardInputInterval :
           themeableHint(QPlatformTheme::KeyboardInputInterval, QPlatformIntegration::KeyboardInputInterval).toInt();
}
 
#if QT_DEPRECATED_SINCE(6, 5)
int QStyleHints::keyboardAutoRepeatRate() const
{
    return themeableHint(QPlatformTheme::KeyboardAutoRepeatRate, QPlatformIntegration::KeyboardAutoRepeatRate).toInt();
}
#endif
 
qreal QStyleHints::keyboardAutoRepeatRateF() const
{
    return themeableHint(QPlatformTheme::KeyboardAutoRepeatRate, QPlatformIntegration::KeyboardAutoRepeatRate).toReal();
}
 
void QStyleHints::setCursorFlashTime(int cursorFlashTime)
{
    Q_D(QStyleHints);
    if (d->m_cursorFlashTime == cursorFlashTime)
        return;
    d->m_cursorFlashTime = cursorFlashTime;
    emit cursorFlashTimeChanged(cursorFlashTime);
}
 
int QStyleHints::cursorFlashTime() const
{
    Q_D(const QStyleHints);
    return d->m_cursorFlashTime >= 0 ?
           d->m_cursorFlashTime :
           themeableHint(QPlatformTheme::CursorFlashTime, QPlatformIntegration::CursorFlashTime).toInt();
}
 
bool QStyleHints::showIsFullScreen() const
{
    return hint(QPlatformIntegration::ShowIsFullScreen).toBool();
}
 
bool QStyleHints::showIsMaximized() const
{
    return hint(QPlatformIntegration::ShowIsMaximized).toBool();
}
 
bool QStyleHints::showShortcutsInContextMenus() const
{
    Q_D(const QStyleHints);
    return d->m_showShortcutsInContextMenus >= 0
        ? d->m_showShortcutsInContextMenus != 0
        : themeableHint(QPlatformTheme::ShowShortcutsInContextMenus, QPlatformIntegration::ShowShortcutsInContextMenus).toBool();
}
 
void QStyleHints::setShowShortcutsInContextMenus(bool s)
{
    Q_D(QStyleHints);
    if (s != showShortcutsInContextMenus()) {
        d->m_showShortcutsInContextMenus = s ? 1 : 0;
        emit showShortcutsInContextMenusChanged(s);
    }
}
 
Qt::ContextMenuTrigger QStyleHints::contextMenuTrigger() const
{
    Q_D(const QStyleHints);
    if (d->m_contextMenuTrigger == -1) {
        return themeableHint(QPlatformTheme::ContextMenuOnMouseRelease).toBool()
                   ? Qt::ContextMenuTrigger::Release
                   : Qt::ContextMenuTrigger::Press;
    }
    return Qt::ContextMenuTrigger(d->m_contextMenuTrigger);
}
 
void QStyleHints::setContextMenuTrigger(Qt::ContextMenuTrigger contextMenuTrigger)
{
    Q_D(QStyleHints);
    const Qt::ContextMenuTrigger currentTrigger = this->contextMenuTrigger();
    d->m_contextMenuTrigger = int(contextMenuTrigger);
    if (currentTrigger != contextMenuTrigger)
        emit contextMenuTriggerChanged(contextMenuTrigger);
}
 
int QStyleHints::passwordMaskDelay() const
{
    return themeableHint(QPlatformTheme::PasswordMaskDelay, QPlatformIntegration::PasswordMaskDelay).toInt();
}
 
QChar QStyleHints::passwordMaskCharacter() const
{
    return themeableHint(QPlatformTheme::PasswordMaskCharacter, QPlatformIntegration::PasswordMaskCharacter).toChar();
}
 
qreal QStyleHints::fontSmoothingGamma() const
{
    return hint(QPlatformIntegration::FontSmoothingGamma).toReal();
}
 
bool QStyleHints::useRtlExtensions() const
{
    return hint(QPlatformIntegration::UseRtlExtensions).toBool();
}
 
bool QStyleHints::setFocusOnTouchRelease() const
{
    return themeableHint(QPlatformTheme::SetFocusOnTouchRelease, QPlatformIntegration::SetFocusOnTouchRelease).toBool();
}
 
Qt::TabFocusBehavior QStyleHints::tabFocusBehavior() const
{
    Q_D(const QStyleHints);
    return Qt::TabFocusBehavior(d->m_tabFocusBehavior >= 0 ?
                                d->m_tabFocusBehavior :
                                themeableHint(QPlatformTheme::TabFocusBehavior, QPlatformIntegration::TabFocusBehavior).toInt());
}
 
void QStyleHints::setTabFocusBehavior(Qt::TabFocusBehavior tabFocusBehavior)
{
    Q_D(QStyleHints);
    if (d->m_tabFocusBehavior == tabFocusBehavior)
        return;
    d->m_tabFocusBehavior = tabFocusBehavior;
    emit tabFocusBehaviorChanged(tabFocusBehavior);
}
 
bool QStyleHints::singleClickActivation() const
{
    return themeableHint(QPlatformTheme::ItemViewActivateItemOnSingleClick, QPlatformIntegration::ItemViewActivateItemOnSingleClick).toBool();
}
 
bool QStyleHints::useHoverEffects() const
{
    Q_D(const QStyleHints);
    return (d->m_uiEffects >= 0 ?
            d->m_uiEffects :
            themeableHint(QPlatformTheme::UiEffects, QPlatformIntegration::UiEffects).toInt()) & QPlatformTheme::HoverEffect;
}
 
void QStyleHints::setUseHoverEffects(bool useHoverEffects)
{
    Q_D(QStyleHints);
    if (d->m_uiEffects >= 0 && useHoverEffects == bool(d->m_uiEffects & QPlatformTheme::HoverEffect))
        return;
    if (d->m_uiEffects == -1)
        d->m_uiEffects = 0;
    if (useHoverEffects)
        d->m_uiEffects |= QPlatformTheme::HoverEffect;
    else
        d->m_uiEffects &= ~QPlatformTheme::HoverEffect;
    emit useHoverEffectsChanged(useHoverEffects);
}
 
int QStyleHints::wheelScrollLines() const
{
    Q_D(const QStyleHints);
    if (d->m_wheelScrollLines > 0)
        return d->m_wheelScrollLines;
    return themeableHint(QPlatformTheme::WheelScrollLines, QPlatformIntegration::WheelScrollLines).toInt();
}
 
void QStyleHints::setWheelScrollLines(int scrollLines)
{
    Q_D(QStyleHints);
    if (d->m_wheelScrollLines == scrollLines)
        return;
    d->m_wheelScrollLines = scrollLines;
    emit wheelScrollLinesChanged(scrollLines);
}
 
void QStyleHints::setMouseQuickSelectionThreshold(int threshold)
{
    Q_D(QStyleHints);
    if (d->m_mouseQuickSelectionThreshold == threshold)
        return;
    d->m_mouseQuickSelectionThreshold = threshold;
    emit mouseQuickSelectionThresholdChanged(threshold);
}
 
int QStyleHints::mouseQuickSelectionThreshold() const
{
    Q_D(const QStyleHints);
    if (d->m_mouseQuickSelectionThreshold >= 0)
        return d->m_mouseQuickSelectionThreshold;
    return themeableHint(QPlatformTheme::MouseQuickSelectionThreshold, QPlatformIntegration::MouseQuickSelectionThreshold).toInt();
}
 
void QStyleHintsPrivate::updateColorScheme(Qt::ColorScheme colorScheme)
{
    if (m_colorScheme == colorScheme)
        return;
    m_colorScheme = colorScheme;
    Q_Q(QStyleHints);
    emit q->colorSchemeChanged(colorScheme);
}
 
QStyleHintsPrivate *QStyleHintsPrivate::get(QStyleHints *q)
{
    Q_ASSERT(q);
    return q->d_func();
}
 
QT_END_NAMESPACE
 
#include "moc_qstylehints.cpp"