FCL/sf/mw/qt: comparison src/declarative/util/qdeclarativeanimation.cpp

equal deleted inserted replaced

-:5dc02b23752f
+:3e2da88830cd
 {
 Q_D(const QDeclarativeAbstractAnimation);
 return d->running;
 }
+// the behavior calls this function
+void QDeclarativeAbstractAnimation::notifyRunningChanged(bool running)
+{
+Q_D(QDeclarativeAbstractAnimation);
+if (d->disableUserControl && d->running != running) {
+d->running = running;
+emit runningChanged(running);
+}
+}
 //commence is called to start an animation when it is used as a
 //simple animation, and not as part of a transition
 void QDeclarativeAbstractAnimationPrivate::commence()
 {
 Q_Q(QDeclarativeAbstractAnimation);
 void QDeclarativeAbstractAnimation::setRunning(bool r)
 {
 Q_D(QDeclarativeAbstractAnimation);
 if (!d->componentComplete) {
+if (d->running && r == d->running)    //don't re-register
+return;
 d->running = r;
 if (r == false)
 d->avoidPropertyValueSourceStart = true;
 else {
 QDeclarativeEnginePrivate *engPriv = QDeclarativeEnginePrivate::get(qmlEngine(this));
 NumberAnimation { ... duration: 200 }
 PauseAnimation { duration: 100 }
 NumberAnimation { ... duration: 200 }
 }
 \endcode
+\sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 /*!
 \internal
 \class QDeclarativePauseAnimation
 */
 /*!
 \qmlclass ColorAnimation QDeclarativeColorAnimation
 \since 4.7
 \inherits PropertyAnimation
-\brief The ColorAnimation element allows you to animate color changes.
+\brief The ColorAnimation element animates changes in color values.
-\code
+ColorAnimation is a specialized PropertyAnimation that defines an
-ColorAnimation { from: "white"; to: "#c0c0c0"; duration: 100 }
+animation to be applied when a color value changes.
-\endcode
+Here is a ColorAnimation applied to the \c color property of a \l Rectangle
+as a property value source. It animates the \c color property's value from
+its current value to a value of "red", over 1000 milliseconds:
+\snippet doc/src/snippets/declarative/coloranimation.qml 0
+Like any other animation element, a ColorAnimation can be applied in a
+number of ways, including transitions, behaviors and property value
+sources. The \l PropertyAnimation documentation shows a variety of methods
+for creating animations.
 When used in a transition, ColorAnimation will by default animate
-all properties of type color that are changing. If a property or properties
+all properties of type color that have changed. If a \l{PropertyAnimation::}{property}
-are explicitly set for the animation, then those will be used instead.
+or \l{PropertyAnimation::}{properties} are explicitly set for the animation,
+then those are used instead.
+\sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 /*!
 \internal
 \class QDeclarativeColorAnimation
 */
 {
 }
 /*!
 \qmlproperty color ColorAnimation::from
-This property holds the starting color.
+This property holds the color value at which the animation should begin.
+For example, the following animation is not applied until a color value
+has reached "#c0c0c0":
+\qml
+Item {
+states: [ ... ]
+transition: Transition {
+NumberAnimation { from: "#c0c0c0"; duration: 2000 }
+}
+}
+\endqml
+If this value is not set and the ColorAnimation is defined within
+a \l Transition, it defaults to the value defined in the starting
+state of the \l Transition.
 */
 QColor QDeclarativeColorAnimation::from() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 return d->from.value<QColor>();
 QDeclarativePropertyAnimation::setFrom(f);
 }
 /*!
 \qmlproperty color ColorAnimation::to
-This property holds the ending color.
+This property holds the color value at which the animation should end.
+If this value is not set and the ColorAnimation is defined within
+a \l Transition or \l Behavior, it defaults to the value defined in the end
+state of the \l Transition or \l Behavior.
 */
 QColor QDeclarativeColorAnimation::to() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 return d->to.value<QColor>();
 \qmlclass PropertyAction QDeclarativePropertyAction
 \since 4.7
 \inherits Animation
 \brief The PropertyAction element allows immediate property changes during animation.
-Explicitly set \c theimage.smooth=true during a transition:
+PropertyAction is used to specify an immediate property change
+during an animation. The property change is not animated.
+For example, to explicitly set \c {theImage.smooth = true} during a \l Transition:
 \code
-PropertyAction { target: theimage; property: "smooth"; value: true }
+transitions: Transition {
+...
+PropertyAction { target: theImage; property: "smooth"; value: true }
+...
+}
 \endcode
-Set \c thewebview.url to the value set for the destination state:
+Or, to set \c theWebView.url to the value set for the destination state:
 \code
-PropertyAction { target: thewebview; property: "url" }
+transitions: Transition {
+...
+PropertyAction { target: theWebView; property: "url" }
+...
+}
 \endcode
-The PropertyAction is immediate -
-the target property is not animated to the selected value in any way.
 \sa QtDeclarative
 */
 /*!
 \internal
 Q_Q(QDeclarativePropertyAction);
 spa = new QActionAnimation;
 QDeclarative_setParent_noEvent(spa, q);
 }
-/*!
-\qmlproperty Object PropertyAction::target
-This property holds an explicit target object to animate.
-The exact effect of the \c target property depends on how the animation
-is being used.  Refer to the \l {QML Animation} documentation for details.
-*/
 QObject *QDeclarativePropertyAction::target() const
 {
 Q_D(const QDeclarativePropertyAction);
 return d->target;
 }
 d->propertyName = n;
 emit targetChanged(d->target, d->propertyName);
 }
 /*!
+\qmlproperty Object PropertyAction::target
 \qmlproperty list<Object> PropertyAction::targets
 \qmlproperty string PropertyAction::property
 \qmlproperty string PropertyAction::properties
-\qmlproperty Object PropertyAction::target
+These properties determine the items and their properties that are
-These properties are used as a set to determine which properties should be
 affected by this action.
 The details of how these properties are interpreted in different situations
 is covered in the \l{PropertyAnimation::properties}{corresponding} PropertyAnimation
 documentation.
 return QDeclarativeListProperty<QObject>(this, d->targets);
 }
 /*!
 \qmlproperty list<Object> PropertyAction::exclude
-This property holds the objects not to be affected by this animation.
+This property holds the objects that should not be affected by this action.
 \sa targets
 */
 QDeclarativeListProperty<QObject> QDeclarativePropertyAction::exclude()
 {
 /*!
 \qmlclass NumberAnimation QDeclarativeNumberAnimation
 \since 4.7
 \inherits PropertyAnimation
-\brief The NumberAnimation element allows you to animate changes in properties of type qreal.
+\brief The NumberAnimation element animates changes in qreal-type values.
-Animate a set of properties over 200ms, from their values in the start state to
+NumberAnimation is a specialized PropertyAnimation that defines an
-their values in the end state of the transition:
+animation to be applied when a numerical value changes.
-\code
-NumberAnimation { properties: "x,y,scale"; duration: 200 }
+Here is a NumberAnimation applied to the \c x property of a \l Rectangle
-\endcode
+as a property value source. It animates the \c x value from its current
+value to a value of 50, over 1000 milliseconds:
+\snippet doc/src/snippets/declarative/numberanimation.qml 0
+Like any other animation element, a NumberAnimation can be applied in a
+number of ways, including transitions, behaviors and property value
+sources. The \l PropertyAnimation documentation shows a variety of methods
+for creating animations.
+Note that NumberAnimation may not animate smoothly if there are irregular
+changes in the number value that it is tracking. If this is the case, use
+SmoothedAnimation instead.
+\sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 /*!
 \internal
 \class QDeclarativeNumberAnimation
 d->interpolator = QVariantAnimationPrivate::getInterpolator(d->interpolatorType);
 }
 /*!
 \qmlproperty real NumberAnimation::from
-This property holds the starting value.
+This property holds the starting number value.
-If not set, then the value defined in the start state of the transition.
-*/
+For example, the following animation is not applied until the \c x value
+has reached 100:
+\qml
+Item {
+states: [ ... ]
+transition: Transition {
+NumberAnimation { properties: "x"; from: 100; duration: 200 }
+}
+}
+\endqml
+If this value is not set and the NumberAnimation is defined within
+a \l Transition, it defaults to the value defined in the start
+state of the \l Transition.
+*/
 qreal QDeclarativeNumberAnimation::from() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 return d->from.toReal();
 }
 QDeclarativePropertyAnimation::setFrom(f);
 }
 /*!
 \qmlproperty real NumberAnimation::to
-This property holds the ending value.
+This property holds the ending number value.
-If not set, then the value defined in the end state of the transition or Behavior.
+If this value is not set and the NumberAnimation is defined within
+a \l Transition or \l Behavior, it defaults to the value defined in the end
+state of the \l Transition or \l Behavior.
 */
 qreal QDeclarativeNumberAnimation::to() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 return d->to.toReal();
 /*!
 \qmlclass Vector3dAnimation QDeclarativeVector3dAnimation
 \since 4.7
 \inherits PropertyAnimation
-\brief The Vector3dAnimation element allows you to animate changes in properties of type QVector3d.
+\brief The Vector3dAnimation element animates changes in QVector3d values.
+Vector3dAnimation is a specialized PropertyAnimation that defines an
+animation to be applied when a Vector3d value changes.
+\sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 /*!
 \internal
 \class QDeclarativeVector3dAnimation
 }
 /*!
 \qmlproperty real Vector3dAnimation::from
 This property holds the starting value.
-If not set, then the value defined in the start state of the transition.
+If this value is not set, it defaults to the value defined in the start
+state of the \l Transition.
 */
 QVector3D QDeclarativeVector3dAnimation::from() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 return d->from.value<QVector3D>();
 }
 /*!
 \qmlproperty real Vector3dAnimation::to
 This property holds the ending value.
-If not set, then the value defined in the end state of the transition or Behavior.
+If this value is not set, it defaults to the value defined in the end
+state of the \l Transition or \l Behavior.
 */
 QVector3D QDeclarativeVector3dAnimation::to() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 return d->to.value<QVector3D>();
 /*!
 \qmlclass RotationAnimation QDeclarativeRotationAnimation
 \since 4.7
 \inherits PropertyAnimation
-\brief The RotationAnimation element allows you to animate rotations.
+\brief The RotationAnimation element animates changes in rotation values.
 RotationAnimation is a specialized PropertyAnimation that gives control
-over the direction of rotation. By default, it will rotate in the direction
+over the direction of rotation during an animation.
+By default, it rotates in the direction
 of the numerical change; a rotation from 0 to 240 will rotate 220 degrees
 clockwise, while a rotation from 240 to 0 will rotate 220 degrees
-counterclockwise.
+counterclockwise. The \l direction property can be set to specify the
+direction in which the rotation should occur.
-When used in a transition RotationAnimation will rotate all
+In the following example we use RotationAnimation to animate the rotation
+between states via the shortest path:
+\snippet doc/src/snippets/declarative/rotationanimation.qml 0
+Notice the RotationAnimation did not need to set a \l {RotationAnimation::}{target}
+value. As a convenience, when used in a transition, RotationAnimation will rotate all
 properties named "rotation" or "angle". You can override this by providing
-your own properties via \c properties or \c property.
+your own properties via \l {PropertyAnimation::properties}{properties} or
+\l {PropertyAnimation::property}{property}.
-In the following example we use RotationAnimation to animate the rotation
-between states via the shortest path.
+Like any other animation element, a RotationAnimation can be applied in a
-\qml
+number of ways, including transitions, behaviors and property value
-states: {
+sources. The \l PropertyAnimation documentation shows a variety of methods
-State { name: "180"; PropertyChanges { target: myItem; rotation: 180 } }
+for creating animations.
-State { name: "90"; PropertyChanges { target: myItem; rotation: 90 } }
-State { name: "-90"; PropertyChanges { target: myItem; rotation: -90 } }
+\sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
-}
-transition: Transition {
-RotationAnimation { direction: RotationAnimation.Shortest }
-}
-\endqml
 */
 /*!
 \internal
 \class QDeclarativeRotationAnimation
 {
 }
 /*!
 \qmlproperty real RotationAnimation::from
-This property holds the starting value.
+This property holds the starting number value.
-If not set, then the value defined in the start state of the transition.
+For example, the following animation is not applied until the \c angle value
+has reached 100:
+\qml
+Item {
+states: [ ... ]
+transition: Transition {
+RotationAnimation { properties: "angle"; from: 100; duration: 2000 }
+}
+}
+\endqml
+If this value is not set, it defaults to the value defined in the start
+state of the \l Transition.
 */
 qreal QDeclarativeRotationAnimation::from() const
 {
 Q_D(const QDeclarativeRotationAnimation);
 return d->from.toReal();
 }
 /*!
 \qmlproperty real RotationAnimation::to
 This property holds the ending value.
-If not set, then the value defined in the end state of the transition or Behavior.
+If this value is not set, it defaults to the value defined in the end
+state of the \l Transition or \l Behavior.
 */
 qreal QDeclarativeRotationAnimation::to() const
 {
 Q_D(const QDeclarativeRotationAnimation);
 return d->to.toReal();
 QDeclarativePropertyAnimation::setTo(t);
 }
 /*!
 \qmlproperty enumeration RotationAnimation::direction
-The direction in which to rotate.
+This property holds the direction of the rotation.
 Possible values are:
-\table
+\list
-\row
+\o RotationAnimation.Numerical (default) - Rotate by linearly interpolating between the two numbers.
-\o RotationAnimation.Numerical
-\o Rotate by linearly interpolating between the two numbers.
 A rotation from 10 to 350 will rotate 340 degrees clockwise.
-\row
+\o RotationAnimation.Clockwise - Rotate clockwise between the two values
-\o RotationAnimation.Clockwise
+\o RotationAnimation.Counterclockwise - Rotate counterclockwise between the two values
-\o Rotate clockwise between the two values
+\o RotationAnimation.Shortest - Rotate in the direction that produces the shortest animation path.
-\row
-\o RotationAnimation.Counterclockwise
-\o Rotate counterclockwise between the two values
-\row
-\o RotationAnimation.Shortest
-\o Rotate in the direction that produces the shortest animation path.
 A rotation from 10 to 350 will rotate 20 degrees counterclockwise.
-\endtable
+\endlist
-The default direction is RotationAnimation.Numerical.
 */
 QDeclarativeRotationAnimation::RotationDirection QDeclarativeRotationAnimation::direction() const
 {
 Q_D(const QDeclarativeRotationAnimation);
 return d->direction;
 /*!
 \qmlclass SequentialAnimation QDeclarativeSequentialAnimation
 \since 4.7
 \inherits Animation
-\brief The SequentialAnimation element allows you to run animations sequentially.
+\brief The SequentialAnimation element allows animations to be run sequentially.
-Animations controlled in SequentialAnimation will be run one after the other.
+The SequentialAnimation and ParallelAnimation elements allow multiple
+animations to be run together. Animations defined in a SequentialAnimation
-The following example chains two numeric animations together.  The \c MyItem
+are run one after the other, while animations defined in a ParallelAnimation
-object will animate from its current x position to 100, and then back to 0.
+are run at the same time.
-\code
+The following example runs two number animations in a sequence.  The \l Rectangle
-SequentialAnimation {
+animates to a \c x position of 50, then to a \c y position of 50.
-NumberAnimation { target: MyItem; property: "x"; to: 100 }
-NumberAnimation { target: MyItem; property: "x"; to: 0 }
+\snippet doc/src/snippets/declarative/sequentialanimation.qml 0
-}
-\endcode
+Animations defined within a \l Transition are automatically run in parallel,
+so SequentialAnimation can be used to enclose the animations in a \l Transition
-\sa ParallelAnimation
+if this is the preferred behavior.
+Like any other animation element, a SequentialAnimation can be applied in a
+number of ways, including transitions, behaviors and property value
+sources. The \l PropertyAnimation documentation shows a variety of methods
+for creating animations.
+\sa ParallelAnimation, {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 QDeclarativeSequentialAnimation::QDeclarativeSequentialAnimation(QObject *parent) :
 QDeclarativeAnimationGroup(parent)
 {
 /*!
 \qmlclass ParallelAnimation QDeclarativeParallelAnimation
 \since 4.7
 \inherits Animation
-\brief The ParallelAnimation element allows you to run animations in parallel.
+\brief The ParallelAnimation element allows animations to be run in parallel.
-Animations contained in ParallelAnimation will be run at the same time.
+The SequentialAnimation and ParallelAnimation elements allow multiple
+animations to be run together. Animations defined in a SequentialAnimation
-The following animation demonstrates animating the \c MyItem item
+are run one after the other, while animations defined in a ParallelAnimation
-to (100,100) by animating the x and y properties in parallel.
+are run at the same time.
-\code
+The following animation runs two number animations in parallel. The \l Rectangle
-ParallelAnimation {
+moves to (50,50) by animating its \c x and \c y properties at the same time.
-NumberAnimation { target: MyItem; property: "x"; to: 100 }
-NumberAnimation { target: MyItem; property: "y"; to: 100 }
+\snippet doc/src/snippets/declarative/parallelanimation.qml 0
-}
-\endcode
+Like any other animation element, a ParallelAnimation can be applied in a
+number of ways, including transitions, behaviors and property value
-\sa SequentialAnimation
+sources. The \l PropertyAnimation documentation shows a variety of methods
+for creating animations.
+\sa SequentialAnimation, {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 /*!
 \internal
 \class QDeclarativeParallelAnimation
 */
 /*!
 \qmlclass PropertyAnimation QDeclarativePropertyAnimation
 \since 4.7
 \inherits Animation
-\brief The PropertyAnimation element allows you to animate property changes.
+\brief The PropertyAnimation element animates changes in property values.
-PropertyAnimation provides a way to animate changes to a property's value. It can
+PropertyAnimation provides a way to animate changes to a property's value.
-be used in many different situations:
+It can be used to define animations in a number of ways:
 \list
-\o In a Transition
+\o In a \l Transition
-Animate any objects that have changed their x or y properties in the target state using
+For example, to animate any objects that have changed their \c x or \c y properties
-an InOutQuad easing curve:
+as a result of a state change, using an \c InOutQuad easing curve:
-\qml
-Transition { PropertyAnimation { properties: "x,y"; easing.type: Easing.InOutQuad } }
+\snippet doc/src/snippets/declarative/propertyanimation.qml transition
-\endqml
-\o In a Behavior
+\o In a \l Behavior
-Animate all changes to a rectangle's x property.
-\qml
+For example, to animate all changes to a rectangle's \c x property:
-Rectangle {
-Behavior on x { PropertyAnimation {} }
+\snippet doc/src/snippets/declarative/propertyanimation.qml behavior
-}
-\endqml
 \o As a property value source
-Repeatedly animate the rectangle's x property.
+For example, to repeatedly animate the rectangle's \c x property:
-\qml
-Rectangle {
+\snippet doc/src/snippets/declarative/propertyanimation.qml propertyvaluesource
-SequentialAnimation on x {
-loops: Animation.Infinite
-PropertyAnimation { to: 50 }
-PropertyAnimation { to: 0 }
-}
-}
-\endqml
 \o In a signal handler
-Fade out \c theObject when clicked:
+For example, to fade out \c theObject when clicked:
 \qml
 MouseArea {
 anchors.fill: theObject
 onClicked: PropertyAnimation { target: theObject; property: "opacity"; to: 0 }
 }
 \endqml
 \o Standalone
-Animate \c theObject's size property over 200ms, from its current size to 20-by-20:
+For example, to animate \c rect's \c width property over 500ms, from its current width to 30:
-\qml
-PropertyAnimation { target: theObject; property: "size"; to: "20x20"; duration: 200 }
+\snippet doc/src/snippets/declarative/propertyanimation.qml standalone
-\endqml
 \endlist
 Depending on how the animation is used, the set of properties normally used will be
 different. For more information see the individual property documentation, as well
 as the \l{QML Animation} introduction.
+Note that PropertyAnimation inherits the abstract \l Animation element.
+This includes additional properties and methods for controlling the animation.
+\sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 QDeclarativePropertyAnimation::QDeclarativePropertyAnimation(QObject *parent)
 : QDeclarativeAbstractAnimation(*(new QDeclarativePropertyAnimationPrivate), parent)
 {
 }
 /*!
 \qmlproperty real PropertyAnimation::to
 This property holds the ending value.
-If not set, then the value defined in the end state of the transition or Behavior.
+If not set, then the value defined in the end state of the transition or \l Behavior.
 */
 QVariant QDeclarativePropertyAnimation::to() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 return d->to;
 \qmlproperty real PropertyAnimation::easing.period
 \brief the easing curve used for the animation.
 To specify an easing curve you need to specify at least the type. For some curves you can also specify
 amplitude, period and/or overshoot (more details provided after the table). The default easing curve is
-Linear.
+\c Easing.Linear.
 \qml
 PropertyAnimation { properties: "y"; easing.type: Easing.InOutElastic; easing.amplitude: 2.0; easing.period: 1.5 }
 \endqml
 \o \c Easing.OutInBounce
 \o Easing curve for a bounce (exponentially decaying parabolic bounce) function easing out/in: deceleration until halfway, then acceleration.
 \o \inlineimage qeasingcurve-outinbounce.png
 \endtable
-easing.amplitude is only applicable for bounce and elastic curves (curves of type
+\c easing.amplitude is only applicable for bounce and elastic curves (curves of type
-Easing.InBounce, Easing.OutBounce, Easing.InOutBounce, Easing.OutInBounce, Easing.InElastic,
+\c Easing.InBounce, \c Easing.OutBounce, \c Easing.InOutBounce, \c Easing.OutInBounce, \c Easing.InElastic,
-Easing.OutElastic, Easing.InOutElastic or Easing.OutInElastic).
+\c Easing.OutElastic, \c Easing.InOutElastic or \c Easing.OutInElastic).
-easing.overshoot is only applicable if type is: Easing.InBack, Easing.OutBack,
+\c easing.overshoot is only applicable if \c easing.type is: \c Easing.InBack, \c Easing.OutBack,
-Easing.InOutBack or Easing.OutInBack.
+\c Easing.InOutBack or \c Easing.OutInBack.
-easing.period is only applicable if type is: Easing.InElastic, Easing.OutElastic,
+\c easing.period is only applicable if easing.type is: \c Easing.InElastic, \c Easing.OutElastic,
-Easing.InOutElastic or Easing.OutInElastic.
+\c Easing.InOutElastic or \c Easing.OutInElastic.
 See the \l {declarative/animation/easing}{easing} example for a demonstration of
 the different easing settings.
 */
 QEasingCurve QDeclarativePropertyAnimation::easing() const
 {
 Q_D(const QDeclarativePropertyAnimation);
-return d->easing;
+return d->va->easingCurve();
 }
 void QDeclarativePropertyAnimation::setEasing(const QEasingCurve &e)
 {
 Q_D(QDeclarativePropertyAnimation);
-if (d->easing == e)
+if (d->va->easingCurve() == e)
 return;
-d->easing = e;
+d->va->setEasingCurve(e);
-d->va->setEasingCurve(d->easing);
 emit easingChanged(e);
 }
 QObject *QDeclarativePropertyAnimation::target() const
 {
 NumberAnimation { targets: theItem; properties: "x"; to: 500 }
 \endqml
 The singular forms are slightly optimized, so if you do have only a single target/property
 to animate you should try to use them.
-In many cases these properties do not need to be explicitly specified -- they can be
+In many cases these properties do not need to be explicitly specified, as they can be
-inferred from the animation framework.
+inferred from the animation framework:
 \table 80%
 \row
 \o Value Source / Behavior
 \o When an animation is used as a value source or in a Behavior, the default target and property
 name to be animated can both be inferred.
 {
 Q_D(QDeclarativePropertyAnimation);
 return d->va;
 }
-struct PropertyUpdater : public QDeclarativeBulkValueUpdater
+void QDeclarativeAnimationPropertyUpdater::setValue(qreal v)
 {
-QDeclarativeStateActions actions;
+bool deleted = false;
-int interpolatorType;       //for Number/ColorAnimation
+wasDeleted = &deleted;
-int prevInterpolatorType;   //for generic
+if (reverse)    //QVariantAnimation sends us 1->0 when reversed, but we are expecting 0->1
-QVariantAnimation::Interpolator interpolator;
+v = 1 - v;
-bool reverse;
+for (int ii = 0; ii < actions.count(); ++ii) {
-bool fromSourced;
+QDeclarativeAction &action = actions[ii];
-bool fromDefined;
-bool *wasDeleted;
+if (v == 1.)
-PropertyUpdater() : prevInterpolatorType(0), wasDeleted(0) {}
+QDeclarativePropertyPrivate::write(action.property, action.toValue, QDeclarativePropertyPrivate::BypassInterceptor | QDeclarativePropertyPrivate::DontRemoveBinding);
-~PropertyUpdater() { if (wasDeleted) *wasDeleted = true; }
+else {
-void setValue(qreal v)
+if (!fromSourced && !fromDefined) {
-{
+action.fromValue = action.property.read();
-bool deleted = false;
+if (interpolatorType)
-wasDeleted = &deleted;
+QDeclarativePropertyAnimationPrivate::convertVariant(action.fromValue, interpolatorType);
-if (reverse)    //QVariantAnimation sends us 1->0 when reversed, but we are expecting 0->1
+}
-v = 1 - v;
+if (!interpolatorType) {
-for (int ii = 0; ii < actions.count(); ++ii) {
+int propType = action.property.propertyType();
-QDeclarativeAction &action = actions[ii];
+if (!prevInterpolatorType || prevInterpolatorType != propType) {
+prevInterpolatorType = propType;
-if (v == 1.)
+interpolator = QVariantAnimationPrivate::getInterpolator(prevInterpolatorType);
-QDeclarativePropertyPrivate::write(action.property, action.toValue, QDeclarativePropertyPrivate::BypassInterceptor | QDeclarativePropertyPrivate::DontRemoveBinding);
-else {
-if (!fromSourced && !fromDefined) {
-action.fromValue = action.property.read();
-if (interpolatorType)
-QDeclarativePropertyAnimationPrivate::convertVariant(action.fromValue, interpolatorType);
 }
-if (!interpolatorType) {
-int propType = action.property.propertyType();
-if (!prevInterpolatorType || prevInterpolatorType != propType) {
-prevInterpolatorType = propType;
-interpolator = QVariantAnimationPrivate::getInterpolator(prevInterpolatorType);
-}
-}
-if (interpolator)
-QDeclarativePropertyPrivate::write(action.property, interpolator(action.fromValue.constData(), action.toValue.constData(), v), QDeclarativePropertyPrivate::BypassInterceptor | QDeclarativePropertyPrivate::DontRemoveBinding);
 }
-if (deleted)
+if (interpolator)
-return;
+QDeclarativePropertyPrivate::write(action.property, interpolator(action.fromValue.constData(), action.toValue.constData(), v), QDeclarativePropertyPrivate::BypassInterceptor | QDeclarativePropertyPrivate::DontRemoveBinding);
 }
-wasDeleted = 0;
+if (deleted)
-fromSourced = true;
+return;
 }
-};
+wasDeleted = 0;
+fromSourced = true;
+}
 void QDeclarativePropertyAnimation::transition(QDeclarativeStateActions &actions,
 QDeclarativeProperties &modified,
 TransitionDirection direction)
 {
 if (props.isEmpty() && !d->defaultProperties.isEmpty()) {
 props << d->defaultProperties.split(QLatin1Char(','));
 }
-PropertyUpdater *data = new PropertyUpdater;
+QDeclarativeAnimationPropertyUpdater *data = new QDeclarativeAnimationPropertyUpdater;
 data->interpolatorType = d->interpolatorType;
 data->interpolator = d->interpolator;
 data->reverse = direction == Backward ? true : false;
 data->fromSourced = false;
 data->fromDefined = d->fromIsDefined;
 /*!
 \qmlclass ParentAnimation QDeclarativeParentAnimation
 \since 4.7
 \inherits Animation
-\brief The ParentAnimation element allows you to animate parent changes.
+\brief The ParentAnimation element animates changes in parent values.
-ParentAnimation is used in conjunction with NumberAnimation to smoothly
+ParentAnimation defines an animation to applied when a ParentChange
-animate changing an item's parent. In the following example,
+occurs. This allows parent changes to be smoothly animated.
-ParentAnimation wraps a NumberAnimation which animates from the
-current position in the old parent to the new position in the new
+For example, the following ParentChange changes \c blueRect to become
-parent.
+a child of \c redRect when it is clicked. The inclusion of the
+ParentAnimation, which defines a NumberAnimation to be applied during
-\qml
+the transition, ensures the item animates smoothly as it moves to
-...
+its new parent:
-State {
-//reparent myItem to newParent. myItem's final location
+\snippet doc/src/snippets/declarative/parentanimation.qml 0
-//should be 10,10 in newParent.
-ParentChange {
+A ParentAnimation can contain any number of animations. These animations will
-target: myItem
+be run in parallel; to run them sequentially, define them within a
-parent: newParent
+SequentialAnimation.
-x: 10; y: 10
-}
+In some cases, such as when reparenting between items with clipping enabled, it is useful
-}
+to animate the parent change via another item that does not have clipping
-...
+enabled. Such an item can be set using the \l via property.
-Transition {
-//smoothly reparent myItem and move into new position
+By default, when used in a transition, ParentAnimation animates all parent
-ParentAnimation {
+changes. This can be overriden by setting a specific target item using the
-target: theItem
+\l target property.
-NumberAnimation { properties: "x,y" }
-}
+\sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
-}
-\endqml
-ParentAnimation can wrap any number of animations -- those animations will
-be run in parallel (like those in a ParallelAnimation group).
-In some cases, such as reparenting between items with clipping, it's useful
-to animate the parent change via another item with no clipping.
-When used in a transition, ParentAnimation will by default animate
-all ParentChanges.
 */
 /*!
 \internal
 \class QDeclarativeParentAnimation
 /*!
 \qmlproperty Item ParentAnimation::target
 The item to reparent.
-When used in a transition, if no target is specified all
+When used in a transition, if no target is specified, all
-ParentChanges will be animated by the ParentAnimation.
+ParentChange occurrences are animated by the ParentAnimation.
 */
 QDeclarativeItem *QDeclarativeParentAnimation::target() const
 {
 Q_D(const QDeclarativeParentAnimation);
 return d->target;
 }
 /*!
 \qmlproperty Item ParentAnimation::via
 The item to reparent via. This provides a way to do an unclipped animation
-when both the old parent and new parent are clipped
+when both the old parent and new parent are clipped.
 \qml
 ParentAnimation {
 target: myItem
 via: topLevelItem
 /*!
 \qmlclass AnchorAnimation QDeclarativeAnchorAnimation
 \since 4.7
 \inherits Animation
-\brief The AnchorAnimation element allows you to animate anchor changes.
+\brief The AnchorAnimation element animates changes in anchor values.
-AnchorAnimation will animated any changes specified by a state's AnchorChanges.
+AnchorAnimation is used to animate an AnchorChange. It will anchor all
-In the following snippet we animate the addition of a right anchor to our item.
+anchor changes specified in a \l State.
-\qml
-Item {
+In the following snippet we animate the addition of a right anchor to a \l Rectangle:
-id: myItem
-width: 100
+\snippet doc/src/snippets/declarative/anchoranimation.qml 0
-}
-...
-State {
-AnchorChanges {
-target: myItem
-anchors.right: container.right
-}
-}
-...
-Transition {
-//smoothly reanchor myItem and move into new position
-AnchorAnimation {}
-}
-\endqml
 \sa AnchorChanges
 */
 QDeclarativeAnchorAnimation::QDeclarativeAnchorAnimation(QObject *parent)
 QDeclarativeProperties &modified,
 TransitionDirection direction)
 {
 Q_UNUSED(modified);
 Q_D(QDeclarativeAnchorAnimation);
-PropertyUpdater *data = new PropertyUpdater;
+QDeclarativeAnimationPropertyUpdater *data = new QDeclarativeAnimationPropertyUpdater;
 data->interpolatorType = QMetaType::QReal;
 data->interpolator = d->interpolator;
 data->reverse = direction == Backward ? true : false;
 data->fromSourced = false;

changeset 33	3e2da88830cd
parent 30	5dc02b23752f
child 37	758a864f9613