Revision control
Copy as Markdown
// Copyright (C) 2025 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 "qqstylekitpropertyresolver_p.h"
#include "qqstylekitcontrol_p.h"
#include "qqstylekitcontrols_p.h"
#include "qqstylekitvariation_p.h"
#include "qqstylekitstyle_p.h"
#include "qqstylekittheme_p.h"
#include "qqstylekitdebug_p.h"
#include <QtQuickTemplates2/private/qquickcontrol_p.h>
#include <QtCore/QScopedValueRollback>
QT_BEGIN_NAMESPACE
bool QQStyleKitPropertyResolver::s_styleWarningsIssued = false;
bool QQStyleKitPropertyResolver::s_isReadingProperty = false;
QQSK::State QQStyleKitPropertyResolver::s_cachedState = QQSK::StateFlag::Unspecified;
QVarLengthArray<QQSK::StateFlag, 10> QQStyleKitPropertyResolver::s_cachedStateList;
const QList<QQStyleKitExtendableControlType> QQStyleKitPropertyResolver::baseTypesForType(
QQStyleKitExtendableControlType exactType)
{
/* By default, the base types should mirror the class hierarchy in Qt Quick Controls.
* However, to make it possible to style a base type without having to "undo" it again
* in a sub type, we choose to diverge in som cases:
*
* ItemDelegate — Normally used as a menu item in a ComboBox or as an item in a ListView.
* Although it behaves similarly to a button, it is typically styled very differently
* (e.g., without borders, drop shadows, gradients, etc.). For that reason, it falls
* back to Control rather than AbstractButton.
*
* MenuBarItem — Although it is technically a button, it is typically styled very differently
* from other buttons (e.g., without borders, drop shadows, gradients, etc.). For that
* reason, it falls back to Control rather than AbstractButton.
*
* MenuItem — In Qt Quick Controls, MenuItem inherits from AbstractButton. Although it
* behaves similarly to a button, it is typically styled very differently
* (e.g., without borders, drop shadows, gradients, etc.). For that reason, it falls
* back to Control rather than AbstractButton.
*
* TabBar — In Qt Quick Controls, ToolBar inherits Pane, while TabBar inherits Container.
* Since it is desirable for a TabBar to share styling characteristics (such as
* background color) with ToolBar and Pane, we let it fall back to Pane instead of
* Control.
*/
switch (exactType) {
case QQStyleKitReader::ApplicationWindow: {
static QList<QQStyleKitExtendableControlType> t =
{ QQStyleKitReader::ApplicationWindow };
return t; }
case QQStyleKitReader::Button:
case QQStyleKitReader::DelayButton:
case QQStyleKitReader::FlatButton:
case QQStyleKitReader::ToolButton:
case QQStyleKitReader::TabButton:
case QQStyleKitReader::RadioButton:
case QQStyleKitReader::RoundButton:
case QQStyleKitReader::CheckBox:
case QQStyleKitReader::SwitchControl: {
static QList<QQStyleKitExtendableControlType> t =
{ QQStyleKitReader::AbstractButton, QQStyleKitReader::Control };
return t; }
case QQStyleKitReader::CheckDelegate:
case QQStyleKitReader::RadioDelegate:
case QQStyleKitReader::SwipeDelegate:
case QQStyleKitReader::SwitchDelegate:
case QQStyleKitReader::TableViewDelegate:
case QQStyleKitReader::TreeViewDelegate: {
static QList<QQStyleKitExtendableControlType> t =
{ QQStyleKitReader::ItemDelegate, QQStyleKitReader::Control };
return t; }
case QQStyleKitReader::HeaderViewDelegate: {
static QList<QQStyleKitExtendableControlType> t =
{ QQStyleKitReader::TableViewDelegate, QQStyleKitReader::ItemDelegate, QQStyleKitReader::Control };
return t;
}
case QQStyleKitReader::Dialog:
case QQStyleKitReader::Drawer:
case QQStyleKitReader::Menu:
case QQStyleKitReader::ToolTip: {
static QList<QQStyleKitExtendableControlType> t =
{ QQStyleKitReader::Popup, QQStyleKitReader::Control };
return t; }
case QQStyleKitReader::Page:
case QQStyleKitReader::DialogButtonBox:
case QQStyleKitReader::Frame:
case QQStyleKitReader::TabBar:
case QQStyleKitReader::ToolBar: {
static QList<QQStyleKitExtendableControlType> t =
{ QQStyleKitReader::Pane, QQStyleKitReader::Control };
return t; }
case QQStyleKitReader::GroupBox: {
static QList<QQStyleKitExtendableControlType> t =
{ QQStyleKitReader::Frame, QQStyleKitReader::Pane, QQStyleKitReader::Control };
return t;
}
case QQStyleKitReader::TextField:
case QQStyleKitReader::TextArea: {
static QList<QQStyleKitExtendableControlType> t =
{ QQStyleKitReader::TextInput, QQStyleKitReader::Control };
return t; }
default: {
static QList<QQStyleKitExtendableControlType> t =
{ QQStyleKitReader::Control };
return t; }
}
Q_UNREACHABLE();
return {};
}
void QQStyleKitPropertyResolver::cacheReaderState(QQSK::State state)
{
Q_ASSERT(state != QQSK::StateFlag::Unspecified);
if (state == s_cachedState)
return;
s_cachedState = state;
/* Note: The order in which we add the states below matters.
* The reason is that the s_cachedStateList that we build is used by QQStyleKitPropertyResolver
* later to generate all the different state combinations that should be tested when
* searching for a property. And the states added first to the list will "win" if the
* same property is set in several of the states. */
s_cachedStateList.clear();
if (state.testFlag(QQSK::StateFlag::Pressed))
s_cachedStateList.append(QQSK::StateFlag::Pressed);
if (state.testFlag(QQSK::StateFlag::Hovered))
s_cachedStateList.append(QQSK::StateFlag::Hovered);
if (state.testFlag(QQSK::StateFlag::Highlighted))
s_cachedStateList.append(QQSK::StateFlag::Highlighted);
if (state.testFlag(QQSK::StateFlag::Focused))
s_cachedStateList.append(QQSK::StateFlag::Focused);
if (state.testFlag(QQSK::StateFlag::Checked))
s_cachedStateList.append(QQSK::StateFlag::Checked);
if (state.testFlag(QQSK::StateFlag::Vertical))
s_cachedStateList.append(QQSK::StateFlag::Vertical);
if (state.testFlag(QQSK::StateFlag::Disabled))
s_cachedStateList.append(QQSK::StateFlag::Disabled);
}
void QQStyleKitPropertyResolver::addVariationToReader(
QQStyleKitReader *styleReader,
QQStyleKitStyleAndThemeBase *styleOrTheme,
QQStyleKitVariation *variation)
{
/* Add the variation to the StyleReader's list of effective variations.
* A variation may appear more than once in a type variation list or in
* an instance variation list, but it only needs to be added once - the
* first in the list will shadow the other ones anyway. */
if (!styleReader->m_effectiveVariations.contains(variation))
styleReader->m_effectiveVariations.append(variation);
/* We also record in which Style or Theme the variation was found, so that
* it only takes effect for that specific Style or Theme during property
* propagation. Note that the same type variation can be used from both the
* Style and the Theme (its ID can be added to several variation lists). */
if (!variation->m_usageContext.contains(styleOrTheme))
variation->m_usageContext.append(styleOrTheme);
}
void QQStyleKitPropertyResolver::addTypeVariationsToReader(
QQStyleKitReader *styleReader,
QQStyleKitStyleAndThemeBase *styleOrTheme,
const AttachedVariationList &attachedVariations)
{
const QQStyleKitExtendableControlType styleReaderType = styleReader->controlType();
const auto styleReaderBaseType = baseTypesForType(styleReaderType);
static PropertyPathIds ids;
if (ids.property.property() == QQSK::Property::NoProperty) {
/* ids is made static, since the 'variations' path will be the same for all
* StyleKitControls. Also, since subtypes are only possible for delegates,
* and 'variations' is a control property, we can exclude subtypes. */
ids.property = QQStyleKitPropertyPath(styleReader, QQSK::Property::Variations, QQStyleKitPropertyPath::Flag::ExcludeSubtype);
ids.alternative = QQStyleKitPropertyPath(styleReader, QQSK::Property::NoProperty, QQStyleKitPropertyPath::Flag::ExcludeSubtype);
ids.subTypeProperty = QQStyleKitPropertyPath();
ids.subTypeAlternative = QQStyleKitPropertyPath();
}
for (const QQStyleKitVariationAttached *attached : attachedVariations) {
const auto parentType = attached->controlType();
const auto parentBaseTypes = baseTypesForType(parentType);
/* Search for the 'variations' property set on the parentType, or any of its base
* types, using normal propagation and fallback logic. Unlike when resolving other style
* properties, we limit the search to the style or theme we're processing, since it matters which
* style or theme a variation belongs when they're used to resolve other style properties later. */
const QVariant typeVariationsVariant = readPropertyInRelevantControls(styleOrTheme, ids, parentType, parentBaseTypes);
if (!typeVariationsVariant.isValid())
continue;
const auto typeVariations = *qvariant_cast<QList<QQStyleKitVariation *> *>(typeVariationsVariant);
for (QQStyleKitVariation *variation : typeVariations) {
/* Inside each type variation, check if the control type that styleReader represents has
* been defined. If so, it means that the variation _might_ affect it, and should therefore
* be added to the style readers list of effective variations. */
if (!variation) {
/* The variation will be nullptr if non-QQStyleKitVariation elements
* are added to the 'variations' list from QML (such as strings). */
continue;
}
if (variation->getControlStyle(styleReaderType)) {
addVariationToReader(styleReader, styleOrTheme, variation);
} else {
for (int type : styleReaderBaseType) {
if (variation->getControlStyle(type))
addVariationToReader(styleReader, styleOrTheme, variation);
}
}
}
}
}
void QQStyleKitPropertyResolver::addInstanceVariationsToReader(
QQStyleKitReader *styleReader,
QQStyleKitStyleAndThemeBase *styleOrTheme,
const AttachedVariationList &attachedVariations)
{
/* Add the variations set from the application to the list of effective variations
* in the styleReader. But, to speed up property look-up later on, we only add the
* variations that has the potential to affect the control type, or its base types,
* that the styleReader represents. The variations that are closest to styleReader
* in the hierarchy will be added first and take precendence over the ones added last. */
const QQStyleKitExtendableControlType styleReaderType = styleReader->controlType();
const auto styleReaderBaseTypes = baseTypesForType(styleReaderType);
for (const QQStyleKitVariationAttached *attached : attachedVariations) {
for (const QString &instanceVariationName : attached->variations()) {
for (QQStyleKitVariation *variation : styleOrTheme->m_styleVariations) {
if (variation->name() != instanceVariationName)
continue;
/* Invariant: we found a variation in the given Style or a Theme with a name that matches
* a name in the attached variation list. Check if the found variation contains the
* type, or the subtypes, of the style reader. If not, it doesn't affect it and can
* therefore be skipped. */
if (variation->getControlStyle(styleReaderType)) {
addVariationToReader(styleReader, styleOrTheme, variation);
} else {
for (int baseType : styleReaderBaseTypes) {
if (variation->getControlStyle(baseType))
addVariationToReader(styleReader, styleOrTheme, variation);
}
}
}
}
}
}
void QQStyleKitPropertyResolver::rebuildVariationsForReader(
QQStyleKitReader *styleReader, QQStyleKitStyle *style)
{
/* Traverse up the parent chain of \a styleReader, and for each parent, look for an
* instance of QQStyleKitVariationAttached. And for each attached object, check if it
* has variations that can potentially affect the style reader. If so, add the
* variations to the style readers list of effective variations.
* A QQStyleKitVariationAttached can specify both Instance Variations and Type Variations.
* The former should affect all descendant StyleKitReaders of the parent, while the
* latter should only affect descendant StyleKitReaders of a specific type. */
Q_ASSERT(styleReader->m_effectiveVariationsDirty);
styleReader->m_effectiveVariationsDirty = false;
styleReader->m_effectiveVariations.clear();
if (!style->m_hasVariations)
return;
/* Walk up the parent chain and collect all attached StyleVariation objects that
* may affect this StyleReader. Their variation lists affect instance variations,
* and their control type may affect type variations. */
AttachedVariationList attachedVariations;
for (QObject *current = styleReader; current; current = current->parent()) {
if (const QObject *attachedObject = qmlAttachedPropertiesObject<QQStyleKitVariation>(current, false)) {
const auto *attached = static_cast<const QQStyleKitVariationAttached *>(attachedObject);
attachedVariations.append(attached);
}
}
if (attachedVariations.isEmpty())
return;
for (QQStyleKitStyle *current = style; current; current = current->fallbackStyle()) {
if (QQStyleKitTheme *theme = current->theme()) {
addInstanceVariationsToReader(styleReader, theme, attachedVariations);
addTypeVariationsToReader(styleReader, theme, attachedVariations);
}
addInstanceVariationsToReader(styleReader, current, attachedVariations);
addTypeVariationsToReader(styleReader, current, attachedVariations);
}
}
template <class T>
QVariant QQStyleKitPropertyResolver::readPropertyInStorageForState(
const QQStyleKitPropertyPath main, const QQStyleKitPropertyPath alternative,
const T *storageProvider, QQSK::State state)
{
/* If either the main property or its alternative is set in the storage,
* we’ve found the best match and can return the value to the application.
* The reason we support an alternative property is that some properties can be
* specified in more than one way. For example, 'topLeftRadius' can be set either
* directly ('topLeftRadius', the main property) or indirectly via 'radius'
* (the alternative). Whichever one is encountered first in the propagation chain
* takes precedence.
* This means that when resolving 'topLeftRadius' for a Button, if 'radius' is set
* on the Button and 'topLeftRadius' is set on AbstractButton, then 'radius' will
* override 'topLeftRadius' and be used as the final value. */
Q_ASSERT(qlonglong(state) <= qlonglong(QQSK::StateFlag::MAX_STATE));
const PropertyStorageId propertyKey = main.createStorageId(state);
if (Q_UNLIKELY(QQStyleKitDebug::enabled()))
QQStyleKitDebug::trace(main, storageProvider, state, propertyKey);
const QVariant propertyValue = storageProvider->readStyleProperty(propertyKey);
if (propertyValue.isValid()) {
if (Q_UNLIKELY(QQStyleKitDebug::enabled()))
QQStyleKitDebug::notifyPropertyRead(main, storageProvider, state, propertyValue);
return propertyValue;
}
const PropertyStorageId altPropertyKey = alternative.createStorageId(state);
if (Q_UNLIKELY(QQStyleKitDebug::enabled()))
QQStyleKitDebug::trace(alternative, storageProvider, state, altPropertyKey);
const QVariant altValue = storageProvider->readStyleProperty(altPropertyKey);
if (altValue.isValid()) {
if (Q_UNLIKELY(QQStyleKitDebug::enabled()))
QQStyleKitDebug::notifyPropertyRead(main, storageProvider, state, altValue);
return altValue;
}
return {};
}
template <class INDICES_CONTAINER>
QVariant QQStyleKitPropertyResolver::readPropertyInControlForStates(
const QQStyleKitPropertyPath main, const QQStyleKitPropertyPath alternative,
const QQStyleKitControl *control, INDICES_CONTAINER &stateListIndices,
int startIndex, int recursionLevel)
{
for (int i = startIndex; i < s_cachedStateList.length(); ++i) {
/* stateListIndices is a helper list to track which index in the state list
* each recursion level is currently processing. The first recursion level
* will iterate through all of the states. The second recursion level will
* only the iterate through the states that comes after the state at the
* previous recursion. And so on recursively. The end result will be a list of
* state combinations (depth first) where no state is repeated more than
* once. And for each combination, we check if the storage has a value assigned
* for the given property for the given state combination. */
stateListIndices[recursionLevel] = i;
const QQSK::StateFlag stateFlag = s_cachedStateList[i];
/* Optimization: check if the control stores values for any properties for
* the state we're processing. Otherwise, skip the state. */
if (!control->m_writtenStates.testFlag(stateFlag))
continue;
/* Optimization: check if the style/theme/variation stores a value for the
* property in the state we're processing. Otherwise, skip the state. */
const QQStyleKitControls *controls = control->controls();
const QQSK::State statesAffectingProperty = controls->m_writtenPropertyPaths[main.pathId()];
if (!statesAffectingProperty.testFlag(stateFlag)) {
if (alternative.property() == QQSK::Property::NoProperty) {
continue;
} else {
const QQSK::State statesAffectingAlternative = controls->m_writtenPropertyPaths[alternative.pathId()];
if (!statesAffectingAlternative.testFlag(stateFlag))
continue;
}
}
if (recursionLevel < s_cachedStateList.length() - 1) {
// Continue the recursion towards the longest possible nested state
const QVariant value = readPropertyInControlForStates(
main, alternative, control, stateListIndices, i + 1, recursionLevel + 1);
if (value.isValid())
return value;
}
// Check the current combination
QQSK::State storageState = QQSK::StateFlag::Unspecified;
for (int j = 0; j <= recursionLevel; ++j)
storageState.setFlag(s_cachedStateList[stateListIndices[j]]);
const QVariant value = readPropertyInStorageForState(main, alternative, control, storageState);
if (value.isValid())
return value;
}
return {};
}
QVariant QQStyleKitPropertyResolver::readPropertyInControl(
const PropertyPathIds &ids, const QQStyleKitControl *control)
{
/* Find the most specific state combination (based on the state of the reader) that
* has a value set for the property in the contol. In case several state combinations
* could be found, the order of the states in the stateList decides the priority.
* If we're reading a property in a subtype, try all state combinations in the subtype
* first, before trying all the state combinations in the super type. */
QVarLengthArray<int, 10> stateListIndices(s_cachedStateList.length());
if (ids.subTypeProperty.property() != QQSK::Property::NoProperty) {
if (s_cachedState != QQSK::StateFlag::Normal) {
QVariant value = readPropertyInControlForStates(
ids.subTypeProperty, ids.subTypeAlternative, control, stateListIndices, 0, 0);
if (value.isValid())
return value;
}
if (control->m_writtenStates.testFlag(QQSK::StateFlag::Normal)) {
const QVariant value = readPropertyInStorageForState(
ids.subTypeProperty, ids.subTypeAlternative, control, QQSK::StateFlag::Normal);
if (value.isValid())
return value;
}
}
if (s_cachedState != QQSK::StateFlag::Normal) {
const QVariant value = readPropertyInControlForStates(
ids.property, ids.alternative, control, stateListIndices, 0, 0);
if (value.isValid())
return value;
}
/* The normal state is the propagation fall back for all state combinations.
* If the normal state has the property set, it'll return a valid QVariant,
* which will cause the propagation to stop. Otherwise we'll return an invalid
* variant which will cause the search to continue. */
if (control->m_writtenStates.testFlag(QQSK::StateFlag::Normal))
return readPropertyInStorageForState(ids.property, ids.alternative, control, QQSK::StateFlag::Normal);
return {};
}
QVariant QQStyleKitPropertyResolver::readPropertyInRelevantControls(
const QQStyleKitControls *controls, const PropertyPathIds &ids,
const QQStyleKitExtendableControlType exactType,
const QList<QQStyleKitExtendableControlType> baseTypes)
{
if (!controls)
return {};
/* Optimization: check if the style/theme/variation stores a value for
* the property, regardless of state. Otherwise we can just return. */
while (true) {
const auto writtenProperties = controls->m_writtenPropertyPaths;
if (writtenProperties.contains(ids.property.pathId()))
break;
const bool hasAlternative = ids.alternative.property() != QQSK::Property::NoProperty;
if (hasAlternative && writtenProperties.contains(ids.alternative.pathId()))
break;
if (ids.subTypeProperty.property() == QQSK::Property::NoProperty)
return {};
if (writtenProperties.contains(ids.subTypeProperty.pathId()))
break;
if (hasAlternative && writtenProperties.contains(ids.subTypeAlternative.pathId()))
break;
return {};
}
if (const QQStyleKitControl *control = controls->getControlStyle(exactType)) {
const QVariant value = readPropertyInControl(ids, control);
if (value.isValid())
return value;
}
for (const int type : baseTypes) {
if (const QQStyleKitControl *control = controls->getControlStyle(type)) {
const QVariant value = readPropertyInControl(ids, control);
if (value.isValid())
return value;
}
}
return {};
}
QVariant QQStyleKitPropertyResolver::readPropertyInVariations(
const QList<QPointer<QQStyleKitVariation>> &variations,
const QQStyleKitStyleAndThemeBase *styleOrTheme,
const PropertyPathIds &ids,
const QQStyleKitExtendableControlType exactType,
const QList<QQStyleKitExtendableControlType> baseTypes)
{
bool foundAtLeastOneVariation = false;
for (const QPointer<QQStyleKitVariation> &variation : variations) {
if (!variation)
continue;
if (!variation->m_usageContext.contains(styleOrTheme)) {
if (foundAtLeastOneVariation) {
/* Optimization: We have found at least one effective variation in the list, but this
* one has a different usage context. This means that the remaining variations will also
* have a different usage context, since the variations were added to the list sorted on context.
* So we can end the iteration. */
break;
}
/* The variations list is sorted on usage context. And the first variation in the list with
* the correct usage context has yet to be found. So continue to the next variation. */
continue;
}
foundAtLeastOneVariation = true;
const QVariant value = readPropertyInRelevantControls(variation, ids, exactType, baseTypes);
if (value.isValid())
return value;
}
return {};
}
QVariant QQStyleKitPropertyResolver::readPropertyInStyle(
QQStyleKitStyle *style, const PropertyPathIds &ids, QQStyleKitReader *styleReader)
{
/* Sync the palette of the style with the palette of the current reader. Note
* that this can cause palette bindings in the style to change, which will
* result in calls to writeStyleProperty(). */
style->syncFromQPalette(styleReader->effectivePalette());
/* Cache the state of the style reader to avoid rebuilding the same helper
* structures on subsequent reads. In practice, a single style reader
* typically processes many properties in sequence rather than just one. */
cacheReaderState(styleReader->controlState());
if (styleReader->m_effectiveVariationsDirty)
rebuildVariationsForReader(styleReader, style);
const QQStyleKitExtendableControlType exactType = styleReader->controlType();
const QList<QQStyleKitExtendableControlType> baseTypes = baseTypesForType(exactType);
QVariant value;
while (true) {
value = readPropertyInVariations(styleReader->m_effectiveVariations, style->theme(), ids, exactType, baseTypes);
if (value.isValid())
break;
value = readPropertyInRelevantControls(style->theme(), ids, exactType, baseTypes);
if (value.isValid())
break;
value = readPropertyInVariations(styleReader->m_effectiveVariations, style, ids, exactType, baseTypes);
if (value.isValid())
break;
value = readPropertyInRelevantControls(style, ids, exactType, baseTypes);
if (value.isValid())
break;
if (auto *fallbackStyle = style->fallbackStyle()) {
/* Recurse into the fallback style, and search for the property there. If not
* found, and the fallback style has a fallback style, the recursion continues. */
value = readPropertyInStyle(fallbackStyle, ids, styleReader);
if (value.isValid())
break;
}
break;
}
if (Q_UNLIKELY(QQStyleKitDebug::enabled())) {
if (!value.isValid())
QQStyleKitDebug::notifyPropertyNotResolved(ids.property);
}
return value;
}
QVariant QQStyleKitPropertyResolver::readStyleProperty(
const QQStyleKitPropertyGroup *group,
const QQSK::Property property,
const QQSK::Property alternative)
{
const QQStyleKitControlProperties *controlProperties = group->controlProperties();
const QQSK::PropertyPathFlags pathFlags = group->pathFlags();
const QQSK::Subclass subclass = controlProperties->subclass();
if (subclass != QQSK::Subclass::QQStyleKitReader) {
/* Due to propagation, we must know the reader’s state in order to resolve the value
* of a given property. For example, the background delegate’s color may follow a
* completely different lookup path—and therefore produce a different result—depending
* on whether the reader is a Slider or a Button, and whether it is hovered, pressed, etc.
* For this reason, when a property is not read via a QQStyleKitReader, propagation and
* fall back logic cannot be supported.
* However, to still allow static (i.e., non-propagating) bindings between properties
* _inside_ a Style, we fall back to return the value set directly on the accessed control. */
Q_ASSERT(subclass == QQSK::Subclass::QQStyleKitState);
const QQStyleKitControlState *controlState = controlProperties->asQQStyleKitState();
const QQStyleKitControl *control = controlState->control();
const PropertyStorageId key = QQStyleKitPropertyPath(group, property).createStorageId(controlState->nestedState());
return control->readStyleProperty(key);
}
QQStyleKitStyle *style = controlProperties->style();
if (!style || !style->loaded()) {
/* No style has been set yet, or the style is still loading. The application should set
* a style early (e.g. at the top of main.qml) before creating any controls, to avoid
* premature property reads that end up here. However, some controls like the menu bar
* are instantiated very early and may try to read properties before a style is available. */
return {};
}
QQStyleKitDebug::groupBeingRead = group;
QQStyleKitReader *styleReader = controlProperties->asQQStyleKitReader();
if (s_isReadingProperty) {
if (!s_styleWarningsIssued) {
s_styleWarningsIssued = true;
qmlWarning(styleReader) << "The style property '" << property << "' was read "
<< "before finishing the read of another style property. "
<< "This is likely to cause a style glitch.";
}
}
QScopedValueRollback rollback(s_isReadingProperty, true);
PropertyPathIds ids;
ids.property = QQStyleKitPropertyPath(group, property, QQStyleKitPropertyPath::Flag::ExcludeSubtype);
ids.alternative = QQStyleKitPropertyPath(group, alternative, QQStyleKitPropertyPath::Flag::ExcludeSubtype);
const bool insideSubType = pathFlags &
(QQSK::PropertyPathFlag::DelegateSubtype1 | QQSK::PropertyPathFlag::DelegateSubtype2);
if (insideSubType) {
ids.subTypeProperty = QQStyleKitPropertyPath(group, property);
ids.subTypeAlternative = QQStyleKitPropertyPath(group, alternative);
} else {
ids.subTypeProperty = QQStyleKitPropertyPath();
ids.subTypeAlternative = QQStyleKitPropertyPath();
}
if (!pathFlags.testFlag(QQSK::PropertyPathFlag::Global)) {
/* A style reader can have a storage that contains local property overrides (that is,
* interpolated values from an ongoing transition). When searching for a property, we
* therefore need to check this storage first. The exception is if the property was read
* inside the 'global' group, which means that we should read the values directly
* from the style. */
if (insideSubType) {
const QVariant value = readPropertyInStorageForState(
ids.subTypeProperty, ids.subTypeAlternative, styleReader, QQSK::StateFlag::Normal);
if (value.isValid())
return value;
}
const QVariant value = readPropertyInStorageForState(
ids.property, ids.alternative, styleReader, QQSK::StateFlag::Normal);
if (value.isValid())
return value;
}
return readPropertyInStyle(style, ids, styleReader);
}
bool QQStyleKitPropertyResolver::writeStyleProperty(
const QQStyleKitPropertyGroup *group,
const QQSK::Property property,
const QVariant &value)
{
// While readStyleProperty() takes propagation into account, writeStyleProperty() doesn't.
// Instead it writes \a value directly to the storage that the group belongs to.
Q_ASSERT(group);
const QQStyleKitControlProperties *controlProperties = group->controlProperties();
const QQSK::PropertyPathFlags pathFlags = group->pathFlags();
const QQSK::Subclass subclass = controlProperties->subclass();
const QQStyleKitPropertyPath propertyPath(group, property);
if (pathFlags.testFlag(QQSK::PropertyPathFlag::Global)) {
qmlWarning(controlProperties) << "Properties inside 'global' are read-only!";
return false;
}
if (subclass == QQSK::Subclass::QQStyleKitReader) {
// This is a write to a StyleKitReader, probably from an ongoing transition
QQStyleKitReader *reader = controlProperties->asQQStyleKitReader();
const PropertyStorageId key = propertyPath.createStorageId(QQSK::StateFlag::Normal);
const QVariant currentValue = reader->readStyleProperty(key);
const bool valueChanged = currentValue != value;
if (valueChanged) {
reader->writeStyleProperty(key, value);
QQStyleKitDebug::notifyPropertyWrite(group, property, reader, QQSK::StateFlag::Normal, key, value);
}
return valueChanged;
}
if (subclass == QQSK::Subclass::QQStyleKitState) {
// This is a write to a control inside the StyleKit style
const QQStyleKitControlState *controlState = controlProperties->asQQStyleKitState();
QQStyleKitControl *control = controlState->control();
const QQSK::State nestedState = controlState->nestedState();
const PropertyStorageId key = propertyPath.createStorageId(nestedState);
const QVariant currentValue = control->readStyleProperty(key);
const bool valueChanged = currentValue != value;
if (valueChanged) {
/* Optimization: Allow a control to track which states it stores property values for.
* When later reading a property via propagation, we can skip that control entirely
* if it has no stored values corresponding to the state requested by the StyleKitReader. */
control->m_writtenStates |= nestedState;
/* Optimization: Track which properties a style, theme, or variation defines
* values for, and for which states. When reading a property later, we can skip
* the style/theme/variation entirely if it has no stored values for it, or if
* none match the state requested by the StyleKitReader. */
QQStyleKitControls *controls = control->controls();
const QQSK::State alreadyWrittenStates = controls->m_writtenPropertyPaths[propertyPath.pathId()];
controls->m_writtenPropertyPaths[propertyPath.pathId()] = alreadyWrittenStates | nestedState;
control->writeStyleProperty(key, value);
QQStyleKitDebug::notifyPropertyWrite(group, property, control, nestedState, key, value);
}
return valueChanged;
}
Q_UNREACHABLE();
return false;
}
bool QQStyleKitPropertyResolver::hasLocalStyleProperty(
const QQStyleKitPropertyGroup *group,
const QQSK::Property property)
{
Q_ASSERT(group);
const QQStyleKitControlProperties *controlProperties = group->controlProperties();
const QQSK::PropertyPathFlags pathFlags = group->pathFlags();
const QQStyleKitPropertyPath propertyPath(group, property);
const QQSK::Subclass subclass = controlProperties->subclass();
if (pathFlags.testFlag(QQSK::PropertyPathFlag::Global))
return false;
if (subclass == QQSK::Subclass::QQStyleKitReader) {
const PropertyStorageId key = propertyPath.createStorageId(QQSK::StateFlag::Normal);
return controlProperties->asQQStyleKitReader()->readStyleProperty(key).isValid();
}
if (subclass == QQSK::Subclass::QQStyleKitState) {
const QQStyleKitControlState *controlState = controlProperties->asQQStyleKitState();
const QQStyleKitControl *control = controlState->control();
const PropertyStorageId key = propertyPath.createStorageId(controlState->nestedState());
return control->readStyleProperty(key).isValid();
}
Q_UNREACHABLE();
return false;
}
QT_END_NAMESPACE
#include "moc_qqstylekitpropertyresolver_p.cpp"