FCL/sf/mw/qt: comparison src/corelib/statemachine/qstatemachine.cpp

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 \property QStateMachine::globalRestorePolicy
 \brief the restore policy for states of this state machine.
 The default value of this property is
-QStateMachine::DoNotRestoreProperties.
+QStateMachine::DontRestoreProperties.
 */
 #ifndef QT_NO_ANIMATION
 /*!
-\property QStateMachine::animationsEnabled
+\property QStateMachine::animated
 \brief whether animations are enabled
 The default value of this property is true.
 // #define QSTATEMACHINE_DEBUG
 QStateMachinePrivate::QStateMachinePrivate()
 {
+QAbstractStatePrivate::isMachine = true;
 state = NotRunning;
 _startState = 0;
 processing = false;
 processingScheduled = false;
 stop = false;
 stopProcessingReason = EventQueueEmpty;
 error = QStateMachine::NoError;
-globalRestorePolicy = QStateMachine::DoNotRestoreProperties;
+globalRestorePolicy = QStateMachine::DontRestoreProperties;
 signalEventGenerator = 0;
 #ifndef QT_NO_ANIMATION
-animationsEnabled = true;
+animated = true;
 #endif
 }
 QStateMachinePrivate::~QStateMachinePrivate()
 {
 if (!isAtomic(state))
 continue;
 if (isPreempted(state, enabledTransitions))
 continue;
 QList<QState*> lst = properAncestors(state, rootState()->parentState());
-if (QState *grp = qobject_cast<QState*>(state))
+if (QState *grp = toStandardState(state))
 lst.prepend(grp);
 bool found = false;
 for (int j = 0; (j < lst.size()) && !found; ++j) {
 QState *s = lst.at(j);
 QList<QAbstractTransition*> transitions = QStatePrivate::get(s)->transitions();
 }
 QList<QAbstractState*> statesToExit_sorted = statesToExit.toList();
 qSort(statesToExit_sorted.begin(), statesToExit_sorted.end(), stateExitLessThan);
 for (int i = 0; i < statesToExit_sorted.size(); ++i) {
 QAbstractState *s = statesToExit_sorted.at(i);
-if (QState *grp = qobject_cast<QState*>(s)) {
+if (QState *grp = toStandardState(s)) {
 QList<QHistoryState*> hlst = QStatePrivate::get(grp)->historyStates();
 for (int j = 0; j < hlst.size(); ++j) {
 QHistoryState *h = hlst.at(j);
 QHistoryStatePrivate::get(h)->configuration.clear();
 QSet<QAbstractState*>::const_iterator it;
 void QStateMachinePrivate::addStatesToEnter(QAbstractState *s, QState *root,
 QSet<QAbstractState*> &statesToEnter,
 QSet<QAbstractState*> &statesForDefaultEntry)
 {
-	if (QHistoryState *h = qobject_cast<QHistoryState*>(s)) {
+	if (QHistoryState *h = toHistoryState(s)) {
 		QList<QAbstractState*> hconf = QHistoryStatePrivate::get(h)->configuration;
 		if (!hconf.isEmpty()) {
 			for (int k = 0; k < hconf.size(); ++k) {
 				QAbstractState *s0 = hconf.at(k);
 				addStatesToEnter(s0, root, statesToEnter, statesForDefaultEntry);
 Q_ASSERT(error != QStateMachine::NoError);
 return;
 }
 		statesToEnter.insert(s);
 		if (isParallel(s)) {
-			QState *grp = qobject_cast<QState*>(s);
+			QState *grp = toStandardState(s);
 			QList<QAbstractState*> lst = QStatePrivate::get(grp)->childStates();
 			for (int i = 0; i < lst.size(); ++i) {
 				QAbstractState *child = lst.at(i);
 				addStatesToEnter(child, grp, statesToEnter, statesForDefaultEntry);
 			}
 		} else if (isCompound(s)) {
 			statesForDefaultEntry.insert(s);
-			QState *grp = qobject_cast<QState*>(s);
+			QState *grp = toStandardState(s);
 			QAbstractState *initial = grp->initialState();
 			if (initial != 0) {
 Q_ASSERT(initial->machine() == q_func());
 				addStatesToEnter(initial, grp, statesToEnter, statesForDefaultEntry);
 			} else {
 #endif
 // Process the property assignments of the entered states.
 QHash<QAbstractState*, QList<QPropertyAssignment> > propertyAssignmentsForState;
 QHash<RestorableId, QVariant> pendingRestorables = registeredRestorables;
 for (int i = 0; i < enteredStates.size(); ++i) {
-QState *s = qobject_cast<QState*>(enteredStates.at(i));
+QState *s = toStandardState(enteredStates.at(i));
 if (!s)
 continue;
 QList<QPropertyAssignment> assignments = QStatePrivate::get(s)->propertyAssignments;
 for (int j = 0; j < assignments.size(); ++j) {
 }
 }
 // Find the animations to use for the state change.
 QList<QAbstractAnimation*> selectedAnimations;
-if (animationsEnabled) {
+if (animated) {
 for (int i = 0; i < transitionList.size(); ++i) {
 QAbstractTransition *transition = transitionList.at(i);
 selectedAnimations << transition->animations();
 selectedAnimations << defaultAnimationsForSource.values(transition->sourceState());
 if (hasValidEndValue) {
 if (anim->state() == QAbstractAnimation::Running) {
 // The animation is still running. This can happen if the
 // animation is a group, and one of its children just finished,
-// and that caused a state to emit its polished() signal, and
+// and that caused a state to emit its propertiesAssigned() signal, and
 // that triggered a transition in the machine.
 // Just stop the animation so it is correctly restarted again.
 anim->stop();
 }
 anim->start();
 assn.object->setProperty(assn.propertyName, assn.value);
 }
 }
 }
-// Emit polished signal for entered states that have no animated properties.
+// Emit propertiesAssigned signal for entered states that have no animated properties.
 for (int i = 0; i < enteredStates.size(); ++i) {
-QState *s = qobject_cast<QState*>(enteredStates.at(i));
+QState *s = toStandardState(enteredStates.at(i));
 if (s
 #ifndef QT_NO_ANIMATION
 && !animationsForState.contains(s)
 #endif
 )
-QStatePrivate::get(s)->emitPolished();
+QStatePrivate::get(s)->emitPropertiesAssigned();
 }
 }
 #endif // QT_NO_PROPERTIES
 bool QStateMachinePrivate::isFinal(const QAbstractState *s)
 {
-return qobject_cast<const QFinalState*>(s) != 0;
+return s && (QAbstractStatePrivate::get(s)->stateType == QAbstractStatePrivate::FinalState);
 }
 bool QStateMachinePrivate::isParallel(const QAbstractState *s)
 {
-const QState *ss = qobject_cast<const QState*>(s);
+const QState *ss = toStandardState(s);
 return ss && (QStatePrivate::get(ss)->childMode == QState::ParallelStates);
 }
 bool QStateMachinePrivate::isCompound(const QAbstractState *s) const
 {
-const QState *group = qobject_cast<const QState*>(s);
+const QState *group = toStandardState(s);
 if (!group)
 return false;
-bool isMachine = (qobject_cast<const QStateMachine*>(group) != 0);
+bool isMachine = QStatePrivate::get(group)->isMachine;
 // Don't treat the machine as compound if it's a sub-state of this machine
 if (isMachine && (group != rootState()))
 return false;
 return (!isParallel(group) && !QStatePrivate::get(group)->childStates().isEmpty())
 || isMachine;
 }
 bool QStateMachinePrivate::isAtomic(const QAbstractState *s) const
 {
-const QState *ss = qobject_cast<const QState*>(s);
+const QState *ss = toStandardState(s);
 return (ss && QStatePrivate::get(ss)->childStates().isEmpty())
 || isFinal(s)
 // Treat the machine as atomic if it's a sub-state of this machine
-|| (ss && (qobject_cast<const QStateMachine*>(ss) != 0) && (ss != rootState()));
+|| (ss && QStatePrivate::get(ss)->isMachine && (ss != rootState()));
 }
 bool QStateMachinePrivate::isDescendantOf(const QAbstractState *state, const QAbstractState *other)
 {
 result.append(s);
 }
 return result;
 }
+QState *QStateMachinePrivate::toStandardState(QAbstractState *state)
+{
+if (state && (QAbstractStatePrivate::get(state)->stateType == QAbstractStatePrivate::StandardState))
+return static_cast<QState*>(state);
+return 0;
+}
+const QState *QStateMachinePrivate::toStandardState(const QAbstractState *state)
+{
+if (state && (QAbstractStatePrivate::get(state)->stateType == QAbstractStatePrivate::StandardState))
+return static_cast<const QState*>(state);
+return 0;
+}
+QFinalState *QStateMachinePrivate::toFinalState(QAbstractState *state)
+{
+if (state && (QAbstractStatePrivate::get(state)->stateType == QAbstractStatePrivate::FinalState))
+return static_cast<QFinalState*>(state);
+return 0;
+}
+QHistoryState *QStateMachinePrivate::toHistoryState(QAbstractState *state)
+{
+if (state && (QAbstractStatePrivate::get(state)->stateType == QAbstractStatePrivate::HistoryState))
+return static_cast<QHistoryState*>(state);
+return 0;
+}
 bool QStateMachinePrivate::isInFinalState(QAbstractState* s) const
 {
 if (isCompound(s)) {
-QState *grp = qobject_cast<QState*>(s);
+QState *grp = toStandardState(s);
 QList<QAbstractState*> lst = QStatePrivate::get(grp)->childStates();
 for (int i = 0; i < lst.size(); ++i) {
 QAbstractState *cs = lst.at(i);
 if (isFinal(cs) && configuration.contains(cs))
 return true;
 }
 return false;
 } else if (isParallel(s)) {
-QState *grp = qobject_cast<QState*>(s);
+QState *grp = toStandardState(s);
 QList<QAbstractState*> lst = QStatePrivate::get(grp)->childStates();
 for (int i = 0; i < lst.size(); ++i) {
 QAbstractState *cs = lst.at(i);
 if (!isInFinalState(cs))
 return false;
 QAbstractState *QStateMachinePrivate::findErrorState(QAbstractState *context)
 {
 // Find error state recursively in parent hierarchy if not set explicitly for context state
 QAbstractState *errorState = 0;
 if (context != 0) {
-QState *s = qobject_cast<QState*>(context);
+QState *s = toStandardState(context);
 if (s != 0)
 errorState = s->errorState();
 if (errorState == 0)
 errorState = findErrorState(context->parentState());
 Q_ASSERT(it != animationsForState.end());
 QList<QAbstractAnimation*> &animations = it.value();
 animations.removeOne(anim);
 if (animations.isEmpty()) {
 animationsForState.erase(it);
-QStatePrivate::get(qobject_cast<QState*>(state))->emitPolished();
+QStatePrivate::get(toStandardState(state))->emitPropertiesAssigned();
 }
 }
 #endif // !QT_NO_ANIMATION
 enabledTransitions = selectTransitions(e);
 if (enabledTransitions.isEmpty()) {
 delete e;
 e = 0;
 }
-if (enabledTransitions.isEmpty() && !internalEventQueue.isEmpty()) {
+if (enabledTransitions.isEmpty() && ((e = dequeueInternalEvent()) != 0)) {
-e = internalEventQueue.takeFirst();
 #ifdef QSTATEMACHINE_DEBUG
 qDebug() << q << ": dequeued internal event" << e << "of type" << e->type();
 #endif
 enabledTransitions = selectTransitions(e);
 if (enabledTransitions.isEmpty()) {
 delete e;
 e = 0;
 }
 }
 if (enabledTransitions.isEmpty()) {
-if (externalEventQueue.isEmpty()) {
+if ((e = dequeueExternalEvent()) != 0) {
-if (internalEventQueue.isEmpty()) {
-processing = false;
-stopProcessingReason = EventQueueEmpty;
-}
-} else {
-e = externalEventQueue.takeFirst();
 #ifdef QSTATEMACHINE_DEBUG
 qDebug() << q << ": dequeued external event" << e << "of type" << e->type();
 #endif
 enabledTransitions = selectTransitions(e);
 if (enabledTransitions.isEmpty()) {
 delete e;
 e = 0;
+}
+} else {
+if (isInternalEventQueueEmpty()) {
+processing = false;
+stopProcessingReason = EventQueueEmpty;
 }
 }
 }
 if (!enabledTransitions.isEmpty()) {
 q->beginMicrostep(e);
 emit q->stopped();
 break;
 }
 }
+void QStateMachinePrivate::postInternalEvent(QEvent *e)
+{
+QMutexLocker locker(&internalEventMutex);
+internalEventQueue.append(e);
+}
+void QStateMachinePrivate::postExternalEvent(QEvent *e)
+{
+QMutexLocker locker(&externalEventMutex);
+externalEventQueue.append(e);
+}
+QEvent *QStateMachinePrivate::dequeueInternalEvent()
+{
+QMutexLocker locker(&internalEventMutex);
+if (internalEventQueue.isEmpty())
+return 0;
+return internalEventQueue.takeFirst();
+}
+QEvent *QStateMachinePrivate::dequeueExternalEvent()
+{
+QMutexLocker locker(&externalEventMutex);
+if (externalEventQueue.isEmpty())
+return 0;
+return externalEventQueue.takeFirst();
+}
+bool QStateMachinePrivate::isInternalEventQueueEmpty()
+{
+QMutexLocker locker(&internalEventMutex);
+return internalEventQueue.isEmpty();
+}
+bool QStateMachinePrivate::isExternalEventQueueEmpty()
+{
+QMutexLocker locker(&externalEventMutex);
+return externalEventQueue.isEmpty();
+}
 void QStateMachinePrivate::processEvents(EventProcessingMode processingMode)
 {
+Q_Q(QStateMachine);
 if ((state != Running) || processing || processingScheduled)
 return;
 switch (processingMode) {
 case DirectProcessing:
-_q_process();
+if (QThread::currentThread() == q->thread()) {
-break;
+_q_process();
+break;
+} // fallthrough -- processing must be done in the machine thread
 case QueuedProcessing:
 processingScheduled = true;
-QMetaObject::invokeMethod(q_func(), "_q_process", Qt::QueuedConnection);
+QMetaObject::invokeMethod(q, "_q_process", Qt::QueuedConnection);
 break;
 }
 }
 void QStateMachinePrivate::cancelAllDelayedEvents()
 {
 Q_Q(QStateMachine);
+QMutexLocker locker(&delayedEventsMutex);
 QHash<int, QEvent*>::const_iterator it;
 for (it = delayedEvents.constBegin(); it != delayedEvents.constEnd(); ++it) {
 int id = it.key();
 QEvent *e = it.value();
 q->killTimer(id);
 QState *sourceState = 0;
 if (state == Running) {
 QSet<QAbstractState*>::const_iterator it;
 for (it = configuration.constBegin(); it != configuration.constEnd(); ++it) {
-sourceState = qobject_cast<QState*>(*it);
+sourceState = toStandardState(*it);
 if (sourceState != 0)
 break;
 }
 } else {
 sourceState = startState();
 processEvents(QueuedProcessing);
 }
 void QStateMachinePrivate::registerTransitions(QAbstractState *state)
 {
-QState *group = qobject_cast<QState*>(state);
+QState *group = toStandardState(state);
 if (!group)
 return;
 QList<QAbstractTransition*> transitions = QStatePrivate::get(group)->transitions();
 for (int i = 0; i < transitions.size(); ++i) {
 QAbstractTransition *t = transitions.at(i);
 }
 QEventTransitionPrivate::get(transition)->registered = false;
 }
 void QStateMachinePrivate::handleFilteredEvent(QObject *watched, QEvent *event)
 {
-Q_ASSERT(qobjectEvents.contains(watched));
+if (qobjectEvents.value(watched).contains(event->type())) {
-if (qobjectEvents[watched].contains(event->type())) {
+postInternalEvent(new QStateMachine::WrappedEvent(watched, handler->cloneEvent(event)));
-internalEventQueue.append(new QStateMachine::WrappedEvent(watched, handler->cloneEvent(event)));
 processEvents(DirectProcessing);
 }
 }
 #endif
 #ifdef QSTATEMACHINE_DEBUG
 qDebug() << q_func() << ": sending signal event ( sender =" << sender
 << ", signal =" << sender->metaObject()->method(signalIndex).signature() << ')';
 #endif
-internalEventQueue.append(new QStateMachine::SignalEvent(sender, signalIndex, vargs));
+postInternalEvent(new QStateMachine::SignalEvent(sender, signalIndex, vargs));
 processEvents(DirectProcessing);
 }
 /*!
 Constructs a new state machine with the given \a parent.
 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.
-\value DoNotRestoreProperties The state machine should not save the initial values of properties
+\value DontRestoreProperties The state machine should not save the initial values of properties
 and restore them later.
 \value RestoreProperties The state machine should save the initial values of properties
 and restore them later.
 \sa QStateMachine::globalRestorePolicy QState::assignProperty()
 return d->globalRestorePolicy;
 }
 /*!
 Sets the restore policy of the state machine to \a restorePolicy. The default
-restore policy is QAbstractState::DoNotRestoreProperties.
+restore policy is QAbstractState::DontRestoreProperties.
 \sa globalRestorePolicy()
 */
 void QStateMachine::setGlobalRestorePolicy(QStateMachine::RestorePolicy restorePolicy)
 {
 break;
 }
 }
 /*!
+\threadsafe
 Posts the given \a event of the given \a priority for processing by this
 state machine.
 This function returns immediately. The event is added to the state machine's
 event queue. Events are processed in the order posted. The state machine
 #ifdef QSTATEMACHINE_DEBUG
 qDebug() << this << ": posting event" << event;
 #endif
 switch (priority) {
 case NormalPriority:
-d->externalEventQueue.append(event);
+d->postExternalEvent(event);
 break;
 case HighPriority:
-d->internalEventQueue.append(event);
+d->postInternalEvent(event);
 break;
 }
 d->processEvents(QStateMachinePrivate::QueuedProcessing);
 }
 /*!
+\threadsafe
 Posts the given \a event for processing by this state machine, with the
 given \a delay in milliseconds. Returns an identifier associated with the
 delayed event, or -1 if the event could not be posted.
 This function returns immediately. When the delay has expired, the event
 return -1;
 }
 #ifdef QSTATEMACHINE_DEBUG
 qDebug() << this << ": posting event" << event << "with delay" << delay;
 #endif
+QMutexLocker locker(&d->delayedEventsMutex);
 int tid = startTimer(delay);
 d->delayedEvents[tid] = event;
 return tid;
 }
 /*!
+\threadsafe
 Cancels the delayed event identified by the given \a id. The id should be a
 value returned by a call to postDelayedEvent(). Returns true if the event
 was successfully cancelled, otherwise returns false.
 \sa postDelayedEvent()
 Q_D(QStateMachine);
 if (d->state != QStateMachinePrivate::Running) {
 qWarning("QStateMachine::cancelDelayedEvent: the machine is not running");
 return false;
 }
+QMutexLocker locker(&d->delayedEventsMutex);
 QEvent *e = d->delayedEvents.take(id);
 if (!e)
 return false;
 killTimer(id);
 delete e;
 return true;
 }
 /*!
-\internal
 Returns the maximal consistent set of states (including parallel and final
 states) that this state machine is currently in. If a state \c s is in the
 configuration, it is always the case that the parent of \c s is also in
 c. Note, however, that the machine itself is not an explicit member of the
 configuration.
 if (e->type() == QEvent::Timer) {
 QTimerEvent *te = static_cast<QTimerEvent*>(e);
 int tid = te->timerId();
 if (d->state != QStateMachinePrivate::Running) {
 // This event has been cancelled already
+QMutexLocker locker(&d->delayedEventsMutex);
 Q_ASSERT(!d->delayedEvents.contains(tid));
 return true;
 }
+d->delayedEventsMutex.lock();
 QEvent *ee = d->delayedEvents.take(tid);
 if (ee != 0) {
 killTimer(tid);
-d->externalEventQueue.append(ee);
+d->delayedEventsMutex.unlock();
+d->postExternalEvent(ee);
 d->processEvents(QStateMachinePrivate::DirectProcessing);
 return true;
-}
+} else {
-}
+d->delayedEventsMutex.unlock();
-return QObject::event(e);
+}
+}
+return QState::event(e);
 }
 #ifndef QT_NO_STATEMACHINE_EVENTFILTER
 /*!
 \reimp
 #ifndef QT_NO_ANIMATION
 /*!
 Returns whether animations are enabled for this state machine.
 */
-bool QStateMachine::animationsEnabled() const
+bool QStateMachine::isAnimated() const
 {
 Q_D(const QStateMachine);
-return d->animationsEnabled;
+return d->animated;
 }
 /*!
 Sets whether animations are \a enabled for this state machine.
 */
-void QStateMachine::setAnimationsEnabled(bool enabled)
+void QStateMachine::setAnimated(bool enabled)
 {
 Q_D(QStateMachine);
-d->animationsEnabled = enabled;
+d->animated = enabled;
 }
 /*!
 Adds a default \a animation to be considered for any transition.
 */

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7
child 7	f7bc934e204c