diff options
44 files changed, 3629 insertions, 3 deletions
diff --git a/src/imports/imports.pro b/src/imports/imports.pro index f1d262a6c3..d0d47aa38c 100644 --- a/src/imports/imports.pro +++ b/src/imports/imports.pro @@ -4,7 +4,8 @@ SUBDIRS += \ folderlistmodel \ localstorage \ models \ - settings + settings \ + statemachine qtHaveModule(quick) { SUBDIRS += \ diff --git a/src/imports/statemachine/childrenprivate.h b/src/imports/statemachine/childrenprivate.h new file mode 100644 index 0000000000..7e7b7f37ef --- /dev/null +++ b/src/imports/statemachine/childrenprivate.h @@ -0,0 +1,108 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQMLCHILDRENPRIVATE_H +#define QQMLCHILDRENPRIVATE_H + +#include <QAbstractState> +#include <QAbstractTransition> +#include <QStateMachine> +#include <QQmlInfo> +#include <QQmlListProperty> + +template <class T> +class ChildrenPrivate +{ +public: + ChildrenPrivate() + {} + + static void append(QQmlListProperty<QObject> *prop, QObject *item) + { + QAbstractState *state = qobject_cast<QAbstractState*>(item); + if (state) { + if (qobject_cast<QStateMachine*>(item)) + qmlInfo(static_cast<T *>(prop->object)) << "StateMachines should not be nested."; + + item->setParent(prop->object); + } else { + QAbstractTransition *trans = qobject_cast<QAbstractTransition*>(item); + if (trans) + static_cast<T *>(prop->object)->addTransition(trans); + } + static_cast<ChildrenPrivate<T>*>(prop->data)->children.append(item); + emit static_cast<T *>(prop->object)->childrenChanged(); + } + + static void appendNoTransition(QQmlListProperty<QObject> *prop, QObject *item) + { + QAbstractState *state = qobject_cast<QAbstractState*>(item); + if (state) { + if (qobject_cast<QStateMachine*>(item)) + qmlInfo(static_cast<T *>(prop->object)) << "StateMachines should not be nested."; + + item->setParent(prop->object); + } + static_cast<ChildrenPrivate<T>*>(prop->data)->children.append(item); + emit static_cast<T *>(prop->object)->childrenChanged(); + } + + static int count(QQmlListProperty<QObject> *prop) + { + return static_cast<ChildrenPrivate<T>*>(prop->data)->children.count(); + } + + static QObject *at(QQmlListProperty<QObject> *prop, int index) + { + return static_cast<ChildrenPrivate<T>*>(prop->data)->children.at(index); + } + + static void clear(QQmlListProperty<QObject> *prop) + { + static_cast<ChildrenPrivate<T>*>(prop->data)->children.clear(); + emit static_cast<T *>(prop->object)->childrenChanged(); + } + +private: + QList<QObject *> children; +}; + +#endif diff --git a/src/imports/statemachine/finalstate.cpp b/src/imports/statemachine/finalstate.cpp new file mode 100644 index 0000000000..1852a533c6 --- /dev/null +++ b/src/imports/statemachine/finalstate.cpp @@ -0,0 +1,85 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "finalstate.h" + +#include <QQmlContext> +#include <QQmlEngine> +#include <QQmlInfo> + +FinalState::FinalState(QState *parent) + : QFinalState(parent) +{ +} + +QQmlListProperty<QObject> FinalState::children() +{ + return QQmlListProperty<QObject>(this, &m_children, m_children.appendNoTransition, m_children.count, m_children.at, m_children.clear); +} + +/*! + \qmltype FinalState + \inqmlmodule QtStateMachine 1.0 + \inherits QAbstractState + \ingroup qmlstatemachine + \since 5.4 + + \brief Provides a final state. + + + A final state is used to communicate that (part of) a StateMachine has + finished its work. When a final top-level state is entered, the state + machine's \l{StateBase::finished}{finished}() signal is emitted. In + general, when a final substate (a child of a State) is entered, the parent + state's \l{StateBase::finished}{finished}() signal is emitted. FinalState + is part of \l{The Declarative State Machine Framework}. + + To use a final state, you create a FinalState object and add a transition + to it from another state. + + \section1 Example Usage + + \snippet qml/statemachine/finalstate.qml document + + \clearfloat + + \sa StateMachine, StateBase +*/ diff --git a/src/imports/statemachine/finalstate.h b/src/imports/statemachine/finalstate.h new file mode 100644 index 0000000000..6086b1b8a2 --- /dev/null +++ b/src/imports/statemachine/finalstate.h @@ -0,0 +1,73 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQMLFINALSTATE_H +#define QQMLFINALSTATE_H + +#include "childrenprivate.h" +#include "statemachine.h" + +#include <QtCore/QFinalState> +#include <QtQml/QQmlListProperty> + + +QT_BEGIN_NAMESPACE + +class FinalState : public QFinalState +{ + Q_OBJECT + Q_PROPERTY(QQmlListProperty<QObject> children READ children NOTIFY childrenChanged) + Q_CLASSINFO("DefaultProperty", "children") + +public: + explicit FinalState(QState *parent = 0); + + QQmlListProperty<QObject> children(); + +Q_SIGNALS: + void childrenChanged(); + +private: + ChildrenPrivate<FinalState> m_children; +}; + +QT_END_NAMESPACE +#endif diff --git a/src/imports/statemachine/plugin.cpp b/src/imports/statemachine/plugin.cpp new file mode 100644 index 0000000000..2a266f9dfb --- /dev/null +++ b/src/imports/statemachine/plugin.cpp @@ -0,0 +1,77 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the plugins of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "finalstate.h" +#include "signaltransition.h" +#include "statebase.h" +#include "statemachine.h" +#include "timeouttransition.h" + +#include <QHistoryState> +#include <QQmlExtensionPlugin> +#include <qqml.h> + +QT_BEGIN_NAMESPACE + +class QtQmlStateMachinePlugin : public QQmlExtensionPlugin +{ + Q_OBJECT + Q_PLUGIN_METADATA(IID "org.qt-project.org.Qt.QtQml.StateMachine/1.0") + +public: + void registerTypes(const char *uri) + { + qmlRegisterType<StateBase>(uri, 1, 0, "StateBase"); + qmlRegisterType<StateMachine>(uri, 1, 0, "StateMachine"); + qmlRegisterType<QHistoryState>(uri, 1, 0, "HistoryState"); + qmlRegisterType<FinalState>(uri, 1, 0, "FinalState"); + qmlRegisterUncreatableType<QState>(uri, 1, 0, "QState", "Don't use this, use StateBase instead"); + qmlRegisterUncreatableType<QAbstractState>(uri, 1, 0, "QAbstractState", "Don't use this, use StateBase instead"); + qmlRegisterUncreatableType<QSignalTransition>(uri, 1, 0, "QSignalTransition", "Don't use this, use SignalTransition instead"); + qmlRegisterType<SignalTransition>(uri, 1, 0, "SignalTransition"); + qmlRegisterType<TimeoutTransition>(uri, 1, 0, "TimeoutTransition"); + qmlProtectModule(uri, 1); + } +}; + +QT_END_NAMESPACE + +#include "plugin.moc" diff --git a/src/imports/statemachine/plugins.qmltypes b/src/imports/statemachine/plugins.qmltypes new file mode 100644 index 0000000000..a53d68f8e8 --- /dev/null +++ b/src/imports/statemachine/plugins.qmltypes @@ -0,0 +1,163 @@ +import QtQuick.tooling 1.1 + +// This file describes the plugin-supplied types contained in the library. +// It is used for QML tooling purposes only. +// +// This file was auto-generated by: +// 'qmlplugindump -nonrelocatable QtQml.StateMachine 1.0' + +Module { + Component { + name: "FinalState" + defaultProperty: "children" + prototype: "QFinalState" + exports: ["QtQml.StateMachine/FinalState 1.0"] + exportMetaObjectRevisions: [0] + Property { name: "children"; type: "QObject"; isList: true; isReadonly: true } + } + Component { + name: "QAbstractState" + prototype: "QObject" + exports: ["QtQml.StateMachine/QAbstractState 1.0"] + isCreatable: false + exportMetaObjectRevisions: [0] + Property { name: "active"; type: "bool"; isReadonly: true } + Signal { name: "entered" } + Signal { name: "exited" } + Signal { + name: "activeChanged" + Parameter { name: "active"; type: "bool" } + } + } + Component { + name: "QAbstractTransition" + prototype: "QObject" + Property { name: "sourceState"; type: "QState"; isReadonly: true; isPointer: true } + Property { name: "targetState"; type: "QAbstractState"; isPointer: true } + Property { name: "targetStates"; type: "QList<QAbstractState*>" } + Signal { name: "triggered" } + } + Component { name: "QFinalState"; prototype: "QAbstractState" } + Component { + name: "QHistoryState" + prototype: "QAbstractState" + exports: ["QtQml.StateMachine/HistoryState 1.0"] + exportMetaObjectRevisions: [0] + Enum { + name: "HistoryType" + values: { + "ShallowHistory": 0, + "DeepHistory": 1 + } + } + Property { name: "defaultState"; type: "QAbstractState"; isPointer: true } + Property { name: "historyType"; type: "HistoryType" } + } + Component { + name: "QSignalTransition" + prototype: "QAbstractTransition" + exports: ["QtQml.StateMachine/QSignalTransition 1.0"] + isCreatable: false + exportMetaObjectRevisions: [0] + Property { name: "senderObject"; type: "QObject"; isPointer: true } + Property { name: "signal"; type: "QByteArray" } + } + Component { + name: "QState" + prototype: "QAbstractState" + exports: ["QtQml.StateMachine/QState 1.0"] + isCreatable: false + exportMetaObjectRevisions: [0] + Enum { + name: "ChildMode" + values: { + "ExclusiveStates": 0, + "ParallelStates": 1 + } + } + Enum { + name: "RestorePolicy" + values: { + "DontRestoreProperties": 0, + "RestoreProperties": 1 + } + } + Property { name: "initialState"; type: "QAbstractState"; isPointer: true } + Property { name: "errorState"; type: "QAbstractState"; isPointer: true } + Property { name: "childMode"; type: "ChildMode" } + Signal { name: "finished" } + Signal { name: "propertiesAssigned" } + } + Component { + name: "QStateMachine" + prototype: "QState" + Property { name: "errorString"; type: "string"; isReadonly: true } + Property { name: "globalRestorePolicy"; type: "QState::RestorePolicy" } + Property { name: "running"; type: "bool" } + Property { name: "animated"; type: "bool" } + Signal { name: "started" } + Signal { name: "stopped" } + Signal { + name: "runningChanged" + Parameter { name: "running"; type: "bool" } + } + Method { name: "start" } + Method { name: "stop" } + Method { + name: "setRunning" + Parameter { name: "running"; type: "bool" } + } + } + Component { + name: "QTimer" + prototype: "QObject" + Property { name: "singleShot"; type: "bool" } + Property { name: "interval"; type: "int" } + Property { name: "remainingTime"; type: "int"; isReadonly: true } + Property { name: "timerType"; type: "Qt::TimerType" } + Property { name: "active"; type: "bool"; isReadonly: true } + Signal { name: "timeout" } + Method { + name: "start" + Parameter { name: "msec"; type: "int" } + } + Method { name: "start" } + Method { name: "stop" } + } + Component { + name: "SignalTransition" + prototype: "QSignalTransition" + exports: ["QtQml.StateMachine/SignalTransition 1.0"] + exportMetaObjectRevisions: [0] + Property { name: "signal"; type: "QJSValue" } + Property { name: "guard"; type: "bool" } + Signal { name: "invokeYourself" } + Signal { name: "qmlSignalChanged" } + Method { name: "invoke" } + } + Component { + name: "StateBase" + defaultProperty: "children" + prototype: "QState" + exports: ["QtQml.StateMachine/StateBase 1.0"] + exportMetaObjectRevisions: [0] + Property { name: "children"; type: "QObject"; isList: true; isReadonly: true } + } + Component { + name: "StateMachine" + defaultProperty: "children" + prototype: "QStateMachine" + exports: ["QtQml.StateMachine/StateMachine 1.0"] + exportMetaObjectRevisions: [0] + Property { name: "children"; type: "QObject"; isList: true; isReadonly: true } + Property { name: "running"; type: "bool" } + Signal { name: "qmlRunningChanged" } + } + Component { + name: "TimeoutTransition" + prototype: "QSignalTransition" + exports: ["QtQml.StateMachine/TimeoutTransition 1.0"] + exportMetaObjectRevisions: [0] + Property { name: "timeout"; type: "int" } + } +} diff --git a/src/imports/statemachine/qmldir b/src/imports/statemachine/qmldir new file mode 100644 index 0000000000..8bc3831208 --- /dev/null +++ b/src/imports/statemachine/qmldir @@ -0,0 +1,4 @@ +module QtQml.StateMachine +plugin qtqmlstatemachine +classname QtQmlStateMachinePlugin +typeinfo plugins.qmltypes diff --git a/src/imports/statemachine/signaltransition.cpp b/src/imports/statemachine/signaltransition.cpp new file mode 100644 index 0000000000..c3dc183472 --- /dev/null +++ b/src/imports/statemachine/signaltransition.cpp @@ -0,0 +1,238 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "signaltransition.h" + +#include <QStateMachine> +#include <QMetaProperty> +#include <QQmlInfo> +#include <QQmlEngine> +#include <QQmlContext> + +#include <private/qv4qobjectwrapper_p.h> +#include <private/qv8engine_p.h> +#include <private/qjsvalue_p.h> +#include <private/qv4scopedvalue_p.h> + +SignalTransition::SignalTransition(QState *parent) + : QSignalTransition(this, SIGNAL(invokeYourself()), parent) + , m_guard(true) +{ + connect(this, SIGNAL(signalChanged()), SIGNAL(qmlSignalChanged())); +} + +bool SignalTransition::eventTest(QEvent *event) +{ + Q_ASSERT(event); + if (!QSignalTransition::eventTest(event)) + return false; + + return m_guard; +} + +const QJSValue& SignalTransition::signal() +{ + return m_signal; +} + +void SignalTransition::setSignal(const QJSValue &signal) +{ + if (m_signal.strictlyEquals(signal)) + return; + + m_signal = signal; + + QV4::ExecutionEngine *jsEngine = QV8Engine::getV4(QQmlEngine::contextForObject(this)->engine()); + QV4::Scope scope(jsEngine); + + QV4::Scoped<QV4::FunctionObject> function(scope, QJSValuePrivate::get(m_signal)->getValue(jsEngine)); + Q_ASSERT(function); + + QV4::Scoped<QV4::QObjectMethod> qobjectSignal(scope, function->as<QV4::QObjectMethod>()); + Q_ASSERT(qobjectSignal); + + QObject *sender = qobjectSignal->object(); + Q_ASSERT(sender); + QMetaMethod metaMethod = sender->metaObject()->method(qobjectSignal->methodIndex()); + + QSignalTransition::setSenderObject(sender); + QSignalTransition::setSignal(metaMethod.methodSignature()); +} + +bool SignalTransition::guard() const +{ + return m_guard; +} + +void SignalTransition::setGuard(bool guard) +{ + if (guard != m_guard) { + m_guard = guard; + emit guardChanged(); + } +} + +void SignalTransition::invoke() +{ + emit invokeYourself(); +} + +/*! + \qmltype QAbstractTransition + \inqmlmodule QtStateMachine 1.0 + \ingroup qmlstatemachine + \since 5.4 + + \brief The QAbstractTransition type is the base type of transitions between QAbstractState objects. + + The QAbstractTransition type is the abstract base type of transitions + between states (QAbstractState objects) of a StateMachine. + QAbstractTransition is part of \l{The Declarative State Machine Framework}. + + The sourceState() property has the source of the transition. The + targetState and targetStates properties return the target(s) of the + transition. + + The triggered() signal is emitted when the transition has been triggered. + + Do not use QAbstractTransition directly; use SignalTransition or + TimeoutTransition instead. + + \sa SignalTransition, TimeoutTransition +*/ + +/*! + \qmlproperty bool QAbstractTransition::sourceState + \readonly sourceState + + \brief The source state (parent) of this transition. +*/ + +/*! + \qmlproperty QAbstractState QAbstractTransition::targetState + + \brief The target state of this transition. + + If a transition has no target state, the transition may still be + triggered, but this will not cause the state machine's configuration to + change (i.e. the current state will not be exited and re-entered). +*/ + +/*! + \qmlproperty list<QAbstractState> QAbstractTransition::targetStates + + \brief The target states of this transition. + + If multiple states are specified, they all must be descendants of the + same parallel group state. +*/ + +/*! + \qmlsignal QAbstractTransition::triggered() + + This signal is emitted when the transition has been triggered. + + The corresponding handler is \c onTriggered. +*/ + +/*! + \qmltype QSignalTransition + \inqmlmodule QtStateMachine 1.0 + \inherits QAbstractTransition + \ingroup qmlstatemachine + \since 5.4 + + \brief The QSignalTransition type provides a transition based on a Qt signal. + + Do not use QSignalTransition directly; use SignalTransition or + TimeoutTransition instead. + + \sa SignalTransition, TimeoutTransition +*/ + +/*! + \qmlproperty string QSignalTransition::signal + + \brief The signal which is associated with this signal transition. +*/ + +/*! + \qmlproperty QObject QSignalTransition::senderObject + + \brief The sender object which is associated with this signal transition. +*/ + + +/*! + \qmltype SignalTransition + \inqmlmodule QtStateMachine 1.0 + \inherits QSignalTransition + \ingroup qmlstatemachine + \since 5.4 + + \brief The SignalTransition type provides a transition based on a Qt signal. + + SignalTransition is part of \l{The Declarative State Machine Framework}. + + \section1 Example Usage + + \snippet qml/statemachine/signaltransition.qml document + + \clearfloat + + \sa StateMachine, FinalState, TimeoutTransition +*/ + +/*! + \qmlproperty signal SignalTransition::signal + + \brief The signal which is associated with this signal transition. + + \snippet qml/statemachine/signaltransitionsignal.qml document +*/ + +/*! + \qmlproperty bool SignalTransition::guard + + Guard conditions affect the behavior of a state machine by enabling + transitions only when they evaluate to true and disabling them when + they evaluate to false. +*/ diff --git a/src/imports/statemachine/signaltransition.h b/src/imports/statemachine/signaltransition.h new file mode 100644 index 0000000000..614a6064a5 --- /dev/null +++ b/src/imports/statemachine/signaltransition.h @@ -0,0 +1,86 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef SIGNALTRANSITION_H +#define SIGNALTRANSITION_H + +#include <QtCore/QSignalTransition> +#include <QtCore/QVariant> +#include <QtQml/QJSValue> + +QT_BEGIN_NAMESPACE + +class SignalTransition : public QSignalTransition +{ + Q_OBJECT + Q_PROPERTY(QJSValue signal READ signal WRITE setSignal NOTIFY qmlSignalChanged) + Q_PROPERTY(bool guard READ guard WRITE setGuard NOTIFY guardChanged) + +public: + explicit SignalTransition(QState *parent = Q_NULLPTR); + + bool guard() const; + void setGuard(bool guard); + + bool eventTest(QEvent *event); + + const QJSValue &signal(); + void setSignal(const QJSValue &signal); + + Q_INVOKABLE void invoke(); + +Q_SIGNALS: + void guardChanged(); + void invokeYourself(); + /*! + * \internal + */ + void qmlSignalChanged(); + +private: + QByteArray m_data; + QJSValue m_signal; + bool m_guard; +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/imports/statemachine/statebase.cpp b/src/imports/statemachine/statebase.cpp new file mode 100644 index 0000000000..fa475df604 --- /dev/null +++ b/src/imports/statemachine/statebase.cpp @@ -0,0 +1,244 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "statebase.h" + +#include <QQmlContext> +#include <QQmlEngine> +#include <QQmlInfo> + +StateBase::StateBase(QState *parent) + : QState(parent) +{ +} + +void StateBase::componentComplete() +{ + if (this->machine() == NULL) { + static bool once = false; + if (!once) { + once = true; + qmlInfo(this) << "No top level StateMachine found. Nothing will run without a StateMachine."; + } + } +} + +QQmlListProperty<QObject> StateBase::children() +{ + return QQmlListProperty<QObject>(this, &m_children, m_children.append, m_children.count, m_children.at, m_children.clear); +} + +/*! + \qmltype QAbstractState + \inqmlmodule QtStateMachine 1.0 + \ingroup qmlstatemachine + \since 5.4 + + \brief The QAbstractState type is the base type of States of a StateMachine. + + Do not use QAbstractState directly; use StateBase, FinalState or + StateMachine instead. + + \sa StateMachine, StateBase +*/ + +/*! + \qmlproperty bool QAbstractState::active + \readonly active + + The active property of this state. A state is active between + entered() and exited() signals. This property is readonly. + + \sa entered, exited +*/ + +/*! + \qmlsignal QAbstractState::entered() + + This signal is emitted when the State becomes active. + + The corresponding handler is \c onEntered. + + \sa active, exited +*/ + +/*! + \qmlsignal QAbstractState::exited() + + This signal is emitted when the State becomes inactive. + + The corresponding handler is \c onExited. + + \sa active, entered +*/ + +/*! + \qmltype StateBase + \inqmlmodule QtStateMachine 1.0 + \inherits QAbstractState + \ingroup qmlstatemachine + \since 5.4 + + \brief Provides a general-purpose state for StateMachine. + + + StateBase objects can have child states as well as transitions to other + states. StateBase is part of \l{The Declarative State Machine Framework}. + + \section1 States with Child States + + The childMode property determines how child states are treated. For + non-parallel state groups, the initialState property must be used to + set the initial state. The child states are mutually exclusive states, + and the state machine needs to know which child state to enter when the + parent state is the target of a transition. + + The state emits the StateBase::finished() signal when a final child state + (FinalState) is entered. + + The errorState sets the state's error state. The error state is the state + that the state machine will transition to if an error is detected when + attempting to enter the state (e.g. because no initial state has been set). + + \section1 Example Usage + + \snippet qml/statemachine/basicstate.qml document + + \clearfloat + + \sa StateMachine, FinalState +*/ + +/*! + \qmlproperty enumeration StateBase::childMode + + \brief The child mode of this state + + The default value of this property is QState.ExclusiveStates. + + This enum specifies how a state's child states are treated: + \list + \li QState.ExclusiveStates The child states are mutually exclusive and an initial state must be set by setting initialState property. + \li QState.ParallelStates The child states are parallel. When the parent state is entered, all its child states are entered in parallel. + \endlist +*/ + +/*! + \qmlproperty QAbstractState StateBase::errorState + + \brief The error state of this state. +*/ + +/*! + \qmlproperty QAbstractState StateBase::initialState + + \brief The initial state of this state (one of its child states). +*/ + +/*! + \qmlsignal StateBase::finished() + + This signal is emitted when a final child state of this state is entered. + + The corresponding handler is \c onFinished. + + \sa QAbstractState::active, QAbstractState::entered, QAbstractState::exited +*/ + +/*! + \qmltype HistoryState + \inqmlmodule QtStateMachine 1.0 + \inherits QAbstractState + \ingroup qmlstatemachine + \since 5.4 + + \brief The HistoryState type provides a means of returning to a previously active substate. + + A history state is a pseudo-state that represents the child state that the + parent state was in the last time the parent state was exited. A transition + with a history state as its target is in fact a transition to one of the + other child states of the parent state. + HistoryState is part of \l{The Declarative State Machine Framework}. + + Use the defaultState property to set the state that should be entered + if the parent state has never been entered. + + \section1 Example Usage + + \snippet qml/statemachine/historystate.qml document + + \clearfloat + + By default, a history state is shallow, meaning that it will not remember + nested states. This can be configured through the historyType property. + + \sa StateMachine, StateBase +*/ + +/*! + \qmlproperty QAbstractState HistoryState::defaultState + + \brief The default state of this history state. + + The default state indicates the state to transition to if the parent + state has never been entered before. +*/ + +/*! + \qmlproperty enumeration HistoryState::historyType + + \brief The type of history that this history state records. + + The default value of this property is QHistoryState.ShallowHistory. + + This enum specifies the type of history that a QHistoryState records. + \list + \li QHistoryState.ShallowHistory Only the immediate child states of the + parent state are recorded. In this case, a transition with the history + state as its target will end up in the immediate child state that the + parent was in the last time it was exited. This is the default. + \li QHistoryState.DeepHistory Nested states are recorded. In this case + a transition with the history state as its target will end up in the + most deeply nested descendant state the parent was in the last time + it was exited. + \endlist +*/ + diff --git a/src/imports/statemachine/statebase.h b/src/imports/statemachine/statebase.h new file mode 100644 index 0000000000..e3084238ef --- /dev/null +++ b/src/imports/statemachine/statebase.h @@ -0,0 +1,77 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef STATE_H +#define STATE_H + +#include "childrenprivate.h" + +#include <QtCore/QState> +#include <QtQml/QQmlParserStatus> +#include <QtQml/QQmlListProperty> + +QT_BEGIN_NAMESPACE + +class StateBase : public QState, public QQmlParserStatus +{ + Q_OBJECT + Q_INTERFACES(QQmlParserStatus) + Q_PROPERTY(QQmlListProperty<QObject> children READ children NOTIFY childrenChanged) + Q_CLASSINFO("DefaultProperty", "children") + +public: + explicit StateBase(QState *parent = 0); + + void classBegin() {} + void componentComplete(); + + QQmlListProperty<QObject> children(); + +Q_SIGNALS: + void childrenChanged(); + +private: + ChildrenPrivate<StateBase> m_children; +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/imports/statemachine/statemachine.cpp b/src/imports/statemachine/statemachine.cpp new file mode 100644 index 0000000000..31d98b7094 --- /dev/null +++ b/src/imports/statemachine/statemachine.cpp @@ -0,0 +1,223 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "statemachine.h" + +#include <QAbstractTransition> +#include <QQmlContext> +#include <QQmlEngine> +#include <QQmlInfo> + +#include <private/qqmlopenmetaobject_p.h> +#include <private/qqmlengine_p.h> + +StateMachine::StateMachine(QObject *parent) + : QStateMachine(parent), m_completed(false), m_running(false) +{ + connect(this, SIGNAL(runningChanged(bool)), SIGNAL(qmlRunningChanged())); +} + +bool StateMachine::isRunning() const +{ + return QStateMachine::isRunning(); +} + +void StateMachine::setRunning(bool running) +{ + if (m_completed) + QStateMachine::setRunning(running); + else + m_running = running; +} + +void StateMachine::componentComplete() +{ + if (QStateMachine::initialState() == NULL && childMode() == QState::ExclusiveStates) + qmlInfo(this) << "No initial state set for StateMachine"; + + // Everything is proper setup, now start the state-machine if we got + // asked to do so. + m_completed = true; + if (m_running) + setRunning(true); +} + +QQmlListProperty<QObject> StateMachine::children() +{ + return QQmlListProperty<QObject>(this, &m_children, m_children.append, m_children.count, m_children.at, m_children.clear); +} + +/*! + \qmltype StateMachine + \inqmlmodule QtStateMachine 1.0 + \inherits StateBase + \ingroup qmlstatemachine + \since 5.4 + + \brief Provides a hierarchical finite state machine. + + StateMachine is based on the concepts and notation of + \l{http://www.wisdom.weizmann.ac.il/~dharel/SCANNED.PAPERS/Statecharts.pdf}{Statecharts}. + StateMachine is part of \l{The Declarative State Machine Framework}. + + A state machine manages a set of states and transitions between those + states; these states and transitions define a state graph. Once a state + graph has been built, the state machine can execute it. StateMachine's + execution algorithm is based on the \l{http://www.w3.org/TR/scxml/}{State Chart XML (SCXML)} + algorithm. The framework's \l{The Declarative State Machine Framework}{overview} + gives several state graphs and the code to build them. + + Before the machine can be started, the \l{StateBase::initialState}{initialState} + must be set. The initial state is the state that the + machine enters when started. You can then set running property to true + or start() the state machine. The started signal is emitted when the + initial state is entered. + + The state machine processes events and takes transitions until a + top-level final state is entered; the state machine then emits the + finished() signal. You can also stop() the state machine + explicitly (you can also set running property to false). + The stopped signal is emitted in this case. + + \section1 Example Usage + The following snippet shows a state machine that will finish when a button + is clicked: + + \snippet qml/statemachine/simplestatemachine.qml document + + If an error is encountered, the machine will look for an + \l{StateBase::errorState}{errorState}, and if one is available, it will + enter this state. After the error state is entered, the type of the error + can be retrieved with error(). The execution of the state graph will not + stop when the error state is entered. If no error state applies to the + erroneous state, the machine will stop executing and an error message will + be printed to the console. + + \clearfloat + + \sa QAbstractState, StateBase, SignalTransition, TimeoutTransition, HistoryState {The Declarative State Machine Framework} +*/ + +/*! + \qmlproperty enumeration StateMachine::globalRestorePolicy + + \brief The restore policy for states of this state machine. + + The default value of this property is QState.DontRestoreProperties. + + This enum specifies the restore policy type. The restore policy + takes effect when the machine enters a state which sets one or more + properties. If the restore policy is set to QState.RestoreProperties, + the state machine will save the original value of the property before the + new value is set. + + Later, when the machine either enters a state which does not set a + value for the given property, the property will automatically be restored + to its initial value. + + Only one initial value will be saved for any given property. If a value + for a property has already been saved by the state machine, it will not be + overwritten until the property has been successfully restored. + + \list + \li QState.DontRestoreProperties The state machine should not save the initial values of properties and restore them later. + \li QState.RestoreProperties The state machine should save the initial values of properties and restore them later. + \endlist +*/ + +/*! + \qmlproperty bool StateMachine::running + + \brief The running state of this state machine. + \sa start(), stop() +*/ + +/*! + \qmlproperty string StateMachine::errorString + \readonly errorString + + \brief The error string of this state machine. +*/ + + +/*! + \qmlmethod StateMachine::start() + + Starts this state machine. The machine will reset its configuration and + transition to the initial state. When a final top-level state (FinalState) + is entered, the machine will emit the finished() signal. + + \note A state machine will not run without a running event loop, such as + the main application event loop started with QCoreApplication::exec() or + QApplication::exec(). + + \sa started, StateBase::finished, stop(), StateBase::initialState, running +*/ + +/*! + \qmlsignal StateMachine::started() + + This signal is emitted when the state machine has entered its initial state + (StateBase::initialState). + + The corresponding handler is \c onStarted. + + \sa running, start(), StateBase::finished +*/ + +/*! + \qmlmethod StateMachine::stop() + + Stops this state machine. The state machine will stop processing events + and then emit the stopped signal. + + \sa stopped, start(), running +*/ + +/*! + \qmlsignal StateMachine::stopped() + + This signal is emitted when the state machine has stopped. + + The corresponding handler is \c onStopped. + + \sa running, stop(), StateBase::finished +*/ diff --git a/src/imports/statemachine/statemachine.h b/src/imports/statemachine/statemachine.h new file mode 100644 index 0000000000..5bce986230 --- /dev/null +++ b/src/imports/statemachine/statemachine.h @@ -0,0 +1,91 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef STATEMACHINE_H +#define STATEMACHINE_H + +#include "childrenprivate.h" + +#include <QtCore/QStateMachine> +#include <QtQml/QQmlParserStatus> +#include <QtQml/QQmlListProperty> + +QT_BEGIN_NAMESPACE + +class QQmlOpenMetaObject; + +class StateMachine : public QStateMachine, public QQmlParserStatus +{ + Q_OBJECT + Q_INTERFACES(QQmlParserStatus) + Q_PROPERTY(QQmlListProperty<QObject> children READ children NOTIFY childrenChanged) + + // Override to delay execution after componentComplete() + Q_PROPERTY(bool running READ isRunning WRITE setRunning NOTIFY qmlRunningChanged) + + Q_CLASSINFO("DefaultProperty", "children") + +public: + explicit StateMachine(QObject *parent = 0); + + void classBegin() {} + void componentComplete(); + QQmlListProperty<QObject> children(); + + bool isRunning() const; + void setRunning(bool running); + +Q_SIGNALS: + void childrenChanged(); + /*! + * \internal + */ + void qmlRunningChanged(); + +private: + ChildrenPrivate<StateMachine> m_children; + bool m_completed; + bool m_running; +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/imports/statemachine/statemachine.pro b/src/imports/statemachine/statemachine.pro new file mode 100644 index 0000000000..4cc7089a32 --- /dev/null +++ b/src/imports/statemachine/statemachine.pro @@ -0,0 +1,24 @@ +CXX_MODULE = qml +TARGET = qtqmlstatemachine +TARGETPATH = QtQml/StateMachine +IMPORT_VERSION = 1.0 + +QT = core-private qml-private + +SOURCES = \ + $$PWD/finalstate.cpp \ + $$PWD/signaltransition.cpp \ + $$PWD/statebase.cpp \ + $$PWD/statemachine.cpp \ + $$PWD/timeouttransition.cpp \ + $$PWD/plugin.cpp + +HEADERS = \ + $$PWD/childrenprivate.h \ + $$PWD/finalstate.h \ + $$PWD/signaltransition.h \ + $$PWD/statebase.h \ + $$PWD/statemachine.h \ + $$PWD/timeouttransition.h + +load(qml_plugin) diff --git a/src/imports/statemachine/timeouttransition.cpp b/src/imports/statemachine/timeouttransition.cpp new file mode 100644 index 0000000000..eb946e38ad --- /dev/null +++ b/src/imports/statemachine/timeouttransition.cpp @@ -0,0 +1,114 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "timeouttransition.h" + +#include <QQmlInfo> +#include <QTimer> +#include <QState> + +TimeoutTransition::TimeoutTransition(QState* parent) + : QSignalTransition((m_timer = new QTimer), SIGNAL(timeout()), parent) +{ + m_timer->setSingleShot(true); + m_timer->setInterval(1000); +} + +TimeoutTransition::~TimeoutTransition() +{ + delete m_timer; +} + +int TimeoutTransition::timeout() const +{ + return m_timer->interval(); +} + +void TimeoutTransition::setTimeout(int timeout) +{ + if (timeout != m_timer->interval()) { + m_timer->setInterval(timeout); + emit timeoutChanged(); + } +} + +void TimeoutTransition::componentComplete() +{ + QState *state = qobject_cast<QState*>(parent()); + if (!state) { + qmlInfo(this) << "Parent needs to be a State"; + return; + } + + connect(state, SIGNAL(entered()), m_timer, SLOT(start())); + connect(state, SIGNAL(exited()), m_timer, SLOT(stop())); + if (state->active()) + m_timer->start(); +} + +/*! + \qmltype TimeoutTransition + \inqmlmodule QtStateMachine 1.0 + \inherits QSignalTransition + \ingroup qmlstatemachine + \since 5.4 + + \brief The TimeoutTransition type provides a transition based on a timer. + + \l{Timer} type can be combined with SignalTransition to enact more complex + timeout based transitions. + + TimeoutTransition is part of \l{The Declarative State Machine Framework}. + + \section1 Example Usage + + \snippet qml/statemachine/timeouttransition.qml document + + \clearfloat + + \sa StateMachine, SignalTransition, FinalState, HistoryState +*/ + +/*! + \qmlproperty int TimeoutTransition::timeout + + \brief The timeout interval in milliseconds. +*/ diff --git a/src/imports/statemachine/timeouttransition.h b/src/imports/statemachine/timeouttransition.h new file mode 100644 index 0000000000..9b166f8886 --- /dev/null +++ b/src/imports/statemachine/timeouttransition.h @@ -0,0 +1,76 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef TIMEOUTTRANSITION_H +#define TIMEOUTTRANSITION_H + +#include <QtCore/QSignalTransition> +#include <QtQml/QQmlParserStatus> + +QT_BEGIN_NAMESPACE +class QTimer; + +class TimeoutTransition : public QSignalTransition, public QQmlParserStatus +{ + Q_OBJECT + Q_PROPERTY(int timeout READ timeout WRITE setTimeout NOTIFY timeoutChanged) + Q_INTERFACES(QQmlParserStatus) + +public: + TimeoutTransition(QState *parent = Q_NULLPTR); + ~TimeoutTransition(); + + int timeout() const; + void setTimeout(int timeout); + + void classBegin() {} + void componentComplete(); + +Q_SIGNALS: + void timeoutChanged(); + +private: + QTimer *m_timer; +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/qml/doc/images/statemachine-button-history.png b/src/qml/doc/images/statemachine-button-history.png Binary files differnew file mode 100644 index 0000000000..0462b3b99b --- /dev/null +++ b/src/qml/doc/images/statemachine-button-history.png diff --git a/src/qml/doc/images/statemachine-button-nested.png b/src/qml/doc/images/statemachine-button-nested.png Binary files differnew file mode 100644 index 0000000000..762ac14df1 --- /dev/null +++ b/src/qml/doc/images/statemachine-button-nested.png diff --git a/src/qml/doc/images/statemachine-button.png b/src/qml/doc/images/statemachine-button.png Binary files differnew file mode 100644 index 0000000000..10102bdf2c --- /dev/null +++ b/src/qml/doc/images/statemachine-button.png diff --git a/src/qml/doc/images/statemachine-finished.png b/src/qml/doc/images/statemachine-finished.png Binary files differnew file mode 100644 index 0000000000..0ac081d6ba --- /dev/null +++ b/src/qml/doc/images/statemachine-finished.png diff --git a/src/qml/doc/images/statemachine-nonparallel.png b/src/qml/doc/images/statemachine-nonparallel.png Binary files differnew file mode 100644 index 0000000000..f9850a74a6 --- /dev/null +++ b/src/qml/doc/images/statemachine-nonparallel.png diff --git a/src/qml/doc/images/statemachine-parallel.png b/src/qml/doc/images/statemachine-parallel.png Binary files differnew file mode 100644 index 0000000000..a65c297f5b --- /dev/null +++ b/src/qml/doc/images/statemachine-parallel.png diff --git a/src/qml/doc/qtqml.qdocconf b/src/qml/doc/qtqml.qdocconf index 418a330d2c..6e07fd173b 100644 --- a/src/qml/doc/qtqml.qdocconf +++ b/src/qml/doc/qtqml.qdocconf @@ -40,7 +40,8 @@ headerdirs += .. \ ../../imports/models sourcedirs += .. \ - ../../imports/models + ../../imports/models \ + ../../imports/statemachine exampledirs += ../../../examples/qml \ ../ \ diff --git a/src/qml/doc/snippets/qml/statemachine/Button.qml b/src/qml/doc/snippets/qml/statemachine/Button.qml new file mode 100644 index 0000000000..2baad4cbfb --- /dev/null +++ b/src/qml/doc/snippets/qml/statemachine/Button.qml @@ -0,0 +1,88 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the examples of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +import QtQuick 2.1 +import QtQuick.Window 2.1 + +Item { + id: container + + property alias text: buttonLabel.text + property alias label: buttonLabel + signal clicked + property alias containsMouse: mouseArea.containsMouse + property alias pressed: mouseArea.pressed + implicitHeight: Math.max(Screen.pixelDensity * 7, buttonLabel.implicitHeight * 1.2) + implicitWidth: Math.max(Screen.pixelDensity * 11, buttonLabel.implicitWidth * 1.3) + height: implicitHeight + width: implicitWidth + property bool checkable: false + property bool checked: false + + SystemPalette { id: palette } + + Rectangle { + id: frame + anchors.fill: parent + color: palette.button + gradient: Gradient { + GradientStop { position: 0.0; color: mouseArea.pressed ? Qt.darker(palette.button, 1.3) : palette.button } + GradientStop { position: 1.0; color: Qt.darker(palette.button, 1.3) } + } + antialiasing: true + radius: height / 6 + border.color: Qt.darker(palette.button, 1.5) + border.width: 1 + } + + MouseArea { + id: mouseArea + anchors.fill: parent + onClicked: container.clicked() + hoverEnabled: true + } + + Text { + id: buttonLabel + text: container.text + color: palette.buttonText + anchors.centerIn: parent + } +} diff --git a/src/qml/doc/snippets/qml/statemachine/basicstate.qml b/src/qml/doc/snippets/qml/statemachine/basicstate.qml new file mode 100644 index 0000000000..dd9d100e9d --- /dev/null +++ b/src/qml/doc/snippets/qml/statemachine/basicstate.qml @@ -0,0 +1,55 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +//! [document] +import QtQml.StateMachine 1.0 +import QtQuick 2.0 + +Rectangle { + StateMachine { + id: stateMachine + initialState: state + running: true + StateBase { + id: state + } + } +} +//! [document] diff --git a/src/qml/doc/snippets/qml/statemachine/finalstate.qml b/src/qml/doc/snippets/qml/statemachine/finalstate.qml new file mode 100644 index 0000000000..d03a4bce40 --- /dev/null +++ b/src/qml/doc/snippets/qml/statemachine/finalstate.qml @@ -0,0 +1,63 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +//! [document] +import QtQml.StateMachine 1.0 +import QtQuick 2.0 + +Rectangle { + StateMachine { + id: stateMachine + initialState: state + running: true + StateBase { + id: state + TimeoutTransition { + targetState: finalState + timeout: 200 + } + } + FinalState { + id: finalState + } + onFinished: console.log("state finished") + } +} +//! [document] diff --git a/src/qml/doc/snippets/qml/statemachine/historystate.qml b/src/qml/doc/snippets/qml/statemachine/historystate.qml new file mode 100644 index 0000000000..237cf57175 --- /dev/null +++ b/src/qml/doc/snippets/qml/statemachine/historystate.qml @@ -0,0 +1,85 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +//! [document] +import QtQml.StateMachine 1.0 +import QtQuick 2.0 + +Rectangle { + Button { + anchors.fill: parent + id: button + text: "Press me" + StateMachine { + id: stateMachine + initialState: parentState + running: true + StateBase { + id: parentState + initialState: child2 + onEntered: console.log("parentState entered") + onExited: console.log("parentState exited") + StateBase { + id: child1 + onEntered: console.log("child1 entered") + onExited: console.log("child1 exited") + } + StateBase { + id: child2 + onEntered: console.log("child2 entered") + onExited: console.log("child2 exited") + } + HistoryState { + id: historyState + defaultState: child1 + } + SignalTransition { + targetState: historyState + + // Clicking the button will cause the state machine to enter the child state + // that parentState was in the last time parentState was exited, or the history state's default + // state if parentState has never been entered. + signal: button.clicked + } + } + } + } +} +//! [document] diff --git a/src/qml/doc/snippets/qml/statemachine/signaltransition.qml b/src/qml/doc/snippets/qml/statemachine/signaltransition.qml new file mode 100644 index 0000000000..7402ac089f --- /dev/null +++ b/src/qml/doc/snippets/qml/statemachine/signaltransition.qml @@ -0,0 +1,77 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +//! [document] +import QtQml.StateMachine 1.0 +import QtQuick 2.0 + +Rectangle { + StateMachine { + id: stateMachine + initialState: state + running: true + StateBase { + id: state + SignalTransition { + targetState: finalState + signal: button.clicked + guard: guardButton.checked + } + } + FinalState { + id: finalState + } + onFinished: Qt.quit() + } + Row { + spacing: 2 + Button { + id: button + text: "Finish state" + } + + Button { + id: guardButton + checkable: true + text: checked ? "Press to block the SignalTransition" : "Press to unblock the SignalTransition" + } + } +} +//! [document] diff --git a/src/qml/doc/snippets/qml/statemachine/signaltransitionsignal.qml b/src/qml/doc/snippets/qml/statemachine/signaltransitionsignal.qml new file mode 100644 index 0000000000..44608fed36 --- /dev/null +++ b/src/qml/doc/snippets/qml/statemachine/signaltransitionsignal.qml @@ -0,0 +1,62 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +//! [document] +import QtQml.StateMachine 1.0 +import QtQuick 2.0 + +Rectangle { + Button { + anchors.fill: parent + id: button + StateMachine { + StateBase { + SignalTransition { + targetState: finalState + signal: button.clicked + } + } + FinalState { + id: finalState + } + } + } +} +//! [document] diff --git a/src/qml/doc/snippets/qml/statemachine/simplestatemachine.qml b/src/qml/doc/snippets/qml/statemachine/simplestatemachine.qml new file mode 100644 index 0000000000..f5c6923cd1 --- /dev/null +++ b/src/qml/doc/snippets/qml/statemachine/simplestatemachine.qml @@ -0,0 +1,68 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +//! [document] +import QtQml.StateMachine 1.0 +import QtQuick 2.0 + +Rectangle { + Button { + anchors.fill: parent + id: button + text: "Finish state" + StateMachine { + id: stateMachine + initialState: state + running: true + StateBase { + id: state + SignalTransition { + targetState: finalState + signal: button.clicked + } + } + FinalState { + id: finalState + } + onFinished: Qt.quit() + } + } +} +//! [document] diff --git a/src/qml/doc/snippets/qml/statemachine/statemachine-button-history.qml b/src/qml/doc/snippets/qml/statemachine/statemachine-button-history.qml new file mode 100644 index 0000000000..10595a9398 --- /dev/null +++ b/src/qml/doc/snippets/qml/statemachine/statemachine-button-history.qml @@ -0,0 +1,150 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +//! [document] +import QtQml.StateMachine 1.0 +import QtQuick 2.0 + +Rectangle { +//![0] + Row { + anchors.fill: parent + spacing: 2 + Button { + id: button + // change the button label to the active state id + text: s11.active ? "s11" : s12.active ? "s12" : s13.active ? "s13" : "s3" + } + Button { + id: interruptButton + text: s1.active ? "Interrupt" : "Resume" + } + Button { + id: quitButton + // change the button label to the active state id + text: "quit" + } + } + + StateMachine { + id: stateMachine + // set the initial state + initialState: s1 + + // start the state machine + running: true + + StateBase { + id: s1 + // set the initial state + initialState: s11 + + // create a transition from s1 to s2 when the button is clicked + SignalTransition { + targetState: s2 + signal: quitButton.clicked + } + // do something when the state enters/exits + onEntered: console.log("s1 entered") + onExited: console.log("s1 exited") + StateBase { + id: s11 + // create a transition from s1 to s2 when the button is clicked + SignalTransition { + targetState: s12 + signal: button.clicked + } + // do something when the state enters/exits + onEntered: console.log("s11 entered") + onExited: console.log("s11 exited") + } + + StateBase { + id: s12 + // create a transition from s2 to s3 when the button is clicked + SignalTransition { + targetState: s13 + signal: button.clicked + } + // do something when the state enters/exits + onEntered: console.log("s12 entered") + onExited: console.log("s12 exited") + } + StateBase { + id: s13 + // create a transition from s3 to s1 when the button is clicked + SignalTransition { + targetState: s1 + signal: button.clicked + } + // do something when the state enters/exits + onEntered: console.log("s13 entered") + onExited: console.log("s13 exited") + } + + // create a transition from s1 to s3 when the button is clicked + SignalTransition { + targetState: s3 + signal: interruptButton.clicked + } + HistoryState { + id: s1h + } + } + FinalState { + id: s2 + onEntered: console.log("s2 entered") + onExited: console.log("s2 exited") + } + StateBase { + id: s3 + SignalTransition { + targetState: s1h + signal: interruptButton.clicked + } + // do something when the state enters/exits + onEntered: console.log("s3 entered") + onExited: console.log("s3 exited") + } + onFinished: Qt.quit() + } +//![0] +} +//! [document] diff --git a/src/qml/doc/snippets/qml/statemachine/statemachine-button-nested-ignore-quit.qml b/src/qml/doc/snippets/qml/statemachine/statemachine-button-nested-ignore-quit.qml new file mode 100644 index 0000000000..00f9cd3871 --- /dev/null +++ b/src/qml/doc/snippets/qml/statemachine/statemachine-button-nested-ignore-quit.qml @@ -0,0 +1,135 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +//! [document] +import QtQml.StateMachine 1.0 +import QtQuick 2.0 + +Rectangle { + Row { + anchors.fill: parent + spacing: 2 + Button { + id: button + // change the button label to the active state id + text: s11.active ? "s11" : s12.active ? "s12" : "s13" + } + Button { + id: quitButton + // change the button label to the active state id + text: "quit" + } + } + + StateMachine { + id: stateMachine + // set the initial state + initialState: s1 + + // start the state machine + running: true + + StateBase { + id: s1 + // set the initial state + initialState: s11 + + // create a transition from s1 to s2 when the button is clicked + SignalTransition { + targetState: s2 + signal: quitButton.clicked + } + // do something when the state enters/exits + onEntered: console.log("s1 entered") + onExited: console.log("s1 exited") + StateBase { + id: s11 + // create a transition from s11 to s12 when the button is clicked + SignalTransition { + targetState: s12 + signal: button.clicked + } + // do something when the state enters/exits + onEntered: console.log("s11 entered") + onExited: console.log("s11 exited") + } + +//![0] + StateBase { + id: s12 + // create a transition from s12 to s13 when the button is clicked + SignalTransition { + targetState: s13 + signal: button.clicked + } + + // ignore Quit button when we are in state 12 + SignalTransition { + targetState: s12 + signal: quitButton.clicked + } + + // do something when the state enters/exits + onEntered: console.log("s12 entered") + onExited: console.log("s12 exited") + } +//![0] + + StateBase { + id: s13 + // create a transition from s13 to s11 when the button is clicked + SignalTransition { + targetState: s11 + signal: button.clicked + } + // do something when the state enters/exits + onEntered: console.log("s13 entered") + onExited: console.log("s13 exited") + } + } + FinalState { + id: s2 + onEntered: console.log("s2 entered") + onExited: console.log("s2 exited") + } + onFinished: Qt.quit() + } +} +//! [document] diff --git a/src/qml/doc/snippets/qml/statemachine/statemachine-button-nested.qml b/src/qml/doc/snippets/qml/statemachine/statemachine-button-nested.qml new file mode 100644 index 0000000000..68bd57d85f --- /dev/null +++ b/src/qml/doc/snippets/qml/statemachine/statemachine-button-nested.qml @@ -0,0 +1,127 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +//! [document] +import QtQml.StateMachine 1.0 +import QtQuick 2.0 + +Rectangle { +//![0] + Row { + anchors.fill: parent + spacing: 2 + Button { + id: button + // change the button label to the active state id + text: s11.active ? "s11" : s12.active ? "s12" : "s13" + } + Button { + id: quitButton + // change the button label to the active state id + text: "quit" + } + } + + StateMachine { + id: stateMachine + // set the initial state + initialState: s1 + + // start the state machine + running: true + + StateBase { + id: s1 + // set the initial state + initialState: s11 + + // create a transition from s1 to s2 when the button is clicked + SignalTransition { + targetState: s2 + signal: quitButton.clicked + } + // do something when the state enters/exits + onEntered: console.log("s1 entered") + onExited: console.log("s1 exited") + StateBase { + id: s11 + // create a transition from s11 to s12 when the button is clicked + SignalTransition { + targetState: s12 + signal: button.clicked + } + // do something when the state enters/exits + onEntered: console.log("s11 entered") + onExited: console.log("s11 exited") + } + + StateBase { + id: s12 + // create a transition from s12 to s13 when the button is clicked + SignalTransition { + targetState: s13 + signal: button.clicked + } + // do something when the state enters/exits + onEntered: console.log("s12 entered") + onExited: console.log("s12 exited") + } + StateBase { + id: s13 + // create a transition from s13 to s11 when the button is clicked + SignalTransition { + targetState: s11 + signal: button.clicked + } + // do something when the state enters/exits + onEntered: console.log("s13 entered") + onExited: console.log("s13 exited") + } + } + FinalState { + id: s2 + onEntered: console.log("s2 entered") + onExited: console.log("s2 exited") + } + onFinished: Qt.quit() + } +//![0] +} +//! [document] diff --git a/src/qml/doc/snippets/qml/statemachine/statemachine-button.qml b/src/qml/doc/snippets/qml/statemachine/statemachine-button.qml new file mode 100644 index 0000000000..f2817ead8b --- /dev/null +++ b/src/qml/doc/snippets/qml/statemachine/statemachine-button.qml @@ -0,0 +1,100 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +//! [document] +import QtQml.StateMachine 1.0 +import QtQuick 2.0 + +Rectangle { +//![0] + Button { + anchors.fill: parent + id: button + + // change the button label to the active state id + text: s1.active ? "s1" : s2.active ? "s2" : "s3" + } + + StateMachine { + id: stateMachine + // set the initial state + initialState: s1 + + // start the state machine + running: true + + StateBase { + id: s1 + // create a transition from s1 to s2 when the button is clicked + SignalTransition { + targetState: s2 + signal: button.clicked + } + // do something when the state enters/exits + onEntered: console.log("s1 entered") + onExited: console.log("s1 exited") + } + + StateBase { + id: s2 + // create a transition from s2 to s3 when the button is clicked + SignalTransition { + targetState: s3 + signal: button.clicked + } + // do something when the state enters/exits + onEntered: console.log("s2 entered") + onExited: console.log("s2 exited") + } + StateBase { + id: s3 + // create a transition from s3 to s1 when the button is clicked + SignalTransition { + targetState: s1 + signal: button.clicked + } + // do something when the state enters/exits + onEntered: console.log("s3 entered") + onExited: console.log("s3 exited") + } + } +//![0] +} +//! [document] diff --git a/src/qml/doc/snippets/qml/statemachine/timeouttransition.qml b/src/qml/doc/snippets/qml/statemachine/timeouttransition.qml new file mode 100644 index 0000000000..b15c99cd22 --- /dev/null +++ b/src/qml/doc/snippets/qml/statemachine/timeouttransition.qml @@ -0,0 +1,69 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +//! [document] +import QtQml.StateMachine 1.0 +import QtQuick 2.0 + +Rectangle { + Button { + anchors.fill: parent + id: button + text: "Finish state" + enabled: !stateMachine.running + onClicked: stateMachine.running = true + StateMachine { + id: stateMachine + initialState: state + running: true + StateBase { + id: state + TimeoutTransition { + targetState: finalState + timeout: 1000 + } + } + FinalState { + id: finalState + } + } + } +} +//! [document] diff --git a/src/qml/doc/src/qtqml.qdoc b/src/qml/doc/src/qtqml.qdoc index b9c008edf1..ae2cac7275 100644 --- a/src/qml/doc/src/qtqml.qdoc +++ b/src/qml/doc/src/qtqml.qdoc @@ -126,6 +126,11 @@ the QML code to interact with C++ code. \li \l{Integrating QML and C++} \endlist +\section1 Additional Frameworks +\list +\li \l{The Declarative State Machine Framework} +\endlist + \section1 Guides and Other Information Further information for writing QML applications: diff --git a/src/qml/doc/src/statemachine.qdoc b/src/qml/doc/src/statemachine.qdoc new file mode 100644 index 0000000000..5a37ef8026 --- /dev/null +++ b/src/qml/doc/src/statemachine.qdoc @@ -0,0 +1,317 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:FDL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Free Documentation License Usage +** Alternatively, this file may be used under the terms of the GNU Free +** Documentation License version 1.3 as published by the Free Software +** Foundation and appearing in the file included in the packaging of +** this file. Please review the following information to ensure +** the GNU Free Documentation License version 1.3 requirements +** will be met: http://www.gnu.org/copyleft/fdl.html. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +/*! + \group qmlstatemachine + \page qmlstatemachine.html + \title The Declarative State Machine Framework + \brief An overview of the Declarative State Machine Framework for constructing and executing state graphs. + + \ingroup frameworks-technologies + + \tableofcontents + + The Declarative State Machine Framework provides classes for creating and executing + state graphs in QML. The concepts and notation are based on those from Harel's + \l{http://www.wisdom.weizmann.ac.il/~dharel/SCANNED.PAPERS/Statecharts.pdf} + {Statecharts: A visual formalism for complex systems}, which + is also the basis of UML state diagrams. The semantics of state machine + execution are based on \l{State Chart XML: State Machine Notation for + Control Abstraction}{State Chart XML (SCXML)}. + + Statecharts provide a graphical way of modeling how a system reacts to + stimuli. This is done by defining the possible \e states that the system can + be in, and how the system can move from one state to another (\e transitions + between states). A key characteristic of event-driven systems (such as Qt + applications) is that behavior often depends not only on the last or current + event, but also the events that preceded it. With statecharts, this + information is easy to express. + + The Declarative State Machine Framework provides an API and execution model that can + be used to effectively embed the elements and semantics of statecharts in Qml + applications. The framework integrates tightly with Qt's meta-object system; + for example, transitions between states can be triggered by signals, and + states can be configured to set properties and invoke methods on QObjects. + Qt's event system is used to drive the state machines. + + The state graph in the Declarative State Machine Framework is hierarchical. States + can be nested inside of other states, and the current configuration of the + state machine consists of the set of states which are currently active. + All the states in a valid configuration of the state machine will + have a common ancestor. + + For user interfaces with multiple visual states, independent of the + application's logical state, consider using QML States and Transitions. + + \section1 QML types in the Declarative State Machine Framework + + These QML types are provided by QML for creating event-driven state machines. + + \annotatedlist qmlstatemachine + + \section1 A Simple State Machine + + To demonstrate the core functionality of the State Machine API, let's look + at a small example: A state machine with three states, \c s1, \c s2 and \c + s3. The state machine is controlled by a single QPushButton; when the button + is clicked, the machine transitions to another state. Initially, the state + machine is in state \c s1. The statechart for this machine is as follows: + + \image statemachine-button.png + \omit + \caption This is a caption + \endomit + + The following snippet shows the code needed to create such a state machine. + + \snippet qml/statemachine/statemachine-button.qml 0 + + The state machine executes asynchronously, i.e. it becomes part of your + application's event loop. + + \section1 State Machines That Finish + + The state machine defined in the previous section never finishes. In order + for a state machine to be able to finish, it needs to have a top-level \e + final state (FinalState object). When the state machine enters a top-level + final state, the machine will emit the \l{StateBase::finished}{finished} + signal and halt. + + All you need to do to introduce a final state in the graph is create a + FinalState object and use it as the target of one or more transitions. + + \section1 Sharing Transitions By Grouping States + + Assume we wanted the user to be able to quit the application at any time by + clicking a Quit button. In order to achieve this, we need to create a final + state and make it the target of a transition associated with the Quit + button's clicked() signal. We could add a transition from each of \c s1, \c + s2 and \c s3; however, this seems redundant, and one would also have to + remember to add such a transition from every new state that is added in the + future. + + We can achieve the same behavior (namely that clicking the Quit button quits + the state machine, regardless of which state the state machine is in) by + grouping states \c s1, \c s2 and \c s3. This is done by creating a new + top-level state and making the three original states children of the new + state. The following diagram shows the new state machine. + + \image statemachine-button-nested.png + \omit + \caption This is a caption + \endomit + + The three original states have been renamed \c s11, \c s12 and \c s13 to + reflect that they are now children of the new top-level state, \c s1. Child + states implicitly inherit the transitions of their parent state. This means + it is now sufficient to add a single transition from \c s1 to the final + state \c s2. New states added to \c s1 will also automatically inherit this + transition. + + All that's needed to group states is to specify the proper parent when the + state is created. You also need to specify which of the child states is the + initial one (i.e. which child state the state machine should enter when the + parent state is the target of a transition). + + \snippet qml/statemachine/statemachine-button-nested.qml 0 + + In this case we want the application to quit when the state machine is + finished, so the machine's finished() signal is connected to the + application's quit() slot. + + A child state can override an inherited transition. For example, the + following code adds a transition that effectively causes the Quit button to + be ignored when the state machine is in state \c s12. + + \snippet qml/statemachine/statemachine-button-nested-ignore-quit.qml 0 + + A transition can have any state as its target, i.e. the target state does + not have to be on the same level in the state hierarchy as the source state. + + \section1 Using History States to Save and Restore the Current State + + Imagine that we wanted to add an "interrupt" mechanism to the example + discussed in the previous section; the user should be able to click a button + to have the state machine perform some non-related task, after which the + state machine should resume whatever it was doing before (i.e. return to the + old state, which is one of \c s11, \c s12 and \c s13 in this case). + + Such behavior can easily be modeled using \e{history states}. A history + state (HistoryState object) is a pseudo-state that represents the child + state that the parent state was in the last time the parent state was + exited. + + A history state is created as a child of the state for which we wish to + record the current child state; when the state machine detects the presence + of such a state at runtime, it automatically records the current (real) + child state when the parent state is exited. A transition to the history + state is in fact a transition to the child state that the state machine had + previously saved; the state machine automatically "forwards" the transition + to the real child state. + + The following diagram shows the state machine after the interrupt mechanism + has been added. + + \image statemachine-button-history.png + \omit + \caption This is a caption + \endomit + + The following code shows how it can be implemented; in this example we + simply display a message box when \c s3 is entered, then immediately return + to the previous child state of \c s1 via the history state. + + \snippet qml/statemachine/statemachine-button-history.qml 0 + + \section1 Using Parallel States to Avoid a Combinatorial Explosion of States + + Assume that you wanted to model a set of mutually exclusive properties of a + car in a single state machine. Let's say the properties we are interested in + are Clean vs Dirty, and Moving vs Not moving. It would take four mutually + exclusive states and eight transitions to be able to represent and freely + move between all possible combinations. + + \image statemachine-nonparallel.png + \omit + \caption This is a caption + \endomit + + If we added a third property (say, Red vs Blue), the total number of states + would double, to eight; and if we added a fourth property (say, Enclosed vs + Convertible), the total number of states would double again, to 16. + + Using parallel states, the total number of states and transitions grows + linearly as we add more properties, instead of exponentially. Furthermore, + states can be added to or removed from the parallel state without affecting + any of their sibling states. + + \image statemachine-parallel.png + \omit + \caption This is a caption + \endomit + + To create a parallel state group, set childMode to QState.ParallelStates. + + \qml + StateBase { + id: s1 + childMode: QState.ParallelStates + StateBase { + id: s11 + } + StateBase { + id: s12 + } + } + \endqml + + When a parallel state group is entered, all its child states will be + simultaneously entered. Transitions within the individual child states + operate normally. However, any of the child states may take a transition which exits the parent + state. When this happens, the parent state and all of its child states are exited. + + The parallelism in the State Machine framework follows an interleaved semantics. All parallel + operations will be executed in a single, atomic step of the event processing, so no event can + interrupt the parallel operations. However, events will still be processed sequentially, since + the machine itself is single threaded. As an example: Consider the situation where there are two + transitions that exit the same parallel state group, and their conditions become true + simultaneously. In this case, the event that is processed last of the two will not have any + effect, since the first event will already have caused the machine to exit from the parallel + state. + + \section1 Detecting that a Composite State has Finished + + A child state can be final (a FinalState object); when a final child state + is entered, the parent state emits the StateBase::finished signal. The + following diagram shows a composite state \c s1 which does some processing + before entering a final state: + + \image statemachine-finished.png + \omit + \caption This is a caption + \endomit + + When \c s1 's final state is entered, \c s1 will automatically emit + \l{StateBase::finished}{finished}. We use a signal transition to cause this event to + trigger a state change: + + \qml + StateBase { + id: s1 + SignalTransition { + targetState: s2 + signal: s1.finished + } + } + \endqml + + Using final states in composite states is useful when you want to hide the + internal details of a composite state; i.e. the only thing the outside world + should be able to do is enter the state, and get a notification when the + state has completed its work. This is a very powerful abstraction and + encapsulation mechanism when building complex (deeply nested) state + machines. (In the above example, you could of course create a transition + directly from \c s1 's \c done state rather than relying on \c s1 's + finished() signal, but with the consequence that implementation details of + \c s1 are exposed and depended on). + + For parallel state groups, the StateBase::finished signal is emitted when \e + all the child states have entered final states. + + \section1 Targetless Transitions + + A transition need not have a target state. A transition without a target can + be triggered the same way as any other transition; the difference is that + when a targetless transition is triggered, it doesn't cause any state + changes. This allows you to react to a signal or event when your machine is + in a certain state, without having to leave that state. Example: + + \qml + Button { + id: button + text: "button" + StateMachine { + id: stateMachine + initialState: s1 + running: true + StateBase { + id: s1 + SignalTransition { + signal: button.clicked + onTriggered: console.log("button pressed") + } + } + } + } + \endqml + + The "button pressed" message will be displayed each time the button is clicked, but the + state machine will remain in its current state (s1). If the target state + were explicitly set to s1, however, s1 would be exited and re-entered each + time (e.g. the QAbstractState::entered and QAbstractState::exited + signals would be emitted). +*/ diff --git a/src/qml/jsruntime/qv4qobjectwrapper_p.h b/src/qml/jsruntime/qv4qobjectwrapper_p.h index a774917713..f60640c9fa 100644 --- a/src/qml/jsruntime/qv4qobjectwrapper_p.h +++ b/src/qml/jsruntime/qv4qobjectwrapper_p.h @@ -123,7 +123,7 @@ private: static ReturnedValue method_disconnect(CallContext *ctx); }; -struct QObjectMethod : public QV4::FunctionObject +struct Q_QML_EXPORT QObjectMethod : public QV4::FunctionObject { struct Data : QV4::FunctionObject::Data { Data(QV4::ExecutionContext *scope, QObject *object, int index, const ValueRef qmlGlobal); diff --git a/tests/auto/qmltest/statemachine/tst_anonymousstate.qml b/tests/auto/qmltest/statemachine/tst_anonymousstate.qml new file mode 100644 index 0000000000..cd20f67c20 --- /dev/null +++ b/tests/auto/qmltest/statemachine/tst_anonymousstate.qml @@ -0,0 +1,52 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the test suite module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +import QtQml.StateMachine 1.0 +import QtTest 1.0 + +TestCase { + StateMachine { + StateBase { + } + } + name: "anonymousState" + // no real tests, just make sure it runs +} diff --git a/tests/auto/qmltest/statemachine/tst_historystate.qml b/tests/auto/qmltest/statemachine/tst_historystate.qml new file mode 100644 index 0000000000..86e63af5b0 --- /dev/null +++ b/tests/auto/qmltest/statemachine/tst_historystate.qml @@ -0,0 +1,102 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the test suite module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +import QtQml.StateMachine 1.0 +import QtTest 1.0 + +TestCase { + + StateMachine { + id: stateMachine + initialState: historyState1 + + StateBase { + id: state1 + SignalTransition { + id: st1 + targetState: state2 + } + } + + StateBase { + id: state2 + initialState: historyState2 + HistoryState { + id: historyState2 + defaultState: state21 + } + StateBase { + id: state21 + } + } + + HistoryState { + id: historyState1 + defaultState: state1 + } + } + + SignalSpy { + id: state1SpyActive + target: state1 + signalName: "activeChanged" + } + + SignalSpy { + id: state2SpyActive + target: state2 + signalName: "activeChanged" + } + + + function test_historyStateAsInitialState() + { + stateMachine.start(); + tryCompare(stateMachine, "running", true); + tryCompare(state1SpyActive, "count" , 1); + tryCompare(state2SpyActive, "count" , 0); + st1.invoke(); + tryCompare(state1SpyActive, "count" , 2); + tryCompare(state2SpyActive, "count" , 1); + tryCompare(state21, "active", true); + tryCompare(state1, "active", false); + } +} diff --git a/tests/auto/qmltest/statemachine/tst_initialstate.qml b/tests/auto/qmltest/statemachine/tst_initialstate.qml new file mode 100644 index 0000000000..660bfcb327 --- /dev/null +++ b/tests/auto/qmltest/statemachine/tst_initialstate.qml @@ -0,0 +1,65 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the test suite module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +import QtQml.StateMachine 1.0 +import QtTest 1.0 + +TestCase { + StateMachine { + id: myStateMachine + initialState: myState; + running: true + StateBase { + id: myState + } + } + + name: "initialStateTest" + function test_initialState() { + tryCompare(myStateMachine, "running", true); + compare(myState.active, true); + myStateMachine.running = false; + tryCompare(myStateMachine, "running", false); + myStateMachine.running = true; + tryCompare(myStateMachine, "running", true); + tryCompare(myState, "active", true); + } +} diff --git a/tests/auto/qmltest/statemachine/tst_nestedinitialstates.qml b/tests/auto/qmltest/statemachine/tst_nestedinitialstates.qml new file mode 100644 index 0000000000..60230f1e86 --- /dev/null +++ b/tests/auto/qmltest/statemachine/tst_nestedinitialstates.qml @@ -0,0 +1,74 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the test suite module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +import QtQml.StateMachine 1.0 +import QtTest 1.0 + +TestCase { + StateMachine { + id: myStateMachine + initialState: parentState + StateBase { + id: parentState + initialState: childState1 + StateBase { + id: childState1 + } + StateBase { + id: childState2 + } + } + } + name: "nestedInitalStates" + + function test_nestedInitalStates() { + // uncomment me after vm problems are fixed. + // compare(myStateMachine.running, false); + compare(parentState.active, false); + compare(childState1.active, false); + compare(childState2.active, false); + myStateMachine.start(); + tryCompare(myStateMachine, "running", true); + tryCompare(parentState, "active", true); + tryCompare(childState1, "active", true); + compare(childState2.active, false); + } +} diff --git a/tests/auto/qmltest/statemachine/tst_parallelmachine.qml b/tests/auto/qmltest/statemachine/tst_parallelmachine.qml new file mode 100644 index 0000000000..99ef49860c --- /dev/null +++ b/tests/auto/qmltest/statemachine/tst_parallelmachine.qml @@ -0,0 +1,90 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the test suite module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +import QtQml.StateMachine 1.0 +import QtTest 1.0 + +TestCase { + StateMachine { + id: myStateMachine + childMode: StateBase.ParallelStates + StateBase { + id: childState1 + childMode: StateBase.ParallelStates + StateBase { + id: childState11 + } + StateBase { + id: childState12 + } + } + StateBase { + id: childState2 + initialState: childState21 + StateBase { + id: childState21 + } + StateBase { + id: childState22 + } + } + } + name: "nestedParallelMachineStates" + + function test_nestedInitalStates() { + // uncomment me after vm problems are fixed. + // compare(myStateMachine.running, false); + compare(childState1.active, false); + compare(childState11.active, false); + compare(childState12.active, false); + compare(childState2.active, false); + compare(childState21.active, false); + compare(childState22.active, false); + myStateMachine.start(); + tryCompare(myStateMachine, "running", true); + tryCompare(childState1, "active", true); + tryCompare(childState11, "active", true); + tryCompare(childState12, "active", true); + tryCompare(childState2, "active", true); + tryCompare(childState21, "active", true); + tryCompare(childState22, "active", false); + } +} diff --git a/tests/auto/qmltest/statemachine/tst_trafficlight.qml b/tests/auto/qmltest/statemachine/tst_trafficlight.qml new file mode 100644 index 0000000000..7b02cd0597 --- /dev/null +++ b/tests/auto/qmltest/statemachine/tst_trafficlight.qml @@ -0,0 +1,157 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Ford Motor Company +** Contact: http://www.qt-project.org/legal +** +** This file is part of the test suite module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +import QtQml.StateMachine 1.0 +import QtTest 1.0 + +TestCase { + StateMachine { + id: machine + initialState: red + FinalState { + id: finalState + } + + StateBase { + id: red + initialState: justRed + StateBase { + id: justRed + SignalTransition { + id: e1 + targetState: waitingForGreen + } + SignalTransition { + id: finalSignal + targetState: finalState + } + } + StateBase { + id: waitingForGreen + TimeoutTransition { + id: e2 + targetState: yellowred + timeout: 30 + } + } + } + StateBase { + id: yellowred + TimeoutTransition { + id: e3 + targetState: green + timeout: 10 + } + } + StateBase { + id: green + TimeoutTransition { + id: e4 + targetState: yellow + timeout: 50 + } + } + StateBase { + id: yellow + TimeoutTransition { + id: e5 + targetState: red + timeout: 10 + } + } + } + + SignalSpy { + id: machineSpyRunning + target: machine + signalName: "runningChanged" + } + + SignalSpy { + id: redSpyActive + target: red + signalName: "activeChanged" + } + + SignalSpy { + id: yellowredSpyActive + target: yellowred + signalName: "activeChanged" + } + + SignalSpy { + id: greenSpyActive + target: green + signalName: "activeChanged" + } + + SignalSpy { + id: yellowSpyActive + target: yellow + signalName: "activeChanged" + } + + + name: "testTrafficLight" + function test_trafficLight() + { + var i = 1; + machine.start(); + tryCompare(machine, "running", true); + tryCompare(machineSpyRunning, "count", 1); + tryCompare(redSpyActive, "count", 1); + for (; i <= 5; ++i) { + e1.invoke(); + tryCompare(yellowredSpyActive, "count", i * 2); + tryCompare(greenSpyActive, "count", i * 2); + tryCompare(redSpyActive, "count", i * 2 + 1); + tryCompare(yellowSpyActive, "count", i * 2); + } + finalSignal.guard = false; + finalSignal.invoke(); + wait(100); + tryCompare(machine, "running", true); + finalSignal.guard = true; + finalSignal.invoke(); + tryCompare(machine, "running", false); + tryCompare(redSpyActive, "count", i * 2); + } +} |