MCL/sf/mw/qt: comparison src/corelib/statemachine/qstate.cpp

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 \value ParallelStates The child states are parallel. When the parent state
 is entered, all its child states are entered in parallel.
 */
 QStatePrivate::QStatePrivate()
-: errorState(0), initialState(0), childMode(QState::ExclusiveStates)
+: QAbstractStatePrivate(StandardState),
+errorState(0), initialState(0), childMode(QState::ExclusiveStates),
+childStatesListNeedsRefresh(true), transitionsListNeedsRefresh(true)
 {
 }
 QStatePrivate::~QStatePrivate()
 {
 {
 Q_Q(QState);
 emit q->finished();
 }
-void QStatePrivate::emitPolished()
+void QStatePrivate::emitPropertiesAssigned()
 {
 Q_Q(QState);
-emit q->polished();
+emit q->propertiesAssigned();
 }
 /*!
 Constructs a new state with the given \a parent state.
 */
 {
 }
 QList<QAbstractState*> QStatePrivate::childStates() const
 {
-QList<QAbstractState*> result;
+if (childStatesListNeedsRefresh) {
-QList<QObject*>::const_iterator it;
+childStatesList.clear();
-for (it = children.constBegin(); it != children.constEnd(); ++it) {
+QList<QObject*>::const_iterator it;
-QAbstractState *s = qobject_cast<QAbstractState*>(*it);
+for (it = children.constBegin(); it != children.constEnd(); ++it) {
-if (!s || qobject_cast<QHistoryState*>(s))
+QAbstractState *s = qobject_cast<QAbstractState*>(*it);
-continue;
+if (!s || qobject_cast<QHistoryState*>(s))
-result.append(s);
+continue;
-}
+childStatesList.append(s);
-return result;
+}
+childStatesListNeedsRefresh = false;
+}
+return childStatesList;
 }
 QList<QHistoryState*> QStatePrivate::historyStates() const
 {
 QList<QHistoryState*> result;
 return result;
 }
 QList<QAbstractTransition*> QStatePrivate::transitions() const
 {
-QList<QAbstractTransition*> result;
+if (transitionsListNeedsRefresh) {
-QList<QObject*>::const_iterator it;
+transitionsList.clear();
-for (it = children.constBegin(); it != children.constEnd(); ++it) {
+QList<QObject*>::const_iterator it;
-QAbstractTransition *t = qobject_cast<QAbstractTransition*>(*it);
+for (it = children.constBegin(); it != children.constEnd(); ++it) {
-if (t)
+QAbstractTransition *t = qobject_cast<QAbstractTransition*>(*it);
-result.append(t);
+if (t)
-}
+transitionsList.append(t);
-return result;
+}
+transitionsListNeedsRefresh = false;
+}
+return transitionsList;
 }
 #ifndef QT_NO_PROPERTIES
 /*!
 Instructs this state to set the property with the given \a name of the given
 \a object to the given \a value when the state is entered.
-\sa polished()
+\sa propertiesAssigned()
 */
 void QState::assignProperty(QObject *object, const char *name,
 const QVariant &value)
 {
 Q_D(QState);
 d->errorState = state;
 }
 /*!
 Adds the given \a transition. The transition has this state as the source.
-This state takes ownership of the transition. If the transition is successfully
+This state takes ownership of the transition.
-added, the function will return the \a transition pointer. Otherwise it will return null.
+*/
-*/
+void QState::addTransition(QAbstractTransition *transition)
-QAbstractTransition *QState::addTransition(QAbstractTransition *transition)
 {
 Q_D(QState);
 if (!transition) {
 qWarning("QState::addTransition: cannot add null transition");
-return 0;
+return ;
 }
 transition->setParent(this);
 const QList<QWeakPointer<QAbstractState> > &targets = QAbstractTransitionPrivate::get(transition)->targetStates;
 for (int i = 0; i < targets.size(); ++i) {
 QAbstractState *t = targets.at(i).data();
 if (!t) {
 qWarning("QState::addTransition: cannot add transition to null state");
-return 0;
+return ;
 }
 if ((QAbstractStatePrivate::get(t)->machine() != d->machine())
 && QAbstractStatePrivate::get(t)->machine() && d->machine()) {
 qWarning("QState::addTransition: cannot add transition "
 "to a state in a different state machine");
-return 0;
+return ;
 }
 }
 if (machine() != 0 && machine()->configuration().contains(this))
 QStateMachinePrivate::get(machine())->registerTransitions(this);
-return transition;
 }
 /*!
 Adds a transition associated with the given \a signal of the given \a sender
 object, and returns the new QSignalTransition object. The transition has
 if (!target) {
 qWarning("QState::addTransition: cannot add transition to null state");
 return 0;
 }
 UnconditionalTransition *trans = new UnconditionalTransition(target);
-return addTransition(trans);
+addTransition(trans);
+return trans;
 }
 /*!
 Removes the given \a transition from this state.  The state releases
 ownership of the transition.
 /*!
 \reimp
 */
 bool QState::event(QEvent *e)
 {
+Q_D(QState);
+if ((e->type() == QEvent::ChildAdded) || (e->type() == QEvent::ChildRemoved)) {
+d->childStatesListNeedsRefresh = true;
+d->transitionsListNeedsRefresh = true;
+}
 return QAbstractState::event(e);
 }
 /*!
 \fn QState::finished()
 \sa QFinalState
 */
 /*!
-\fn QState::polished()
+\fn QState::propertiesAssigned()
-This signal is emitted when all properties have been assigned their final value.
+This signal is emitted when all properties have been assigned their final value. If the state
+assigns a value to one or more properties for which an animation exists (either set on the
+transition or as a default animation on the state machine), then the signal will not be emitted
+until all such animations have finished playing.
+If there are no relevant animations, or no property assignments defined for the state, then
+the signal will be emitted immediately before the state is entered.
 \sa QState::assignProperty(), QAbstractTransition::addAnimation()
 */
 QT_END_NAMESPACE

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