Revision control
Copy as Markdown
// 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
// Qt-Security score:significant reason:default
#include "qquickstategroup_p.h"
#include "qquicktransition_p.h"
#include <private/qqmlbinding_p.h>
#include <private/qqmlglobal_p.h>
#include <QtCore/qstringlist.h>
#include <QtCore/qdebug.h>
#include <QtCore/qvector.h>
#include <private/qobject_p.h>
#include <qqmlinfo.h>
QT_BEGIN_NAMESPACE
using namespace Qt::StringLiterals;
class QQuickStateGroupPrivate : public QObjectPrivate
{
Q_DECLARE_PUBLIC(QQuickStateGroup)
public:
QQuickStateGroupPrivate()
: nullState(nullptr), componentComplete(true),
ignoreTrans(false), applyingState(false), unnamedCount(0) {}
QString currentState;
QQuickState *nullState;
static void append_state(QQmlListProperty<QQuickState> *list, QQuickState *state);
static qsizetype count_state(QQmlListProperty<QQuickState> *list);
static QQuickState *at_state(QQmlListProperty<QQuickState> *list, qsizetype index);
static void clear_states(QQmlListProperty<QQuickState> *list);
static void replace_states(QQmlListProperty<QQuickState> *list, qsizetype index, QQuickState *state);
static void removeLast_states(QQmlListProperty<QQuickState> *list);
static void append_transition(QQmlListProperty<QQuickTransition> *list, QQuickTransition *state);
static qsizetype count_transitions(QQmlListProperty<QQuickTransition> *list);
static QQuickTransition *at_transition(QQmlListProperty<QQuickTransition> *list, qsizetype index);
static void clear_transitions(QQmlListProperty<QQuickTransition> *list);
QList<QQuickState *> states;
QList<QQuickTransition *> transitions;
bool componentComplete;
bool ignoreTrans;
bool applyingState;
int unnamedCount;
QQuickTransition *findTransition(const QString &from, const QString &to);
void setCurrentStateInternal(const QString &state, bool = false);
bool updateAutoState();
};
/*!
\qmltype StateGroup
\nativetype QQuickStateGroup
\inqmlmodule QtQuick
\ingroup qtquick-states
\brief Provides built-in state support for non-Item types.
Item (and all derived types) provides built in support for states and transitions
via its \l{Item::state}{state}, \l{Item::states}{states} and \l{Item::transitions}{transitions} properties. StateGroup provides an easy way to
use this support in other (non-Item-derived) types.
\qml
MyCustomObject {
StateGroup {
id: myStateGroup
states: State {
name: "state1"
// ...
}
transitions: Transition {
// ...
}
}
onSomethingHappened: myStateGroup.state = "state1";
}
\endqml
\sa {Qt Quick States}{Qt Quick States}, {Animation and Transitions in Qt Quick}{Transitions}, {Qt Qml}
*/
QQuickStateGroup::QQuickStateGroup(QObject *parent)
: QObject(*(new QQuickStateGroupPrivate), parent)
{
}
QQuickStateGroup::~QQuickStateGroup()
{
Q_D(const QQuickStateGroup);
for (QQuickState *state : std::as_const(d->states)) {
if (state)
state->setStateGroup(nullptr);
}
if (d->nullState)
d->nullState->setStateGroup(nullptr);
}
QList<QQuickState *> QQuickStateGroup::states() const
{
Q_D(const QQuickStateGroup);
return d->states;
}
/*!
\qmlproperty list<State> QtQuick::StateGroup::states
This property holds a list of states defined by the state group.
\qml
StateGroup {
states: [
State {
// State definition...
},
State {
// ...
}
// Other states...
]
}
\endqml
\sa {Qt Quick States}{Qt Quick States}
*/
QQmlListProperty<QQuickState> QQuickStateGroup::statesProperty()
{
Q_D(QQuickStateGroup);
return QQmlListProperty<QQuickState>(this, &d->states,
&QQuickStateGroupPrivate::append_state,
&QQuickStateGroupPrivate::count_state,
&QQuickStateGroupPrivate::at_state,
&QQuickStateGroupPrivate::clear_states,
&QQuickStateGroupPrivate::replace_states,
&QQuickStateGroupPrivate::removeLast_states);
}
void QQuickStateGroupPrivate::append_state(QQmlListProperty<QQuickState> *list, QQuickState *state)
{
QQuickStateGroup *_this = static_cast<QQuickStateGroup *>(list->object);
_this->d_func()->states.append(state);
if (state)
state->setStateGroup(_this);
}
qsizetype QQuickStateGroupPrivate::count_state(QQmlListProperty<QQuickState> *list)
{
QQuickStateGroup *_this = static_cast<QQuickStateGroup *>(list->object);
return _this->d_func()->states.size();
}
QQuickState *QQuickStateGroupPrivate::at_state(QQmlListProperty<QQuickState> *list, qsizetype index)
{
QQuickStateGroup *_this = static_cast<QQuickStateGroup *>(list->object);
return _this->d_func()->states.at(index);
}
void QQuickStateGroupPrivate::clear_states(QQmlListProperty<QQuickState> *list)
{
QQuickStateGroupPrivate *d = static_cast<QQuickStateGroup *>(list->object)->d_func();
d->setCurrentStateInternal(QString(), true);
for (QQuickState *state : std::as_const(d->states)) {
if (state)
state->setStateGroup(nullptr);
}
d->states.clear();
}
void QQuickStateGroupPrivate::replace_states(QQmlListProperty<QQuickState> *list, qsizetype index, QQuickState *state)
{
auto *self = static_cast<QQuickStateGroup *>(list->object);
auto *d = self->d_func();
auto *oldState = d->states.at(index);
if (oldState != state) {
if (oldState)
oldState->setStateGroup(nullptr);
if (state)
state->setStateGroup(self);
d->states.replace(index, state);
if (!oldState || d->currentState == oldState->name())
d->setCurrentStateInternal(state ? state->name() : QString(), true);
}
}
void QQuickStateGroupPrivate::removeLast_states(QQmlListProperty<QQuickState> *list)
{
auto *d = static_cast<QQuickStateGroup *>(list->object)->d_func();
if (QQuickState *last = d->states.last()) {
if (d->currentState == last->name()) {
QQuickState *first = d->states.size() > 1 ? d->states.first() : nullptr;
d->setCurrentStateInternal(first ? first->name() : QString(), true);
}
last->setStateGroup(nullptr);
}
d->states.removeLast();
}
/*!
\qmlproperty list<Transition> QtQuick::StateGroup::transitions
This property holds a list of transitions defined by the state group.
\qml
StateGroup {
transitions: [
Transition {
// ...
},
Transition {
// ...
}
// ...
]
}
\endqml
\sa {Animation and Transitions in Qt Quick}{Transitions}
*/
QQmlListProperty<QQuickTransition> QQuickStateGroup::transitionsProperty()
{
Q_D(QQuickStateGroup);
return QQmlListProperty<QQuickTransition>(this, &d->transitions, &QQuickStateGroupPrivate::append_transition,
&QQuickStateGroupPrivate::count_transitions,
&QQuickStateGroupPrivate::at_transition,
&QQuickStateGroupPrivate::clear_transitions);
}
void QQuickStateGroupPrivate::append_transition(QQmlListProperty<QQuickTransition> *list, QQuickTransition *trans)
{
QQuickStateGroup *_this = static_cast<QQuickStateGroup *>(list->object);
if (trans)
_this->d_func()->transitions.append(trans);
}
qsizetype QQuickStateGroupPrivate::count_transitions(QQmlListProperty<QQuickTransition> *list)
{
QQuickStateGroup *_this = static_cast<QQuickStateGroup *>(list->object);
return _this->d_func()->transitions.size();
}
QQuickTransition *QQuickStateGroupPrivate::at_transition(QQmlListProperty<QQuickTransition> *list, qsizetype index)
{
QQuickStateGroup *_this = static_cast<QQuickStateGroup *>(list->object);
return _this->d_func()->transitions.at(index);
}
void QQuickStateGroupPrivate::clear_transitions(QQmlListProperty<QQuickTransition> *list)
{
QQuickStateGroup *_this = static_cast<QQuickStateGroup *>(list->object);
_this->d_func()->transitions.clear();
}
/*!
\qmlproperty string QtQuick::StateGroup::state
This property holds the name of the current state of the state group.
This property is often used in scripts to change between states. For
example:
\qml
function toggle() {
if (button.state == 'On')
button.state = 'Off';
else
button.state = 'On';
}
\endqml
If the state group is in its base state (i.e. no explicit state has been
set), \c state will be a blank string. Likewise, you can return a
state group to its base state by setting its current state to \c ''.
\sa {Qt Quick States}{Qt Quick States}
*/
QString QQuickStateGroup::state() const
{
Q_D(const QQuickStateGroup);
return d->currentState;
}
void QQuickStateGroup::setState(const QString &state)
{
Q_D(QQuickStateGroup);
if (d->currentState == state)
return;
d->setCurrentStateInternal(state);
}
void QQuickStateGroup::classBegin()
{
Q_D(QQuickStateGroup);
d->componentComplete = false;
}
void QQuickStateGroup::componentComplete()
{
Q_D(QQuickStateGroup);
d->componentComplete = true;
QVarLengthArray<QString, 4> names;
names.reserve(d->states.size());
for (QQuickState *state : std::as_const(d->states)) {
if (!state)
continue;
if (!state->isNamed())
state->setName(QLatin1String("anonymousState") + QString::number(++d->unnamedCount));
QString stateName = state->name();
if (names.contains(stateName))
qmlWarning(state->parent()) << "Found duplicate state name: " << stateName;
else
names.append(std::move(stateName));
}
if (d->updateAutoState()) {
return;
} else if (!d->currentState.isEmpty()) {
QString cs = d->currentState;
d->currentState.clear();
d->setCurrentStateInternal(cs, true);
}
}
/*!
Returns true if the state was changed, otherwise false.
*/
bool QQuickStateGroup::updateAutoState()
{
Q_D(QQuickStateGroup);
return d->updateAutoState();
}
bool QQuickStateGroupPrivate::updateAutoState()
{
Q_Q(QQuickStateGroup);
if (!componentComplete)
return false;
bool revert = false;
for (QQuickState *state : std::as_const(states)) {
if (!state || !state->isWhenKnown() || !state->isNamed())
continue;
bool whenValue = state->when();
const QQmlPropertyIndex whenIndex(state->metaObject()->indexOfProperty("when"));
const auto potentialWhenBinding = QQmlAnyBinding::ofProperty(state, whenIndex);
Q_ASSERT(!potentialWhenBinding.isUntypedPropertyBinding());
// if there is a binding, the value in when might not be up-to-date at this point
// so we manually re-evaluate the binding
QQmlAbstractBinding *abstractBinding = potentialWhenBinding.asAbstractBinding();
if (abstractBinding && abstractBinding->kind() == QQmlAbstractBinding::QmlBinding) {
QQmlBinding *binding = static_cast<QQmlBinding *>(abstractBinding);
if (binding->hasValidContext()) {
const auto boolType = QMetaType::fromType<bool>();
const bool isUndefined = !binding->evaluate(&whenValue, boolType);
if (isUndefined)
whenValue = false;
}
}
if (whenValue) {
qCDebug(lcStates) << "Setting auto state due to expression";
if (currentState != state->name()) {
q->setState(state->name());
return true;
} else {
return false;
}
} else if (state->name() == currentState) {
revert = true;
}
}
if (revert) {
bool rv = !currentState.isEmpty();
q->setState(QString());
return rv;
} else {
return false;
}
}
QQuickTransition *QQuickStateGroupPrivate::findTransition(const QString &from, const QString &to)
{
QQuickTransition *highest = nullptr;
int score = 0;
bool reversed = false;
bool done = false;
for (int ii = 0; !done && ii < transitions.size(); ++ii) {
QQuickTransition *t = transitions.at(ii);
if (!t->enabled())
continue;
for (int ii = 0; ii < 2; ++ii)
{
if (ii && (!t->reversible() ||
(t->fromState() == QLatin1String("*") &&
t->toState() == QLatin1String("*"))))
break;
const QString fromStateStr = t->fromState();
const QString toStateStr = t->toState();
auto fromState = QStringView{fromStateStr}.split(QLatin1Char(','));
for (int jj = 0; jj < fromState.size(); ++jj)
fromState[jj] = fromState.at(jj).trimmed();
auto toState = QStringView{toStateStr}.split(QLatin1Char(','));
for (int jj = 0; jj < toState.size(); ++jj)
toState[jj] = toState.at(jj).trimmed();
if (ii == 1)
qSwap(fromState, toState);
int tScore = 0;
const QString asterisk = QStringLiteral("*");
if (fromState.contains(QStringView(from)))
tScore += 2;
else if (fromState.contains(QStringView(asterisk)))
tScore += 1;
else
continue;
if (toState.contains(QStringView(to)))
tScore += 2;
else if (toState.contains(QStringView(asterisk)))
tScore += 1;
else
continue;
if (ii == 1)
reversed = true;
else
reversed = false;
if (tScore == 4) {
highest = t;
done = true;
break;
} else if (tScore > score) {
score = tScore;
highest = t;
}
}
}
if (highest)
highest->setReversed(reversed);
return highest;
}
void QQuickStateGroupPrivate::setCurrentStateInternal(const QString &state,
bool ignoreTrans)
{
Q_Q(QQuickStateGroup);
if (!componentComplete) {
currentState = state;
return;
}
if (applyingState) {
qmlWarning(q) << "Can't apply a state change as part of a state definition.";
return;
}
applyingState = true;
QQuickTransition *transition = ignoreTrans ? nullptr : findTransition(currentState, state);
if (lcStates().isDebugEnabled()) {
qCDebug(lcStates) << this << "changing state from:" << currentState << "to:" << state;
if (transition)
qCDebug(lcStates) << " using transition" << transition->fromState()
<< transition->toState();
}
QQuickState *oldState = nullptr;
if (!currentState.isEmpty()) {
for (QQuickState *state : std::as_const(states)) {
if (state && state->name() == currentState) {
oldState = state;
break;
}
}
}
currentState = state;
emit q->stateChanged(currentState);
QQuickState *newState = nullptr;
for (QQuickState *state : std::as_const(states)) {
if (state && state->name() == currentState) {
newState = state;
break;
}
}
if (oldState == nullptr || newState == nullptr) {
if (!nullState) {
nullState = new QQuickState;
QQml_setParent_noEvent(nullState, q);
nullState->setStateGroup(q);
}
if (!oldState) oldState = nullState;
if (!newState) newState = nullState;
}
newState->apply(transition, oldState);
applyingState = false; //### consider removing this (don't allow state changes in transition)
}
QQuickState *QQuickStateGroup::findState(const QString &name) const
{
Q_D(const QQuickStateGroup);
for (QQuickState *state : std::as_const(d->states)) {
if (state && state->name() == name)
return state;
}
return nullptr;
}
void QQuickStateGroup::removeState(QQuickState *state)
{
Q_D(QQuickStateGroup);
d->states.removeOne(state);
}
void QQuickStateGroup::stateAboutToComplete()
{
Q_D(QQuickStateGroup);
d->applyingState = false;
}
QT_END_NAMESPACE
#include "moc_qquickstategroup_p.cpp"