1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** Contact: Qt Software Information (qt-info@nokia.com)
**
** This file is part of the $MODULE$ of the Qt Toolkit.
**
** $TROLLTECH_DUAL_LICENSE$
**
****************************************************************************/
#ifndef QSTATEMACHINE_P_H
#define QSTATEMACHINE_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#ifndef QT_STATEMACHINE_SOLUTION
#include <private/qobject_p.h>
#endif
#include <QtCore/qcoreevent.h>
#include <QtCore/qhash.h>
#include <QtCore/qlist.h>
#include <QtCore/qset.h>
#include "qstate.h"
QT_BEGIN_NAMESPACE
class QEvent;
#ifndef QT_NO_STATEMACHINE_EVENTFILTER
class QEventTransition;
#endif
class QSignalEventGenerator;
class QSignalTransition;
class QAbstractState;
class QAbstractTransition;
class QState;
#ifndef QT_NO_ANIMATION
class QPropertyAnimation;
#endif
class QStateMachine;
class Q_CORE_EXPORT QStateMachinePrivate
#ifndef QT_STATEMACHINE_SOLUTION
: public QObjectPrivate
#endif
{
Q_DECLARE_PUBLIC(QStateMachine)
public:
enum State {
NotRunning,
Starting,
Running
};
enum StopProcessingReason {
EventQueueEmpty,
Finished,
Stopped
};
QStateMachinePrivate();
~QStateMachinePrivate();
static QStateMachinePrivate *get(QStateMachine *q);
static QState *findLCA(const QList<QAbstractState*> &states);
static bool stateEntryLessThan(QAbstractState *s1, QAbstractState *s2);
static bool stateExitLessThan(QAbstractState *s1, QAbstractState *s2);
QAbstractState *findErrorState(QAbstractState *context);
void setError(QStateMachine::Error error, QAbstractState *currentContext);
// private slots
void _q_start();
void _q_process();
void microstep(const QList<QAbstractTransition*> &transitionList);
bool isPreempted(const QAbstractState *s, const QSet<QAbstractTransition*> &transitions) const;
QSet<QAbstractTransition*> selectTransitions(QEvent *event) const;
void exitStates(const QList<QAbstractTransition*> &transitionList);
void executeTransitionContent(const QList<QAbstractTransition*> &transitionList);
void enterStates(const QList<QAbstractTransition*> &enabledTransitions);
void addStatesToEnter(QAbstractState *s, QState *root,
QSet<QAbstractState*> &statesToEnter,
QSet<QAbstractState*> &statesForDefaultEntry);
bool isInFinalState(QAbstractState *s) const;
static bool isFinal(const QAbstractState *s);
static bool isParallel(const QAbstractState *s);
static bool isCompound(const QAbstractState *s);
static bool isAtomic(const QAbstractState *s);
static bool isDescendantOf(const QAbstractState *s, const QAbstractState *other);
static QList<QState*> properAncestors(const QAbstractState *s, const QState *upperBound);
void registerTransitions(QAbstractState *state);
void registerSignalTransition(QSignalTransition *transition);
void unregisterSignalTransition(QSignalTransition *transition);
#ifndef QT_NO_STATEMACHINE_EVENTFILTER
void registerEventTransition(QEventTransition *transition);
void unregisterEventTransition(QEventTransition *transition);
#endif
void unregisterTransition(QAbstractTransition *transition);
void handleTransitionSignal(const QObject *sender, int signalIndex,
void **args);
void scheduleProcess();
typedef QPair<QObject *, QByteArray> RestorableId;
QHash<RestorableId, QVariant> registeredRestorables;
void registerRestorable(QObject *object, const QByteArray &propertyName);
void unregisterRestorable(QObject *object, const QByteArray &propertyName);
bool hasRestorable(QObject *object, const QByteArray &propertyName) const;
QVariant restorableValue(QObject *object, const QByteArray &propertyName) const;
#ifndef QT_NO_ANIMATION
void registerRestorable(QPropertyAnimation *animation);
QPropertyAnimation *restorableAnimation(QObject *object, const QByteArray &propertyName);
QList<QPropertyAnimation *> restorableAnimations() const;
QHash<RestorableId, QPropertyAnimation*> registeredRestorableAnimations;
#endif // QT_NO_ANIMATION
State state;
bool processing;
bool processingScheduled;
bool stop;
StopProcessingReason stopProcessingReason;
QState *rootState;
QSet<QAbstractState*> configuration;
QList<QEvent*> internalEventQueue;
QList<QEvent*> externalEventQueue;
QStateMachine::Error error;
QActionState::RestorePolicy globalRestorePolicy;
QString errorString;
QSet<QAbstractState *> pendingErrorStates;
QSet<QAbstractState *> pendingErrorStatesForDefaultEntry;
QAbstractState *initialErrorStateForRoot;
#ifndef QT_STATEMACHINE_SOLUTION
QSignalEventGenerator *signalEventGenerator;
#endif
QHash<const QObject*, QList<int> > connections;
#ifndef QT_NO_STATEMACHINE_EVENTFILTER
QHash<QObject*, QSet<QEvent::Type> > qobjectEvents;
#endif
QHash<int, QEvent*> delayedEvents;
typedef QEvent* (*f_cloneEvent)(QEvent*);
struct Handler {
f_cloneEvent cloneEvent;
};
static const Handler *handler;
#ifdef QT_STATEMACHINE_SOLUTION
QStateMachine *q_ptr;
#endif
};
QT_END_NAMESPACE
#endif
|
