#include <qstatemachine_p.h>

Inheritance diagram for QStateMachinePrivate:

Classes
struct	Handler

Public Types
enum	EventProcessingMode { DirectProcessing, QueuedProcessing }

typedef QEvent (	f_cloneEvent) (QEvent *)

typedef QPair< QObject *, QByteArray >	RestorableId

enum	State { NotRunning, Starting, Running }

enum	StopProcessingReason { EventQueueEmpty, Finished, Stopped }

Public Types inherited from QAbstractStatePrivate
enum	StateType { AbstractState, StandardState, FinalState, HistoryState }

Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject , QMetaObject::Call, int, void *)

Public Functions
void	_q_animationFinished ()

void	_q_process ()

void	_q_start ()

void	addStatesToEnter (QAbstractState s, QState root, QSet< QAbstractState > &statesToEnter, QSet< QAbstractState > &statesForDefaultEntry)

void	applyProperties (const QList< QAbstractTransition > &transitionList, const QList< QAbstractState > &exitedStates, const QList< QAbstractState *> &enteredStates)

void	cancelAllDelayedEvents ()

void	clearHistory ()

QEvent *	dequeueExternalEvent ()

QEvent *	dequeueInternalEvent ()

QList< QAbstractState * >	enterStates (QEvent event, const QList< QAbstractTransition > &enabledTransitions)

void	executeTransitionContent (QEvent event, const QList< QAbstractTransition > &transitionList)

QList< QAbstractState * >	exitStates (QEvent event, const QList< QAbstractTransition > &transitionList)

QAbstractState *	findErrorState (QAbstractState *context)

QState *	findLCA (const QList< QAbstractState *> &states) const

void	goToState (QAbstractState *targetState)
	Causes this state machine to unconditionally transition to the given targetState. More...

void	handleFilteredEvent (QObject watched, QEvent event)

void	handleTransitionSignal (QObject sender, int signalIndex, void *args)

bool	hasRestorable (QObject *object, const QByteArray &propertyName) const
	Returns true if the variable with the given id has been registered for restoration. More...

QPair< QList< QAbstractAnimation * >, QList< QAbstractAnimation * > >	initializeAnimation (QAbstractAnimation *abstractAnimation, const QPropertyAssignment &prop)

bool	isAtomic (const QAbstractState *s) const

bool	isCompound (const QAbstractState *s) const

bool	isExternalEventQueueEmpty ()

bool	isInFinalState (QAbstractState *s) const

bool	isInternalEventQueueEmpty ()

bool	isPreempted (const QAbstractState s, const QSet< QAbstractTransition > &transitions) const

void	microstep (QEvent event, const QList< QAbstractTransition > &transitionList)

void	postExternalEvent (QEvent *e)

void	postInternalEvent (QEvent *e)

void	processEvents (EventProcessingMode processingMode)

	QStateMachinePrivate ()

void	registerEventTransition (QEventTransition *transition)

void	registerRestorable (QObject *object, const QByteArray &propertyName)

void	registerSignalTransition (QSignalTransition *transition)

void	registerTransitions (QAbstractState *state)

void	removeStartState ()

QList< QPropertyAssignment >	restorablesToPropertyList (const QHash< RestorableId, QVariant > &restorables) const

QVariant	restorableValue (QObject *object, const QByteArray &propertyName) const

QState *	rootState () const

QSet< QAbstractTransition * >	selectTransitions (QEvent *event) const

void	setError (QStateMachine::Error error, QAbstractState *currentContext)

QState *	startState ()

void	unregisterAllTransitions ()

void	unregisterEventTransition (QEventTransition *transition)

void	unregisterRestorable (QObject *object, const QByteArray &propertyName)

void	unregisterSignalTransition (QSignalTransition *transition)

void	unregisterTransition (QAbstractTransition *transition)

	~QStateMachinePrivate ()

Public Functions inherited from QStatePrivate
QList< QAbstractState * >	childStates () const

void	emitFinished ()

void	emitPropertiesAssigned ()

QList< QHistoryState * >	historyStates () const

	QStatePrivate ()

QList< QAbstractTransition * >	transitions () const

	~QStatePrivate ()

Public Functions inherited from QAbstractStatePrivate
void	callOnEntry (QEvent *e)

void	callOnExit (QEvent *e)

void	emitEntered ()

void	emitExited ()

QStateMachine *	machine () const

	QAbstractStatePrivate (StateType type)

Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)

void	addConnection (int signal, Connection *c)

void	cleanConnectionLists ()

void	connectNotify (const char *signal)

void	deleteChildren ()

void	disconnectNotify (const char *signal)

bool	isSender (const QObject receiver, const char signal) const

bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...

void	moveToThread_helper ()

	QObjectPrivate (int version=QObjectPrivateVersion)

QObjectList	receiverList (const char *signal) const

QObjectList	senderList () const

void	setParent_helper (QObject *)

void	setThreadData_helper (QThreadData currentData, QThreadData targetData)

int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...

virtual	~QObjectPrivate ()

Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Static Public Functions
static QStateMachinePrivate *	get (QStateMachine *q)

static bool	isDescendantOf (const QAbstractState s, const QAbstractState other)

static bool	isFinal (const QAbstractState *s)

static bool	isParallel (const QAbstractState *s)

static QList< QState * >	properAncestors (const QAbstractState s, const QState upperBound)

static bool	stateEntryLessThan (QAbstractState s1, QAbstractState s2)

static bool	stateExitLessThan (QAbstractState s1, QAbstractState s2)

static QFinalState *	toFinalState (QAbstractState *state)

static QHistoryState *	toHistoryState (QAbstractState *state)

static QState *	toStandardState (QAbstractState *state)

static const QState *	toStandardState (const QAbstractState *state)

Static Public Functions inherited from QStatePrivate
static QStatePrivate *	get (QState *q)

static const QStatePrivate *	get (const QState *q)

Static Public Functions inherited from QAbstractStatePrivate
static QAbstractStatePrivate *	get (QAbstractState *q)

static const QAbstractStatePrivate *	get (const QAbstractState *q)

Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)

static QObjectPrivate *	get (QObject *o)

static void	resetCurrentSender (QObject receiver, Sender currentSender, Sender *previousSender)

static Sender *	setCurrentSender (QObject receiver, Sender sender)

static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Public Variables
QState *	_startState

bool	animated

QHash< QAbstractState , QList< QAbstractAnimation > >	animationsForState

QSet< QAbstractState * >	configuration

QHash< const QObject *, QVector< int > >	connections

QList< QAbstractAnimation * >	defaultAnimations

QMultiHash< QAbstractState , QAbstractAnimation >	defaultAnimationsForSource

QMultiHash< QAbstractState , QAbstractAnimation >	defaultAnimationsForTarget

QHash< int, QEvent * >	delayedEvents

QMutex	delayedEventsMutex

QStateMachine::Error	error

QString	errorString

QMutex	externalEventMutex

QList< QEvent * >	externalEventQueue

QStateMachine::RestorePolicy	globalRestorePolicy

QMutex	internalEventMutex

QList< QEvent * >	internalEventQueue

QSet< QAbstractState * >	pendingErrorStates

QSet< QAbstractState * >	pendingErrorStatesForDefaultEntry

bool	processing

bool	processingScheduled

QHash< QAbstractAnimation *, QPropertyAssignment >	propertyForAnimation

QHash< QObject *, QHash< QEvent::Type, int > >	qobjectEvents

QHash< RestorableId, QVariant >	registeredRestorables

QSet< QAbstractAnimation * >	resetAnimationEndValues

QSignalEventGenerator *	signalEventGenerator

State	state

QHash< QAbstractAnimation , QAbstractState >	stateForAnimation

bool	stop

StopProcessingReason	stopProcessingReason

Public Variables inherited from QStatePrivate
QState::ChildMode	childMode

QList< QAbstractState * >	childStatesList

bool	childStatesListNeedsRefresh

QAbstractState *	errorState

QAbstractState *	initialState

QList< QPropertyAssignment >	propertyAssignments

QList< QAbstractTransition * >	transitionsList

bool	transitionsListNeedsRefresh

Public Variables inherited from QAbstractStatePrivate
uint	isMachine:1

QState *	parentState

uint	stateType:31

Public Variables inherited from QObjectPrivate
union {
QObject * currentChildBeingDeleted

QAbstractDeclarativeData * declarativeData

};

quint32	connectedSignals [2]

QObjectConnectionListVector *	connectionLists

Sender *	currentSender

QList< QPointer< QObject > >	eventFilters

ExtraData *	extraData

QString	objectName

Connection *	senders

QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount

QThreadData *	threadData

void *	unused

Public Variables inherited from QObjectData
uint	blockSig: 1

QObjectList	children

uint	hasGuards: 1

uint	inEventHandler: 1

uint	inThreadChangeEvent: 1

uint	isWidget: 1

QMetaObject *	metaObject

uint	ownObjectName: 1

QObject *	parent

uint	pendTimer: 1

int	postedEvents

QObject *	q_ptr

uint	receiveChildEvents: 1

uint	sendChildEvents: 1

uint	unused: 22

uint	wasDeleted: 1

Static Public Variables
static const Handler *	handler = &qt_kernel_statemachine_handler

Detailed Description

Definition at line 85 of file qstatemachine_p.h.

Typedefs

◆ f_cloneEvent

typedef QEvent*(* QStateMachinePrivate::f_cloneEvent) (QEvent *)

Definition at line 238 of file qstatemachine_p.h.

◆ RestorableId

typedef QPair<QObject *, QByteArray> QStateMachinePrivate::RestorableId

Definition at line 183 of file qstatemachine_p.h.

Enumerations

◆ EventProcessingMode

enum QStateMachinePrivate::EventProcessingMode

Enumerator
DirectProcessing
QueuedProcessing

Definition at line 94 of file qstatemachine_p.h.

                              {
         DirectProcessing,
         QueuedProcessing
     };

◆ State

enum QStateMachinePrivate::State

Enumerator
NotRunning
Starting
Running

Definition at line 89 of file qstatemachine_p.h.

                {
         NotRunning,
         Starting,
         Running
     };

◆ StopProcessingReason

enum QStateMachinePrivate::StopProcessingReason

Enumerator
EventQueueEmpty
Finished
Stopped

Definition at line 98 of file qstatemachine_p.h.

                               {
         EventQueueEmpty,
         Finished,
         Stopped
     };

Constructors and Destructors

◆ QStateMachinePrivate()

QStateMachinePrivate::QStateMachinePrivate ( )

Definition at line 190 of file qstatemachine.cpp.

 {
     isMachine = true;
 
     state = NotRunning;
     _startState = 0;
     processing = false;
     processingScheduled = false;
     stop = false;
     stopProcessingReason = EventQueueEmpty;
     error = QStateMachine::NoError;
     globalRestorePolicy = QStateMachine::DontRestoreProperties;
     signalEventGenerator = 0;
 #ifndef QT_NO_ANIMATION
     animated = true;
 #endif
 }

◆ ~QStateMachinePrivate()

QStateMachinePrivate::~QStateMachinePrivate ( )

Definition at line 208 of file qstatemachine.cpp.

 {
     qDeleteAll(internalEventQueue);
     qDeleteAll(externalEventQueue);
 }

Functions

◆ _q_animationFinished()

void QStateMachinePrivate::_q_animationFinished ( )

Definition at line 1118 of file qstatemachine.cpp.

Referenced by applyProperties().

 {
     Q_Q(QStateMachine);
     QAbstractAnimation *anim = qobject_cast<QAbstractAnimation*>(q->sender());
     Q_ASSERT(anim != 0);
     QObject::disconnect(anim, SIGNAL(finished()), q, SLOT(_q_animationFinished()));
     if (resetAnimationEndValues.contains(anim)) {
         qobject_cast<QVariantAnimation*>(anim)->setEndValue(QVariant()); // ### generalize
         resetAnimationEndValues.remove(anim);
     }
 
 #ifndef QT_NO_PROPERTIES
     // Set the final property value.
     QPropertyAssignment assn = propertyForAnimation.take(anim);
     Q_ASSERT(assn.object != 0);
     assn.object->setProperty(assn.propertyName, assn.value);
     if (!assn.explicitlySet)
         unregisterRestorable(assn.object, assn.propertyName);
 #endif
 
     QAbstractState *state = stateForAnimation.take(anim);
     Q_ASSERT(state != 0);
     QHash<QAbstractState*, QList<QAbstractAnimation*> >::iterator it;
     it = animationsForState.find(state);
     Q_ASSERT(it != animationsForState.end());
     QList<QAbstractAnimation*> &animations = it.value();
     animations.removeOne(anim);
     if (animations.isEmpty()) {
         animationsForState.erase(it);
         QStatePrivate::get(toStandardState(state))->emitPropertiesAssigned();
     }
 }

◆ _q_process()

void QStateMachinePrivate::_q_process ( )

Definition at line 1250 of file qstatemachine.cpp.

Referenced by _q_start(), and processEvents().

 {
     Q_Q(QStateMachine);
     Q_ASSERT(state == Running);
     Q_ASSERT(!processing);
     processing = true;
     processingScheduled = false;
 #ifdef QSTATEMACHINE_DEBUG
     qDebug() << q << ": starting the event processing loop";
 #endif
     while (processing) {
         if (stop) {
             processing = false;
             break;
         }
         QSet<QAbstractTransition*> enabledTransitions;
         QEvent *e = new QEvent(QEvent::None);
         enabledTransitions = selectTransitions(e);
         if (enabledTransitions.isEmpty()) {
             delete e;
             e = 0;
         }
         if (enabledTransitions.isEmpty() && ((e = dequeueInternalEvent()) != 0)) {
 #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 ((e = dequeueExternalEvent()) != 0) {
 #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);
             microstep(e, enabledTransitions.toList());
             q->endMicrostep(e);
         }
 #ifdef QSTATEMACHINE_DEBUG
         else {
             qDebug() << q << ": no transitions enabled";
         }
 #endif
         delete e;
     }
 #ifdef QSTATEMACHINE_DEBUG
     qDebug() << q << ": finished the event processing loop";
 #endif
     if (stop) {
         stop = false;
         stopProcessingReason = Stopped;
     }
 
     switch (stopProcessingReason) {
     case EventQueueEmpty:
         break;
     case Finished:
         state = NotRunning;
         cancelAllDelayedEvents();
         unregisterAllTransitions();
         emit q->finished();
         break;
     case Stopped:
         state = NotRunning;
         cancelAllDelayedEvents();
         unregisterAllTransitions();
         emit q->stopped();
         break;
     }
 }

◆ _q_start()

void QStateMachinePrivate::_q_start ( )

Definition at line 1202 of file qstatemachine.cpp.

 {
     Q_Q(QStateMachine);
     Q_ASSERT(state == Starting);
     Q_ASSERT(rootState() != 0);
     QAbstractState *initial = rootState()->initialState();
     configuration.clear();
     qDeleteAll(internalEventQueue);
     internalEventQueue.clear();
     qDeleteAll(externalEventQueue);
     externalEventQueue.clear();
     clearHistory();
 
 #ifdef QSTATEMACHINE_DEBUG
     qDebug() << q << ": starting";
 #endif
     state = Running;
     processingScheduled = true; // we call _q_process() below
     emit q->started();
 
     QState *start = startState();
     Q_ASSERT(start != 0);
 
     QList<QAbstractTransition*> transitions = QStatePrivate::get(start)->transitions();
 
     // If a transition has already been added, then we skip this step, as the
     // initial transition in that case has been overridden.
     if (transitions.isEmpty()) {
         QAbstractTransition *initialTransition = new InitialTransition(initial);
         start->addTransition(initialTransition);
         transitions.append(initialTransition);
     }
 
     QEvent nullEvent(QEvent::None);
     executeTransitionContent(&nullEvent, transitions);
     QList<QAbstractState*> enteredStates = enterStates(&nullEvent, transitions);
 #ifndef QT_NO_PROPERTIES
     applyProperties(transitions, QList<QAbstractState*>() << start,
                     enteredStates);
 #endif
     removeStartState();
 
 #ifdef QSTATEMACHINE_DEBUG
     qDebug() << q << ": initial configuration:" << configuration;
 #endif
     _q_process();
 }

◆ addStatesToEnter()

void QStateMachinePrivate::addStatesToEnter	(	QAbstractState *	s,
		QState *	root,
		QSet< QAbstractState *> &	statesToEnter,
		QSet< QAbstractState *> &	statesForDefaultEntry
	)

Definition at line 575 of file qstatemachine.cpp.

Referenced by enterStates(), and setError().

 {
     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);
             }
     #ifdef QSTATEMACHINE_DEBUG
             qDebug() <<q_func() << ": restoring"
                     << ((QHistoryStatePrivate::get(h)->historyType == QHistoryState::DeepHistory) ? "deep" : "shallow")
                     << "history from" << s << ':' << hconf;
     #endif
         } else {
             QList<QAbstractState*> hlst;
             if (QHistoryStatePrivate::get(h)->defaultState)
                 hlst.append(QHistoryStatePrivate::get(h)->defaultState);
 
             if (hlst.isEmpty()) {
                 setError(QStateMachine::NoDefaultStateInHistoryStateError, h);
             } else {
                 for (int k = 0; k < hlst.size(); ++k) {
                     QAbstractState *s0 = hlst.at(k);
                     addStatesToEnter(s0, root, statesToEnter, statesForDefaultEntry);
                 }
     #ifdef QSTATEMACHINE_DEBUG
                 qDebug() << q_func() << ": initial history targets for" << s << ':' << hlst;
     #endif
             }
         }
     } else {
             if (s == rootState()) {
                 // Error has already been set by exitStates().
                 Q_ASSERT(error != QStateMachine::NoError);
                 return;
             }
         statesToEnter.insert(s);
         if (isParallel(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 = toStandardState(s);
             QAbstractState *initial = grp->initialState();
             if (initial != 0) {
                             Q_ASSERT(initial->machine() == q_func());
                 addStatesToEnter(initial, grp, statesToEnter, statesForDefaultEntry);
             } else {
                 setError(QStateMachine::NoInitialStateError, grp);
                 return;
             }
         }
         QList<QState*> ancs = properAncestors(s, root);
         for (int i = 0; i < ancs.size(); ++i) {
             QState *anc = ancs.at(i);
             if (!anc->parentState())
                 continue;
             statesToEnter.insert(anc);
             if (isParallel(anc)) {
                 QList<QAbstractState*> lst = QStatePrivate::get(anc)->childStates();
                 for (int j = 0; j < lst.size(); ++j) {
                     QAbstractState *child = lst.at(j);
                     bool hasDescendantInList = false;
                     QSet<QAbstractState*>::const_iterator it;
                     for (it = statesToEnter.constBegin(); it != statesToEnter.constEnd(); ++it) {
                         if (isDescendantOf(*it, child)) {
                             hasDescendantInList = true;
                             break;
                         }
                     }
                     if (!hasDescendantInList)
                         addStatesToEnter(child, anc, statesToEnter, statesForDefaultEntry);
                 }
             }
         }
     }
 }

◆ applyProperties()

void QStateMachinePrivate::applyProperties	(	const QList< QAbstractTransition *> &	transitionList,
		const QList< QAbstractState *> &	exitedStates,
		const QList< QAbstractState *> &	enteredStates
	)

Definition at line 662 of file qstatemachine.cpp.

Referenced by _q_start(), and microstep().

 {
 #ifdef QT_NO_ANIMATION
     Q_UNUSED(transitionList);
     Q_UNUSED(exitedStates);
 #else
     Q_Q(QStateMachine);
 #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 = toStandardState(enteredStates.at(i));
         if (!s)
             continue;
 
         QList<QPropertyAssignment> assignments = QStatePrivate::get(s)->propertyAssignments;
         for (int j = 0; j < assignments.size(); ++j) {
             const QPropertyAssignment &assn = assignments.at(j);
             if (globalRestorePolicy == QStateMachine::RestoreProperties) {
                 registerRestorable(assn.object, assn.propertyName);
             }
             pendingRestorables.remove(RestorableId(assn.object, assn.propertyName));
             propertyAssignmentsForState[s].append(assn);
         }
 
         // Remove pending restorables for all parent states to avoid restoring properties
         // before the state that assigned them is exited. If state does not explicitly
         // assign a property which is assigned by the parent, it inherits the parent's assignment.
         QState *parentState = s;
         while ((parentState = parentState->parentState()) != 0) {
             assignments = QStatePrivate::get(parentState)->propertyAssignments;
             for (int j=0; j<assignments.size(); ++j) {
                 const QPropertyAssignment &assn = assignments.at(j);
                 int c = pendingRestorables.remove(RestorableId(assn.object, assn.propertyName));
                 if (c > 0)
                     propertyAssignmentsForState[s].append(assn);
             }
         }
     }
     if (!pendingRestorables.isEmpty()) {
         QAbstractState *s;
         if (!enteredStates.isEmpty())
             s = enteredStates.last(); // ### handle if parallel
         else
             s = 0;
         propertyAssignmentsForState[s] << restorablesToPropertyList(pendingRestorables);
     }
 
 #ifndef QT_NO_ANIMATION
     // Gracefully terminate playing animations for states that are exited.
     for (int i = 0; i < exitedStates.size(); ++i) {
         QAbstractState *s = exitedStates.at(i);
         QList<QAbstractAnimation*> animations = animationsForState.take(s);
         for (int j = 0; j < animations.size(); ++j) {
             QAbstractAnimation *anim = animations.at(j);
             QObject::disconnect(anim, SIGNAL(finished()), q, SLOT(_q_animationFinished()));
             stateForAnimation.remove(anim);
 
             // Stop the (top-level) animation.
             // ### Stopping nested animation has weird behavior.
             QAbstractAnimation *topLevelAnim = anim;
             while (QAnimationGroup *group = topLevelAnim->group())
                 topLevelAnim = group;
             topLevelAnim->stop();
 
             if (resetAnimationEndValues.contains(anim)) {
                 qobject_cast<QVariantAnimation*>(anim)->setEndValue(QVariant()); // ### generalize
                 resetAnimationEndValues.remove(anim);
             }
             QPropertyAssignment assn = propertyForAnimation.take(anim);
             Q_ASSERT(assn.object != 0);
             // If there is no property assignment that sets this property,
             // set the property to its target value.
             bool found = false;
             QHash<QAbstractState*, QList<QPropertyAssignment> >::const_iterator it;
             for (it = propertyAssignmentsForState.constBegin(); it != propertyAssignmentsForState.constEnd(); ++it) {
                 const QList<QPropertyAssignment> &assignments = it.value();
                 for (int k = 0; k < assignments.size(); ++k) {
                     if ((assignments.at(k).object == assn.object)
                         && (assignments.at(k).propertyName == assn.propertyName)) {
                         found = true;
                         break;
                     }
                 }
             }
             if (!found) {
                 assn.object->setProperty(assn.propertyName, assn.value);
             }
         }
     }
 
     // Find the animations to use for the state change.
     QList<QAbstractAnimation*> selectedAnimations;
     if (animated) {
         for (int i = 0; i < transitionList.size(); ++i) {
             QAbstractTransition *transition = transitionList.at(i);
 
             selectedAnimations << transition->animations();
             selectedAnimations << defaultAnimationsForSource.values(transition->sourceState());
 
             QList<QAbstractState *> targetStates = transition->targetStates();
             for (int j=0; j<targetStates.size(); ++j)
                 selectedAnimations << defaultAnimationsForTarget.values(targetStates.at(j));
         }
         selectedAnimations << defaultAnimations;
     }
 
     // Initialize animations from property assignments.
     for (int i = 0; i < selectedAnimations.size(); ++i) {
         QAbstractAnimation *anim = selectedAnimations.at(i);
         QHash<QAbstractState*, QList<QPropertyAssignment> >::iterator it;
         for (it = propertyAssignmentsForState.begin(); it != propertyAssignmentsForState.end(); ) {
             QList<QPropertyAssignment>::iterator it2;
             QAbstractState *s = it.key();
             QList<QPropertyAssignment> &assignments = it.value();
             for (it2 = assignments.begin(); it2 != assignments.end(); ) {
                 QPair<QList<QAbstractAnimation*>, QList<QAbstractAnimation*> > ret;
                 ret = initializeAnimation(anim, *it2);
                 QList<QAbstractAnimation*> handlers = ret.first;
                 if (!handlers.isEmpty()) {
                     for (int j = 0; j < handlers.size(); ++j) {
                         QAbstractAnimation *a = handlers.at(j);
                         propertyForAnimation.insert(a, *it2);
                         stateForAnimation.insert(a, s);
                         animationsForState[s].append(a);
                         // ### connect to just the top-level animation?
                         QObject::connect(a, SIGNAL(finished()), q, SLOT(_q_animationFinished()), Qt::UniqueConnection);
                     }
                     it2 = assignments.erase(it2);
                 } else {
                     ++it2;
                 }
                 for (int j = 0; j < ret.second.size(); ++j)
                     resetAnimationEndValues.insert(ret.second.at(j));
             }
             if (assignments.isEmpty())
                 it = propertyAssignmentsForState.erase(it);
             else
                 ++it;
         }
         // We require that at least one animation is valid.
         // ### generalize
         QList<QVariantAnimation*> variantAnims = anim->findChildren<QVariantAnimation*>();
         if (QVariantAnimation *va = qobject_cast<QVariantAnimation*>(anim))
             variantAnims.append(va);
 
         bool hasValidEndValue = false;
         for (int j = 0; j < variantAnims.size(); ++j) {
             if (variantAnims.at(j)->endValue().isValid()) {
                 hasValidEndValue = true;
                 break;
             }
         }
 
         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 propertiesAssigned() signal, and
                 // that triggered a transition in the machine.
                 // Just stop the animation so it is correctly restarted again.
                 anim->stop();
             }
             anim->start();
         }
     }
 #endif // !QT_NO_ANIMATION
 
     // Immediately set the properties that are not animated.
     {
         QHash<QAbstractState*, QList<QPropertyAssignment> >::const_iterator it;
         for (it = propertyAssignmentsForState.constBegin(); it != propertyAssignmentsForState.constEnd(); ++it) {
             const QList<QPropertyAssignment> &assignments = it.value();
             for (int i = 0; i < assignments.size(); ++i) {
                 const QPropertyAssignment &assn = assignments.at(i);
                 assn.object->setProperty(assn.propertyName, assn.value);
             }
         }
     }
 
     // Emit propertiesAssigned signal for entered states that have no animated properties.
     for (int i = 0; i < enteredStates.size(); ++i) {
         QState *s = toStandardState(enteredStates.at(i));
         if (s
 #ifndef QT_NO_ANIMATION
             && !animationsForState.contains(s)
 #endif
             )
             QStatePrivate::get(s)->emitPropertiesAssigned();
     }
 }

◆ cancelAllDelayedEvents()

void QStateMachinePrivate::cancelAllDelayedEvents ( )

Definition at line 1395 of file qstatemachine.cpp.

Referenced by _q_process().

 {
     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);
         delete e;
     }
     delayedEvents.clear();
 }

◆ clearHistory()

void QStateMachinePrivate::clearHistory ( )

Definition at line 1192 of file qstatemachine.cpp.

Referenced by _q_start().

 {
     Q_Q(QStateMachine);
     QList<QHistoryState*> historyStates = q->findChildren<QHistoryState*>();
     for (int i = 0; i < historyStates.size(); ++i) {
         QHistoryState *h = historyStates.at(i);
         QHistoryStatePrivate::get(h)->configuration.clear();
     }
 }

◆ dequeueExternalEvent()

QEvent * QStateMachinePrivate::dequeueExternalEvent ( )

Definition at line 1357 of file qstatemachine.cpp.

Referenced by _q_process().

 {
     QMutexLocker locker(&externalEventMutex);
     if (externalEventQueue.isEmpty())
         return 0;
     return externalEventQueue.takeFirst();
 }

◆ dequeueInternalEvent()

QEvent * QStateMachinePrivate::dequeueInternalEvent ( )

Definition at line 1349 of file qstatemachine.cpp.

Referenced by _q_process().

 {
     QMutexLocker locker(&internalEventMutex);
     if (internalEventQueue.isEmpty())
         return 0;
     return internalEventQueue.takeFirst();
 }

◆ enterStates()

QList< QAbstractState * > QStateMachinePrivate::enterStates	(	QEvent *	event,
		const QList< QAbstractTransition *> &	enabledTransitions
	)

Definition at line 476 of file qstatemachine.cpp.

Referenced by _q_start(), and microstep().

 {
 #ifdef QSTATEMACHINE_DEBUG
     Q_Q(QStateMachine);
 #endif
 //    qDebug() << "enterStates(" << enabledTransitions << ')';
     QSet<QAbstractState*> statesToEnter;
     QSet<QAbstractState*> statesForDefaultEntry;
 
     if (pendingErrorStates.isEmpty()) {
         for (int i = 0; i < enabledTransitions.size(); ++i) {
             QAbstractTransition *t = enabledTransitions.at(i);
             QList<QAbstractState*> lst = t->targetStates();
             if (lst.isEmpty())
                 continue;
             lst.prepend(t->sourceState());
             QState *lca = findLCA(lst);
             for (int j = 1; j < lst.size(); ++j) {
                 QAbstractState *s = lst.at(j);
                 addStatesToEnter(s, lca, statesToEnter, statesForDefaultEntry);
                 if (isParallel(lca)) {
                     QList<QAbstractState*> lcac = QStatePrivate::get(lca)->childStates();
                     foreach (QAbstractState* child,lcac) {
                         if (!statesToEnter.contains(child))
                             addStatesToEnter(child,lca,statesToEnter,statesForDefaultEntry);
                     }
                 }
             }
         }
     }
 
     // Did an error occur while selecting transitions? Then we enter the error state.
     if (!pendingErrorStates.isEmpty()) {
         statesToEnter.clear();
         statesToEnter = pendingErrorStates;
         statesForDefaultEntry = pendingErrorStatesForDefaultEntry;
         pendingErrorStates.clear();
         pendingErrorStatesForDefaultEntry.clear();
     }
 
     QList<QAbstractState*> statesToEnter_sorted = statesToEnter.toList();
     qSort(statesToEnter_sorted.begin(), statesToEnter_sorted.end(), stateEntryLessThan);
 
     for (int i = 0; i < statesToEnter_sorted.size(); ++i) {
         QAbstractState *s = statesToEnter_sorted.at(i);
 #ifdef QSTATEMACHINE_DEBUG
         qDebug() << q << ": entering" << s;
 #endif
         configuration.insert(s);
         registerTransitions(s);
         QAbstractStatePrivate::get(s)->callOnEntry(event);
         QAbstractStatePrivate::get(s)->emitEntered();
         if (statesForDefaultEntry.contains(s)) {
             // ### executeContent(s.initial.transition.children())
         }
         if (isFinal(s)) {
             QState *parent = s->parentState();
             if (parent) {
                 if (parent != rootState()) {
 #ifdef QSTATEMACHINE_DEBUG
                     qDebug() << q << ": emitting finished signal for" << parent;
 #endif
                     QStatePrivate::get(parent)->emitFinished();
                 }
                 QState *grandparent = parent->parentState();
                 if (grandparent && isParallel(grandparent)) {
                     bool allChildStatesFinal = true;
                     QList<QAbstractState*> childStates = QStatePrivate::get(grandparent)->childStates();
                     for (int j = 0; j < childStates.size(); ++j) {
                         QAbstractState *cs = childStates.at(j);
                         if (!isInFinalState(cs)) {
                             allChildStatesFinal = false;
                             break;
                         }
                     }
                     if (allChildStatesFinal && (grandparent != rootState())) {
 #ifdef QSTATEMACHINE_DEBUG
                         qDebug() << q << ": emitting finished signal for" << grandparent;
 #endif
                         QStatePrivate::get(grandparent)->emitFinished();
                     }
                 }
             }
         }
     }
     {
         QSet<QAbstractState*>::const_iterator it;
         for (it = configuration.constBegin(); it != configuration.constEnd(); ++it) {
             if (isFinal(*it) && (*it)->parentState() == rootState()) {
                 processing = false;
                 stopProcessingReason = Finished;
                 break;
             }
         }
     }
 //    qDebug() << "configuration:" << configuration.toList();
     return statesToEnter_sorted;
 }

◆ executeTransitionContent()

void QStateMachinePrivate::executeTransitionContent	(	QEvent *	event,
		const QList< QAbstractTransition *> &	transitionList
	)

Definition at line 464 of file qstatemachine.cpp.

Referenced by _q_start(), and microstep().

 {
     for (int i = 0; i < enabledTransitions.size(); ++i) {
         QAbstractTransition *t = enabledTransitions.at(i);
 #ifdef QSTATEMACHINE_DEBUG
         qDebug() << q_func() << ": triggering" << t;
 #endif
         QAbstractTransitionPrivate::get(t)->callOnTransition(event);
         QAbstractTransitionPrivate::get(t)->emitTriggered();
     }
 }

◆ exitStates()

QList< QAbstractState * > QStateMachinePrivate::exitStates	(	QEvent *	event,
		const QList< QAbstractTransition *> &	transitionList
	)

Definition at line 396 of file qstatemachine.cpp.

Referenced by microstep().

 {
 //    qDebug() << "exitStates(" << enabledTransitions << ')';
     QSet<QAbstractState*> statesToExit;
 //    QSet<QAbstractState*> statesToSnapshot;
     for (int i = 0; i < enabledTransitions.size(); ++i) {
         QAbstractTransition *t = enabledTransitions.at(i);
         QList<QAbstractState*> lst = t->targetStates();
         if (lst.isEmpty())
             continue;
         lst.prepend(t->sourceState());
         QAbstractState *lca = findLCA(lst);
         if (lca == 0) {
             setError(QStateMachine::NoCommonAncestorForTransitionError, t->sourceState());
             lst = pendingErrorStates.toList();
             lst.prepend(t->sourceState());
 
             lca = findLCA(lst);
             Q_ASSERT(lca != 0);
         }
 
         {
             QSet<QAbstractState*>::const_iterator it;
             for (it = configuration.constBegin(); it != configuration.constEnd(); ++it) {
                 QAbstractState *s = *it;
                 if (isDescendantOf(s, lca))
                     statesToExit.insert(s);
             }
         }
     }
     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 = 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;
                 for (it = configuration.constBegin(); it != configuration.constEnd(); ++it) {
                     QAbstractState *s0 = *it;
                     if (QHistoryStatePrivate::get(h)->historyType == QHistoryState::DeepHistory) {
                         if (isAtomic(s0) && isDescendantOf(s0, s))
                             QHistoryStatePrivate::get(h)->configuration.append(s0);
                     } else if (s0->parentState() == s) {
                         QHistoryStatePrivate::get(h)->configuration.append(s0);
                     }
                 }
 #ifdef QSTATEMACHINE_DEBUG
                 qDebug() << q_func() << ": recorded" << ((QHistoryStatePrivate::get(h)->historyType == QHistoryState::DeepHistory) ? "deep" : "shallow")
                          << "history for" << s << "in" << h << ':' << QHistoryStatePrivate::get(h)->configuration;
 #endif
             }
         }
     }
     for (int i = 0; i < statesToExit_sorted.size(); ++i) {
         QAbstractState *s = statesToExit_sorted.at(i);
 #ifdef QSTATEMACHINE_DEBUG
         qDebug() << q_func() << ": exiting" << s;
 #endif
         QAbstractStatePrivate::get(s)->callOnExit(event);
         configuration.remove(s);
         QAbstractStatePrivate::get(s)->emitExited();
     }
     return statesToExit_sorted;
 }

◆ findErrorState()

QAbstractState * QStateMachinePrivate::findErrorState ( QAbstractState * context )

Definition at line 1017 of file qstatemachine.cpp.

Referenced by setError().

 {
     // Find error state recursively in parent hierarchy if not set explicitly for context state
     QAbstractState *errorState = 0;
     if (context != 0) {
         QState *s = toStandardState(context);
         if (s != 0)
             errorState = s->errorState();
 
         if (errorState == 0)
             errorState = findErrorState(context->parentState());
     }
 
     return errorState;
 }

◆ findLCA()

QState * QStateMachinePrivate::findLCA ( const QList< QAbstractState *> & states ) const

Definition at line 299 of file qstatemachine.cpp.

Referenced by enterStates(), exitStates(), isPreempted(), and setError().

 {
     if (states.isEmpty())
         return 0;
     QList<QState*> ancestors = properAncestors(states.at(0), rootState()->parentState());
     for (int i = 0; i < ancestors.size(); ++i) {
         QState *anc = ancestors.at(i);
         bool ok = true;
         for (int j = states.size() - 1; (j > 0) && ok; --j) {
             const QAbstractState *s = states.at(j);
             if (!isDescendantOf(s, anc))
                 ok = false;
         }
         if (ok)
             return anc;
     }
     return 0;
 }

◆ get()

QStateMachinePrivate * QStateMachinePrivate::get ( QStateMachine * q )

static

Definition at line 214 of file qstatemachine.cpp.

Referenced by QState::addTransition(), QEventTransitionPrivate::maybeRegister(), QSignalTransitionPrivate::maybeRegister(), QSignalEventGenerator::qt_metacall(), QState::removeTransition(), stateEntryLessThan(), stateExitLessThan(), QSignalTransitionPrivate::unregister(), and QEventTransitionPrivate::unregister().

 {
     if (q)
         return q->d_func();
     return 0;
 }

◆ goToState()

void QStateMachinePrivate::goToState ( QAbstractState * targetState )

Causes this state machine to unconditionally transition to the given targetState.

Warning: This function is not part of the public interface.

Provides a backdoor for using the state machine "imperatively"; i.e. rather than defining explicit transitions, you drive the machine's execution by calling this function. It breaks the whole integrity of the transition-driven model, but is provided for pragmatic reasons.

Definition at line 1440 of file qstatemachine.cpp.

 {
     if (!targetState) {
         qWarning("QStateMachine::goToState(): cannot go to null state");
         return;
     }
 
     if (configuration.contains(targetState))
         return;
 
     QState *sourceState = 0;
     if (state == Running) {
         QSet<QAbstractState*>::const_iterator it;
         for (it = configuration.constBegin(); it != configuration.constEnd(); ++it) {
             sourceState = toStandardState(*it);
             if (sourceState != 0)
                 break;
         }
     } else {
         sourceState = startState();
     }
 
     Q_ASSERT(sourceState != 0);
     // Reuse previous GoToStateTransition in case of several calls to
     // goToState() in a row.
     GoToStateTransition *trans = sourceState->findChild<GoToStateTransition*>();
     if (!trans) {
         trans = new GoToStateTransition(targetState);
         sourceState->addTransition(trans);
     } else {
         trans->setTargetState(targetState);
     }
 
     processEvents(QueuedProcessing);
 }

◆ handleFilteredEvent()

void QStateMachinePrivate::handleFilteredEvent	(	QObject *	watched,
		QEvent *	event
	)

Definition at line 1651 of file qstatemachine.cpp.

 {
     if (qobjectEvents.value(watched).contains(event->type())) {
         postInternalEvent(new QStateMachine::WrappedEvent(watched, handler->cloneEvent(event)));
         processEvents(DirectProcessing);
     }
 }

◆ handleTransitionSignal()

void QStateMachinePrivate::handleTransitionSignal	(	QObject *	sender,
		int	signalIndex,
		void **	args
	)

Definition at line 1660 of file qstatemachine.cpp.

Referenced by QSignalEventGenerator::qt_metacall().

 {
     Q_ASSERT(connections[sender].at(signalIndex) != 0);
     const QMetaObject *meta = sender->metaObject();
     QMetaMethod method = meta->method(signalIndex);
     QList<QByteArray> parameterTypes = method.parameterTypes();
     int argc = parameterTypes.count();
     QList<QVariant> vargs;
     for (int i = 0; i < argc; ++i) {
         int type = QMetaType::type(parameterTypes.at(i));
         vargs.append(QVariant(type, argv[i+1]));
     }
 
 #ifdef QSTATEMACHINE_DEBUG
     qDebug() << q_func() << ": sending signal event ( sender =" << sender
              << ", signal =" << sender->metaObject()->method(signalIndex).signature() << ')';
 #endif
     postInternalEvent(new QStateMachine::SignalEvent(sender, signalIndex, vargs));
     processEvents(DirectProcessing);
 }

◆ hasRestorable()

bool QStateMachinePrivate::hasRestorable	(	QObject *	object,
		const QByteArray &	propertyName
	)		const

Returns true if the variable with the given id has been registered for restoration.

Warning: This function is not part of the public interface.

Definition at line 993 of file qstatemachine.cpp.

 {
     return registeredRestorables.contains(RestorableId(object, propertyName));
 }

◆ initializeAnimation()

QPair< QList< QAbstractAnimation * >, QList< QAbstractAnimation * > > QStateMachinePrivate::initializeAnimation	(	QAbstractAnimation *	abstractAnimation,
		const QPropertyAssignment &	prop
	)

Definition at line 1087 of file qstatemachine.cpp.

Referenced by applyProperties().

 {
     QList<QAbstractAnimation*> handledAnimations;
     QList<QAbstractAnimation*> localResetEndValues;
     QAnimationGroup *group = qobject_cast<QAnimationGroup*>(abstractAnimation);
     if (group) {
         for (int i = 0; i < group->animationCount(); ++i) {
             QAbstractAnimation *animationChild = group->animationAt(i);
             QPair<QList<QAbstractAnimation*>, QList<QAbstractAnimation*> > ret;
             ret = initializeAnimation(animationChild, prop);
             handledAnimations << ret.first;
             localResetEndValues << ret.second;
         }
     } else {
         QPropertyAnimation *animation = qobject_cast<QPropertyAnimation *>(abstractAnimation);
         if (animation != 0
             && prop.object == animation->targetObject()
             && prop.propertyName == animation->propertyName()) {
 
             // Only change end value if it is undefined
             if (!animation->endValue().isValid()) {
                 animation->setEndValue(prop.value);
                 localResetEndValues.append(animation);
             }
             handledAnimations.append(animation);
         }
     }
     return qMakePair(handledAnimations, localResetEndValues);
 }

◆ isAtomic()

bool QStateMachinePrivate::isAtomic ( const QAbstractState * s ) const

Definition at line 883 of file qstatemachine.cpp.

Referenced by exitStates(), and selectTransitions().

 {
     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 && QStatePrivate::get(ss)->isMachine && (ss != rootState()));
 }

◆ isCompound()

bool QStateMachinePrivate::isCompound ( const QAbstractState * s ) const

Definition at line 870 of file qstatemachine.cpp.

Referenced by addStatesToEnter(), and isInFinalState().

 {
     const QState *group = toStandardState(s);
     if (!group)
         return false;
     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;
 }

◆ isDescendantOf()

bool QStateMachinePrivate::isDescendantOf	(	const QAbstractState *	s,
		const QAbstractState *	other
	)

static

Definition at line 893 of file qstatemachine.cpp.

Referenced by addStatesToEnter(), exitStates(), findLCA(), indexOfDescendant(), isPreempted(), stateEntryLessThan(), and stateExitLessThan().

 {
     Q_ASSERT(state != 0);
     for (QAbstractState *s = state->parentState(); s != 0; s = s->parentState()) {
         if (s == other)
             return true;
     }
     return false;
 }

◆ isExternalEventQueueEmpty()

bool QStateMachinePrivate::isExternalEventQueueEmpty ( )

Definition at line 1371 of file qstatemachine.cpp.

 {
     QMutexLocker locker(&externalEventMutex);
     return externalEventQueue.isEmpty();
 }

◆ isFinal()

bool QStateMachinePrivate::isFinal ( const QAbstractState * s )

static

Definition at line 859 of file qstatemachine.cpp.

Referenced by enterStates(), isAtomic(), and isInFinalState().

 {
     return s && (QAbstractStatePrivate::get(s)->stateType == QAbstractStatePrivate::FinalState);
 }

◆ isInFinalState()

bool QStateMachinePrivate::isInFinalState ( QAbstractState * s ) const

Definition at line 941 of file qstatemachine.cpp.

Referenced by enterStates().

 {
     if (isCompound(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 = 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;
         }
         return true;
     }
     else
         return false;
 }

◆ isInternalEventQueueEmpty()

bool QStateMachinePrivate::isInternalEventQueueEmpty ( )

Definition at line 1365 of file qstatemachine.cpp.

Referenced by _q_process().

 {
     QMutexLocker locker(&internalEventMutex);
     return internalEventQueue.isEmpty();
 }

◆ isParallel()

bool QStateMachinePrivate::isParallel ( const QAbstractState * s )

static

Definition at line 864 of file qstatemachine.cpp.

Referenced by addStatesToEnter(), enterStates(), isCompound(), and isInFinalState().

 {
     const QState *ss = toStandardState(s);
     return ss && (QStatePrivate::get(ss)->childMode == QState::ParallelStates);
 }

◆ isPreempted()

bool QStateMachinePrivate::isPreempted	(	const QAbstractState *	s,
		const QSet< QAbstractTransition *> &	transitions
	)		const

Definition at line 318 of file qstatemachine.cpp.

Referenced by selectTransitions().

 {
     QSet<QAbstractTransition*>::const_iterator it;
     for (it = transitions.constBegin(); it != transitions.constEnd(); ++it) {
         QAbstractTransition *t = *it;
         QList<QAbstractState*> lst = t->targetStates();
         if (!lst.isEmpty()) {
             lst.prepend(t->sourceState());
             QAbstractState *lca = findLCA(lst);
             if (isDescendantOf(s, lca)) {
 #ifdef QSTATEMACHINE_DEBUG
                 qDebug() << q_func() << ':' << transitions << "preempts selection of a transition from"
                          << s << "because" << s << "is a descendant of" << lca;
 #endif
                 return true;
             }
         }
     }
     return false;
 }

◆ microstep()

void QStateMachinePrivate::microstep	(	QEvent *	event,
		const QList< QAbstractTransition *> &	transitionList
	)

Definition at line 375 of file qstatemachine.cpp.

Referenced by _q_process().

 {
 #ifdef QSTATEMACHINE_DEBUG
     qDebug() << q_func() << ": begin microstep( enabledTransitions:" << enabledTransitions << ')';
     qDebug() << q_func() << ": configuration before exiting states:" << configuration;
 #endif
     QList<QAbstractState*> exitedStates = exitStates(event, enabledTransitions);
 #ifdef QSTATEMACHINE_DEBUG
     qDebug() << q_func() << ": configuration after exiting states:" << configuration;
 #endif
     executeTransitionContent(event, enabledTransitions);
     QList<QAbstractState*> enteredStates = enterStates(event, enabledTransitions);
 #ifndef QT_NO_PROPERTIES
     applyProperties(enabledTransitions, exitedStates, enteredStates);
 #endif
 #ifdef QSTATEMACHINE_DEBUG
     qDebug() << q_func() << ": configuration after entering states:" << configuration;
     qDebug() << q_func() << ": end microstep";
 #endif
 }

◆ postExternalEvent()

void QStateMachinePrivate::postExternalEvent ( QEvent * e )

Definition at line 1343 of file qstatemachine.cpp.

 {
     QMutexLocker locker(&externalEventMutex);
     externalEventQueue.append(e);
 }

◆ postInternalEvent()

void QStateMachinePrivate::postInternalEvent ( QEvent * e )

Definition at line 1337 of file qstatemachine.cpp.

Referenced by handleFilteredEvent(), and handleTransitionSignal().

 {
     QMutexLocker locker(&internalEventMutex);
     internalEventQueue.append(e);
 }

◆ processEvents()

void QStateMachinePrivate::processEvents ( EventProcessingMode processingMode )

Definition at line 1377 of file qstatemachine.cpp.

Referenced by goToState(), handleFilteredEvent(), and handleTransitionSignal().

 {
     Q_Q(QStateMachine);
     if ((state != Running) || processing || processingScheduled)
         return;
     switch (processingMode) {
     case DirectProcessing:
         if (QThread::currentThread() == q->thread()) {
             _q_process();
             break;
         } // fallthrough -- processing must be done in the machine thread
     case QueuedProcessing:
         processingScheduled = true;
         QMetaObject::invokeMethod(q, "_q_process", Qt::QueuedConnection);
         break;
     }
 }

◆ properAncestors()

QList< QState * > QStateMachinePrivate::properAncestors	(	const QAbstractState *	s,
		const QState *	upperBound
	)

static

Definition at line 903 of file qstatemachine.cpp.

Referenced by addStatesToEnter(), findLCA(), and selectTransitions().

 {
     Q_ASSERT(state != 0);
     QList<QState*> result;
     for (QState *s = state->parentState(); s && s != upperBound; s = s->parentState()) {
         result.append(s);
     }
     return result;
 }

◆ registerEventTransition()

void QStateMachinePrivate::registerEventTransition ( QEventTransition * transition )

Definition at line 1605 of file qstatemachine.cpp.

Referenced by QEventTransitionPrivate::maybeRegister(), and registerTransitions().

 {
     Q_Q(QStateMachine);
     if (QEventTransitionPrivate::get(transition)->registered)
         return;
     if (transition->eventType() >= QEvent::User) {
         qWarning("QObject event transitions are not supported for custom types");
         return;
     }
     QObject *object = QEventTransitionPrivate::get(transition)->object;
     if (!object)
         return;
     QObjectPrivate *od = QObjectPrivate::get(object);
     if (!od->eventFilters.contains(q))
         object->installEventFilter(q);
     ++qobjectEvents[object][transition->eventType()];
     QEventTransitionPrivate::get(transition)->registered = true;
 #ifdef QSTATEMACHINE_DEBUG
     qDebug() << q << ": added event transition from" << transition->sourceState()
              << ": ( object =" << object << ", event =" << transition->eventType()
              << ", targets =" << transition->targetStates() << ')';
 #endif
 }

◆ registerRestorable()

void QStateMachinePrivate::registerRestorable	(	QObject *	object,
		const QByteArray &	propertyName
	)

Definition at line 968 of file qstatemachine.cpp.

Referenced by applyProperties().

 {
     RestorableId id(object, propertyName);
     if (!registeredRestorables.contains(id))
         registeredRestorables.insert(id, object->property(propertyName));
 }

◆ registerSignalTransition()

void QStateMachinePrivate::registerSignalTransition ( QSignalTransition * transition )

Definition at line 1507 of file qstatemachine.cpp.

Referenced by QSignalTransitionPrivate::maybeRegister(), and registerTransitions().

 {
     Q_Q(QStateMachine);
     if (QSignalTransitionPrivate::get(transition)->signalIndex != -1)
         return; // already registered
     QObject *sender = QSignalTransitionPrivate::get(transition)->sender;
     if (!sender)
         return;
     QByteArray signal = QSignalTransitionPrivate::get(transition)->signal;
     if (signal.startsWith('0'+QSIGNAL_CODE))
         signal.remove(0, 1);
     const QMetaObject *meta = sender->metaObject();
     int signalIndex = meta->indexOfSignal(signal);
     int originalSignalIndex = signalIndex;
     if (signalIndex == -1) {
         signalIndex = meta->indexOfSignal(QMetaObject::normalizedSignature(signal));
         if (signalIndex == -1) {
             qWarning("QSignalTransition: no such signal: %s::%s",
                      meta->className(), signal.constData());
             return;
         }
     }
     // The signal index we actually want to connect to is the one
     // that is going to be sent, i.e. the non-cloned original index.
     while (meta->method(signalIndex).attributes() & QMetaMethod::Cloned)
         --signalIndex;
 
     QVector<int> &connectedSignalIndexes = connections[sender];
     if (connectedSignalIndexes.size() <= signalIndex)
         connectedSignalIndexes.resize(signalIndex+1);
     if (connectedSignalIndexes.at(signalIndex) == 0) {
         if (!signalEventGenerator)
             signalEventGenerator = new QSignalEventGenerator(q);
         bool ok = QMetaObject::connect(sender, signalIndex, signalEventGenerator,
                                        signalEventGenerator->metaObject()->methodOffset());
         if (!ok) {
 #ifdef QSTATEMACHINE_DEBUG
             qDebug() << q << ": FAILED to add signal transition from" << transition->sourceState()
                      << ": ( sender =" << sender << ", signal =" << signal
                      << ", targets =" << transition->targetStates() << ')';
 #endif
             return;
         }
     }
     ++connectedSignalIndexes[signalIndex];
     QSignalTransitionPrivate::get(transition)->signalIndex = signalIndex;
     QSignalTransitionPrivate::get(transition)->originalSignalIndex = originalSignalIndex;
 #ifdef QSTATEMACHINE_DEBUG
     qDebug() << q << ": added signal transition from" << transition->sourceState()
              << ": ( sender =" << sender << ", signal =" << signal
              << ", targets =" << transition->targetStates() << ')';
 #endif
 }

◆ registerTransitions()

void QStateMachinePrivate::registerTransitions ( QAbstractState * state )

Definition at line 1476 of file qstatemachine.cpp.

Referenced by QState::addTransition(), and enterStates().

 {
     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);
         if (QSignalTransition *st = qobject_cast<QSignalTransition*>(t)) {
             registerSignalTransition(st);
         }
 #ifndef QT_NO_STATEMACHINE_EVENTFILTER
         else if (QEventTransition *oet = qobject_cast<QEventTransition*>(t)) {
             registerEventTransition(oet);
         }
 #endif
     }
 }

◆ removeStartState()

void QStateMachinePrivate::removeStartState ( )

Definition at line 1186 of file qstatemachine.cpp.

Referenced by _q_start().

 {
     delete _startState;
     _startState = 0;
 }

◆ restorablesToPropertyList()

QList< QPropertyAssignment > QStateMachinePrivate::restorablesToPropertyList ( const QHash< RestorableId, QVariant > & restorables ) const

Definition at line 975 of file qstatemachine.cpp.

Referenced by applyProperties().

 {
     QList<QPropertyAssignment> result;
     QHash<RestorableId, QVariant>::const_iterator it;
     for (it = restorables.constBegin(); it != restorables.constEnd(); ++it) {
 //        qDebug() << "restorable:" << it.key().first << it.key().second << it.value();
         result.append(QPropertyAssignment(it.key().first, it.key().second, it.value(), /*explicitlySet=*/false));
     }
     return result;
 }

◆ restorableValue()

QVariant QStateMachinePrivate::restorableValue	(	QObject *	object,
		const QByteArray &	propertyName
	)		const

Definition at line 998 of file qstatemachine.cpp.

 {
     return registeredRestorables.value(RestorableId(object, propertyName), QVariant());
 }

◆ rootState()

QState * QStateMachinePrivate::rootState ( ) const

Definition at line 221 of file qstatemachine.cpp.

Referenced by _q_start(), addStatesToEnter(), enterStates(), findLCA(), isAtomic(), isCompound(), selectTransitions(), setError(), and unregisterAllTransitions().

 {
     return const_cast<QStateMachine*>(q_func());
 }

◆ selectTransitions()

QSet< QAbstractTransition * > QStateMachinePrivate::selectTransitions ( QEvent * event ) const

Definition at line 339 of file qstatemachine.cpp.

Referenced by _q_process().

 {
     Q_Q(const QStateMachine);
     QSet<QAbstractTransition*> enabledTransitions;
     QSet<QAbstractState*>::const_iterator it;
     const_cast<QStateMachine*>(q)->beginSelectTransitions(event);
     for (it = configuration.constBegin(); it != configuration.constEnd(); ++it) {
         QAbstractState *state = *it;
         if (!isAtomic(state))
             continue;
         if (isPreempted(state, enabledTransitions))
             continue;
         QList<QState*> lst = properAncestors(state, rootState()->parentState());
         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();
             for (int k = 0; k < transitions.size(); ++k) {
                 QAbstractTransition *t = transitions.at(k);
                 if (QAbstractTransitionPrivate::get(t)->callEventTest(event)) {
 #ifdef QSTATEMACHINE_DEBUG
                     qDebug() << q << ": selecting transition" << t;
 #endif
                     enabledTransitions.insert(t);
                     found = true;
                     break;
                 }
             }
         }
     }
     const_cast<QStateMachine*>(q)->endSelectTransitions(event);
     return enabledTransitions;
 }

◆ setError()

void QStateMachinePrivate::setError	(	QStateMachine::Error	error,
		QAbstractState *	currentContext
	)

Definition at line 1033 of file qstatemachine.cpp.

Referenced by addStatesToEnter(), and exitStates().

 {
     Q_Q(QStateMachine);
 
     error = errorCode;
     switch (errorCode) {
     case QStateMachine::NoInitialStateError:
         Q_ASSERT(currentContext != 0);
 
         errorString = QStateMachine::tr("Missing initial state in compound state '%1'")
                         .arg(currentContext->objectName());
 
         break;
     case QStateMachine::NoDefaultStateInHistoryStateError:
         Q_ASSERT(currentContext != 0);
 
         errorString = QStateMachine::tr("Missing default state in history state '%1'")
                         .arg(currentContext->objectName());
         break;
 
     case QStateMachine::NoCommonAncestorForTransitionError:
         Q_ASSERT(currentContext != 0);
 
         errorString = QStateMachine::tr("No common ancestor for targets and source of transition from state '%1'")
                         .arg(currentContext->objectName());
         break;
     default:
         errorString = QStateMachine::tr("Unknown error");
     };
 
     pendingErrorStates.clear();
     pendingErrorStatesForDefaultEntry.clear();
 
     QAbstractState *currentErrorState = findErrorState(currentContext);
 
     // Avoid infinite loop if the error state itself has an error
     if (currentContext == currentErrorState)
         currentErrorState = 0;
 
     Q_ASSERT(currentErrorState != rootState());
 
     if (currentErrorState != 0) {
         QState *lca = findLCA(QList<QAbstractState*>() << currentErrorState << currentContext);
         addStatesToEnter(currentErrorState, lca, pendingErrorStates, pendingErrorStatesForDefaultEntry);
     } else {
         qWarning("Unrecoverable error detected in running state machine: %s",
                  qPrintable(errorString));
         q->stop();
     }
 }

◆ startState()

QState * QStateMachinePrivate::startState ( )

Definition at line 1178 of file qstatemachine.cpp.

Referenced by _q_start(), and goToState().

 {
     Q_Q(QStateMachine);
     if (_startState == 0)
         _startState = new StartState(q);
     return _startState;
 }

◆ stateEntryLessThan()

bool QStateMachinePrivate::stateEntryLessThan	(	QAbstractState *	s1,
		QAbstractState *	s2
	)

static

Definition at line 263 of file qstatemachine.cpp.

Referenced by enterStates().

 {
     if (s1->parent() == s2->parent()) {
         return s1->children().indexOf(s1)
             < s2->children().indexOf(s2);
     } else if (isDescendantOf(s1, s2)) {
         return false;
     } else if (isDescendantOf(s2, s1)) {
         return true;
     } else {
         Q_ASSERT(s1->machine() != 0);
         QStateMachinePrivate *mach = QStateMachinePrivate::get(s1->machine());
         QState *lca = mach->findLCA(QList<QAbstractState*>() << s1 << s2);
         Q_ASSERT(lca != 0);
         return (indexOfDescendant(lca, s1) < indexOfDescendant(lca, s2));
     }
 }

◆ stateExitLessThan()

bool QStateMachinePrivate::stateExitLessThan	(	QAbstractState *	s1,
		QAbstractState *	s2
	)

static

Definition at line 281 of file qstatemachine.cpp.

Referenced by exitStates().

 {
     if (s1->parent() == s2->parent()) {
         return s1->children().indexOf(s1)
             < s2->children().indexOf(s2);
     } else if (isDescendantOf(s1, s2)) {
         return true;
     } else if (isDescendantOf(s2, s1)) {
         return false;
     } else {
         Q_ASSERT(s1->machine() != 0);
         QStateMachinePrivate *mach = QStateMachinePrivate::get(s1->machine());
         QState *lca = mach->findLCA(QList<QAbstractState*>() << s1 << s2);
         Q_ASSERT(lca != 0);
         return (indexOfDescendant(lca, s1) < indexOfDescendant(lca, s2));
     }
 }

◆ toFinalState()

QFinalState * QStateMachinePrivate::toFinalState ( QAbstractState * state )

static

Definition at line 927 of file qstatemachine.cpp.

 {
     if (state && (QAbstractStatePrivate::get(state)->stateType == QAbstractStatePrivate::FinalState))
         return static_cast<QFinalState*>(state);
     return 0;
 }

◆ toHistoryState()

QHistoryState * QStateMachinePrivate::toHistoryState ( QAbstractState * state )

static

Definition at line 934 of file qstatemachine.cpp.

Referenced by addStatesToEnter().

 {
     if (state && (QAbstractStatePrivate::get(state)->stateType == QAbstractStatePrivate::HistoryState))
         return static_cast<QHistoryState*>(state);
     return 0;
 }

◆ toStandardState() [1/2]

QState * QStateMachinePrivate::toStandardState ( QAbstractState * state )

static

Definition at line 913 of file qstatemachine.cpp.

Referenced by _q_animationFinished(), addStatesToEnter(), applyProperties(), exitStates(), findErrorState(), goToState(), isAtomic(), isCompound(), isInFinalState(), isParallel(), registerTransitions(), and selectTransitions().

 {
     if (state && (QAbstractStatePrivate::get(state)->stateType == QAbstractStatePrivate::StandardState))
         return static_cast<QState*>(state);
     return 0;
 }

◆ toStandardState() [2/2]

const QState * QStateMachinePrivate::toStandardState ( const QAbstractState * state )

static

Definition at line 920 of file qstatemachine.cpp.

 {
     if (state && (QAbstractStatePrivate::get(state)->stateType == QAbstractStatePrivate::StandardState))
         return static_cast<const QState*>(state);
     return 0;
 }

◆ unregisterAllTransitions()

void QStateMachinePrivate::unregisterAllTransitions ( )

Definition at line 1583 of file qstatemachine.cpp.

Referenced by _q_process().

 {
     Q_Q(QStateMachine);
     {
         QList<QSignalTransition*> transitions = rootState()->findChildren<QSignalTransition*>();
         for (int i = 0; i < transitions.size(); ++i) {
             QSignalTransition *t = transitions.at(i);
             if (t->machine() == q)
                 unregisterSignalTransition(t);
         }
     }
     {
         QList<QEventTransition*> transitions = rootState()->findChildren<QEventTransition*>();
         for (int i = 0; i < transitions.size(); ++i) {
             QEventTransition *t = transitions.at(i);
             if (t->machine() == q)
                 unregisterEventTransition(t);
         }
     }
 }

◆ unregisterEventTransition()

void QStateMachinePrivate::unregisterEventTransition ( QEventTransition * transition )

Definition at line 1629 of file qstatemachine.cpp.

Referenced by QEventTransitionPrivate::unregister(), unregisterAllTransitions(), and unregisterTransition().

 {
     Q_Q(QStateMachine);
     if (!QEventTransitionPrivate::get(transition)->registered)
         return;
     QObject *object = QEventTransitionPrivate::get(transition)->object;
     QHash<QEvent::Type, int> &events = qobjectEvents[object];
     Q_ASSERT(events.value(transition->eventType()) > 0);
     if (--events[transition->eventType()] == 0) {
         events.remove(transition->eventType());
         int sum = 0;
         QHash<QEvent::Type, int>::const_iterator it;
         for (it = events.constBegin(); it != events.constEnd(); ++it)
             sum += it.value();
         if (sum == 0) {
             qobjectEvents.remove(object);
             object->removeEventFilter(q);
         }
     }
     QEventTransitionPrivate::get(transition)->registered = false;
 }

◆ unregisterRestorable()

void QStateMachinePrivate::unregisterRestorable	(	QObject *	object,
		const QByteArray &	propertyName
	)

Warning: This function is not part of the public interface. Unregisters the variable identified by id

Definition at line 1008 of file qstatemachine.cpp.

Referenced by _q_animationFinished().

 {
 //    qDebug() << "unregisterRestorable(" << object << propertyName << ')';
     RestorableId id(object, propertyName);
     registeredRestorables.remove(id);
 }

◆ unregisterSignalTransition()

void QStateMachinePrivate::unregisterSignalTransition ( QSignalTransition * transition )

Definition at line 1561 of file qstatemachine.cpp.

Referenced by QSignalTransitionPrivate::unregister(), unregisterAllTransitions(), and unregisterTransition().

 {
     int signalIndex = QSignalTransitionPrivate::get(transition)->signalIndex;
     if (signalIndex == -1)
         return; // not registered
     QSignalTransitionPrivate::get(transition)->signalIndex = -1;
     const QObject *sender = QSignalTransitionPrivate::get(transition)->sender;
     QVector<int> &connectedSignalIndexes = connections[sender];
     Q_ASSERT(connectedSignalIndexes.size() > signalIndex);
     Q_ASSERT(connectedSignalIndexes.at(signalIndex) != 0);
     if (--connectedSignalIndexes[signalIndex] == 0) {
         Q_ASSERT(signalEventGenerator != 0);
         QMetaObject::disconnect(sender, signalIndex, signalEventGenerator,
                                 signalEventGenerator->metaObject()->methodOffset());
         int sum = 0;
         for (int i = 0; i < connectedSignalIndexes.size(); ++i)
             sum += connectedSignalIndexes.at(i);
         if (sum == 0)
             connections.remove(sender);
     }
 }

◆ unregisterTransition()

void QStateMachinePrivate::unregisterTransition ( QAbstractTransition * transition )

Definition at line 1495 of file qstatemachine.cpp.

Referenced by QState::removeTransition().

 {
     if (QSignalTransition *st = qobject_cast<QSignalTransition*>(transition)) {
         unregisterSignalTransition(st);
     }
 #ifndef QT_NO_STATEMACHINE_EVENTFILTER
     else if (QEventTransition *oet = qobject_cast<QEventTransition*>(transition)) {
         unregisterEventTransition(oet);
     }
 #endif
 }

Properties

◆ _startState

QState* QStateMachinePrivate::_startState

Definition at line 193 of file qstatemachine_p.h.

Referenced by QStateMachinePrivate(), removeStartState(), and startState().

◆ animated

bool QStateMachinePrivate::animated

Definition at line 212 of file qstatemachine_p.h.

Referenced by applyProperties(), and QStateMachinePrivate().

◆ animationsForState

QHash<QAbstractState*, QList<QAbstractAnimation*> > QStateMachinePrivate::animationsForState

Definition at line 218 of file qstatemachine_p.h.

Referenced by _q_animationFinished(), and applyProperties().

◆ configuration

QSet<QAbstractState*> QStateMachinePrivate::configuration

Definition at line 198 of file qstatemachine_p.h.

Referenced by _q_start(), enterStates(), exitStates(), goToState(), isInFinalState(), microstep(), and selectTransitions().

◆ connections

QHash<const QObject*, QVector<int> > QStateMachinePrivate::connections

Definition at line 231 of file qstatemachine_p.h.

Referenced by handleTransitionSignal(), registerSignalTransition(), and unregisterSignalTransition().

◆ defaultAnimations

QList<QAbstractAnimation *> QStateMachinePrivate::defaultAnimations

Definition at line 223 of file qstatemachine_p.h.

Referenced by applyProperties().

◆ defaultAnimationsForSource

QMultiHash<QAbstractState *, QAbstractAnimation *> QStateMachinePrivate::defaultAnimationsForSource

Definition at line 224 of file qstatemachine_p.h.

Referenced by applyProperties().

◆ defaultAnimationsForTarget

QMultiHash<QAbstractState *, QAbstractAnimation *> QStateMachinePrivate::defaultAnimationsForTarget

Definition at line 225 of file qstatemachine_p.h.

Referenced by applyProperties().

◆ delayedEvents

QHash<int, QEvent*> QStateMachinePrivate::delayedEvents

Definition at line 235 of file qstatemachine_p.h.

Referenced by cancelAllDelayedEvents().

◆ delayedEventsMutex

QMutex QStateMachinePrivate::delayedEventsMutex

Definition at line 236 of file qstatemachine_p.h.

Referenced by cancelAllDelayedEvents().

◆ error

QStateMachine::Error QStateMachinePrivate::error

Definition at line 204 of file qstatemachine_p.h.

Referenced by addStatesToEnter(), QStateMachinePrivate(), and setError().

◆ errorString

QString QStateMachinePrivate::errorString

Definition at line 207 of file qstatemachine_p.h.

Referenced by setError().

◆ externalEventMutex

QMutex QStateMachinePrivate::externalEventMutex

Definition at line 202 of file qstatemachine_p.h.

Referenced by dequeueExternalEvent(), isExternalEventQueueEmpty(), and postExternalEvent().

◆ externalEventQueue

QList<QEvent*> QStateMachinePrivate::externalEventQueue

Definition at line 200 of file qstatemachine_p.h.

Referenced by _q_start(), dequeueExternalEvent(), isExternalEventQueueEmpty(), postExternalEvent(), and ~QStateMachinePrivate().

◆ globalRestorePolicy

QStateMachine::RestorePolicy QStateMachinePrivate::globalRestorePolicy

Definition at line 205 of file qstatemachine_p.h.

Referenced by applyProperties(), and QStateMachinePrivate().

◆ handler

const QStateMachinePrivate::Handler * QStateMachinePrivate::handler = &qt_kernel_statemachine_handler

static

Definition at line 243 of file qstatemachine_p.h.

Referenced by handleFilteredEvent(), qRegisterGuiStateMachine(), and qUnregisterGuiStateMachine().

◆ internalEventMutex

QMutex QStateMachinePrivate::internalEventMutex

Definition at line 201 of file qstatemachine_p.h.

Referenced by dequeueInternalEvent(), isInternalEventQueueEmpty(), and postInternalEvent().

◆ internalEventQueue

QList<QEvent*> QStateMachinePrivate::internalEventQueue

Definition at line 199 of file qstatemachine_p.h.

Referenced by _q_start(), dequeueInternalEvent(), isInternalEventQueueEmpty(), postInternalEvent(), and ~QStateMachinePrivate().

◆ pendingErrorStates

QSet<QAbstractState *> QStateMachinePrivate::pendingErrorStates

Definition at line 208 of file qstatemachine_p.h.

Referenced by enterStates(), exitStates(), and setError().

◆ pendingErrorStatesForDefaultEntry

QSet<QAbstractState *> QStateMachinePrivate::pendingErrorStatesForDefaultEntry

Definition at line 209 of file qstatemachine_p.h.

Referenced by enterStates(), and setError().

◆ processing

bool QStateMachinePrivate::processing

Definition at line 194 of file qstatemachine_p.h.

Referenced by _q_process(), enterStates(), processEvents(), and QStateMachinePrivate().

◆ processingScheduled

bool QStateMachinePrivate::processingScheduled

Definition at line 195 of file qstatemachine_p.h.

Referenced by _q_process(), _q_start(), processEvents(), and QStateMachinePrivate().

◆ propertyForAnimation

QHash<QAbstractAnimation*, QPropertyAssignment> QStateMachinePrivate::propertyForAnimation

Definition at line 219 of file qstatemachine_p.h.

Referenced by _q_animationFinished(), and applyProperties().

◆ qobjectEvents

QHash<QObject*, QHash<QEvent::Type, int> > QStateMachinePrivate::qobjectEvents

Definition at line 233 of file qstatemachine_p.h.

Referenced by handleFilteredEvent(), registerEventTransition(), and unregisterEventTransition().

◆ registeredRestorables

QHash<RestorableId, QVariant> QStateMachinePrivate::registeredRestorables

Definition at line 184 of file qstatemachine_p.h.

Referenced by applyProperties(), hasRestorable(), registerRestorable(), restorableValue(), and unregisterRestorable().

◆ resetAnimationEndValues

QSet<QAbstractAnimation*> QStateMachinePrivate::resetAnimationEndValues

Definition at line 221 of file qstatemachine_p.h.

Referenced by _q_animationFinished(), and applyProperties().

◆ signalEventGenerator

QSignalEventGenerator* QStateMachinePrivate::signalEventGenerator

Definition at line 229 of file qstatemachine_p.h.

Referenced by QStateMachinePrivate(), registerSignalTransition(), and unregisterSignalTransition().

◆ state

State QStateMachinePrivate::state

Definition at line 192 of file qstatemachine_p.h.

Referenced by _q_animationFinished(), _q_process(), _q_start(), goToState(), processEvents(), QStateMachinePrivate(), selectTransitions(), toFinalState(), toHistoryState(), and toStandardState().

◆ stateForAnimation

QHash<QAbstractAnimation*, QAbstractState*> QStateMachinePrivate::stateForAnimation

Definition at line 220 of file qstatemachine_p.h.

Referenced by _q_animationFinished(), and applyProperties().

◆ stop

bool QStateMachinePrivate::stop

Definition at line 196 of file qstatemachine_p.h.

Referenced by _q_process(), and QStateMachinePrivate().

◆ stopProcessingReason

StopProcessingReason QStateMachinePrivate::stopProcessingReason

Definition at line 197 of file qstatemachine_p.h.

Referenced by _q_process(), enterStates(), and QStateMachinePrivate().

The documentation for this class was generated from the following files:

/src/corelib/statemachine/qstatemachine_p.h
/src/corelib/statemachine/qstatemachine.cpp

Classes

Public Types

Public Functions

Static Public Functions

Public Variables

Static Public Variables

Detailed Description

Typedefs

◆ f_cloneEvent

◆ RestorableId

Enumerations

◆ EventProcessingMode

◆ State

◆ StopProcessingReason

Constructors and Destructors

◆ QStateMachinePrivate()

◆ ~QStateMachinePrivate()

Functions

◆ _q_animationFinished()

◆ _q_process()

◆ _q_start()

◆ addStatesToEnter()

◆ applyProperties()

◆ cancelAllDelayedEvents()

◆ clearHistory()

◆ dequeueExternalEvent()

◆ dequeueInternalEvent()

◆ enterStates()

◆ executeTransitionContent()

◆ exitStates()

◆ findErrorState()

◆ findLCA()

◆ get()

◆ goToState()

◆ handleFilteredEvent()

◆ handleTransitionSignal()

◆ hasRestorable()

◆ initializeAnimation()

◆ isAtomic()

◆ isCompound()

◆ isDescendantOf()

◆ isExternalEventQueueEmpty()

◆ isFinal()

◆ isInFinalState()

◆ isInternalEventQueueEmpty()

◆ isParallel()

◆ isPreempted()

◆ microstep()

◆ postExternalEvent()

◆ postInternalEvent()

◆ processEvents()

◆ properAncestors()

◆ registerEventTransition()

◆ registerRestorable()

◆ registerSignalTransition()

◆ registerTransitions()

◆ removeStartState()

◆ restorablesToPropertyList()

◆ restorableValue()

◆ rootState()

◆ selectTransitions()

◆ setError()

◆ startState()

◆ stateEntryLessThan()

◆ stateExitLessThan()

◆ toFinalState()

◆ toHistoryState()

◆ toStandardState() [1/2]

◆ toStandardState() [2/2]

◆ unregisterAllTransitions()

◆ unregisterEventTransition()

◆ unregisterRestorable()

◆ unregisterSignalTransition()

◆ unregisterTransition()

Properties

◆ _startState

◆ animated

◆ animationsForState

◆ configuration

◆ connections