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

equal deleted inserted replaced

-:ef0373b55136
+:758a864f9613
 QT_BEGIN_NAMESPACE
 /*!
 \qmlclass Animation QDeclarativeAbstractAnimation
+\ingroup qml-animation-transition
 \since 4.7
 \brief The Animation element is the base of all QML animations.
 The Animation element cannot be used directly in a QML file.  It exists
 to provide a set of common properties and methods, available across all the
 other animation types that inherit from it.  Attempting to use the Animation
 element directly will result in an error.
-*/
-/*!
-\class QDeclarativeAbstractAnimation
-\internal
 */
 QDeclarativeAbstractAnimation::QDeclarativeAbstractAnimation(QObject *parent)
 : QObject(*(new QDeclarativeAbstractAnimationPrivate), parent)
 {
 If set to Animation.Infinite, the animation will continuously repeat until it is explicitly
 stopped - either by setting the \c running property to false, or by calling
 the \c stop() method.
-In the following example, the rectangle will spin indefinately.
+In the following example, the rectangle will spin indefinitely.
 \code
 Rectangle {
 width: 100; height: 100; color: "green"
 RotationAnimation on rotation {
 }
 }
 /*!
 \qmlclass PauseAnimation QDeclarativePauseAnimation
+\ingroup qml-animation-transition
 \since 4.7
 \inherits Animation
 \brief The PauseAnimation element provides a pause for an animation.
 When used in a SequentialAnimation, PauseAnimation is a step when
 }
 \endcode
 \sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
-/*!
-\internal
-\class QDeclarativePauseAnimation
-*/
 QDeclarativePauseAnimation::QDeclarativePauseAnimation(QObject *parent)
 : QDeclarativeAbstractAnimation(*(new QDeclarativePauseAnimationPrivate), parent)
 {
 Q_D(QDeclarativePauseAnimation);
 d->init();
 return d->pa;
 }
 /*!
 \qmlclass ColorAnimation QDeclarativeColorAnimation
+\ingroup qml-animation-transition
 \since 4.7
 \inherits PropertyAnimation
 \brief The ColorAnimation element animates changes in color values.
 ColorAnimation is a specialized PropertyAnimation that defines an
 \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
+sources. The \l {QML Animation} documentation shows a variety of methods
 for creating animations.
-When used in a transition, ColorAnimation will by default animate
+For convenience, when a ColorAnimation is used in a \l Transition, it will
-all properties of type color that have changed. If a \l{PropertyAnimation::}{property}
+animate any \c color properties that have been modified during the state
-or \l{PropertyAnimation::}{properties} are explicitly set for the animation,
+change. If a \l{PropertyAnimation::}{property} 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
-*/
 QDeclarativeColorAnimation::QDeclarativeColorAnimation(QObject *parent)
 : QDeclarativePropertyAnimation(parent)
 {
 Q_D(QDeclarativePropertyAnimation);
 d->interpolatorType = QMetaType::QColor;
 NumberAnimation { from: "#c0c0c0"; duration: 2000 }
 }
 }
 \endqml
-If this value is not set and the ColorAnimation is defined within
+If the ColorAnimation is defined within a \l Transition or \l Behavior,
-a \l Transition, it defaults to the value defined in the starting
+this value defaults to the value defined in the starting state of the
-state of the \l Transition.
+\l Transition, or the current value of the property at the moment the
+\l Behavior is triggered.
+\sa {QML Animation}
 */
 QColor QDeclarativeColorAnimation::from() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 return d->from.value<QColor>();
 /*!
 \qmlproperty color ColorAnimation::to
 This property holds the color value at which the animation should end.
-If this value is not set and the ColorAnimation is defined within
+If the ColorAnimation is defined within a \l Transition or \l Behavior,
-a \l Transition or \l Behavior, it defaults to the value defined in the end
+this value defaults to the value defined in the end state of the
-state of the \l Transition or \l Behavior.
+\l Transition, or the value of the property change that triggered the
+\l Behavior.
+\sa {QML Animation}
 */
 QColor QDeclarativeColorAnimation::to() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 return d->to.value<QColor>();
 /*!
 \qmlclass ScriptAction QDeclarativeScriptAction
+\ingroup qml-animation-transition
 \since 4.7
 \inherits Animation
 \brief The ScriptAction element allows scripts to be run during an animation.
 ScriptAction can be used to run script at a specific point in an animation.
 }
 }
 \endqml
 \sa StateChangeScript
-*/
-/*!
-\internal
-\class QDeclarativeScriptAction
 */
 QDeclarativeScriptAction::QDeclarativeScriptAction(QObject *parent)
 :QDeclarativeAbstractAnimation(*(new QDeclarativeScriptActionPrivate), parent)
 {
 Q_D(QDeclarativeScriptAction);
 /*!
 \qmlclass PropertyAction QDeclarativePropertyAction
+\ingroup qml-animation-transition
 \since 4.7
 \inherits Animation
 \brief The PropertyAction element allows immediate property changes during animation.
-PropertyAction is used to specify an immediate property change
+PropertyAction is used to specify an immediate property change during an
-during an animation. The property change is not animated.
+animation. The property change is not animated.
-For example, to explicitly set \c {theImage.smooth = true} during a \l Transition:
+It is useful for setting non-animated property values during an animation.
-\code
+For example, here is a SequentialAnimation that sets the image's
+\l {Image::}{smooth} property to \c true, animates the width of the image,
+then sets \l {Image::}{smooth} back to \c false:
+\snippet doc/src/snippets/declarative/propertyaction.qml standalone
+PropertyAction is also useful for setting the exact point at which a property
+change should occur during a \l Transition. For example, if PropertyChanges
+was used in a \l State to rotate an item around a particular
+\l {Item::}{transformOrigin}, it might be implemented like this:
+\snippet doc/src/snippets/declarative/propertyaction.qml transition
+However, with this code, the \c transformOrigin is not set until \e after
+the animation, as a \l State is taken to define the values at the \e end of
+a transition. The animation would rotate at the default \c transformOrigin,
+then jump to \c Item.BottomRight. To fix this, insert a PropertyChanges
+before the RotationAnimation begins:
+\qml
 transitions: Transition {
-...
+SequentialAnimation {
-PropertyAction { target: theImage; property: "smooth"; value: true }
+PropertyAction { target: rect; property: "transformOrigin" }
-...
+RotationAnimation { ... }
 }
-\endcode
+}
+\endqml
-Or, to set \c theWebView.url to the value set for the destination state:
-\code
+This immediately sets the \c transformOrigin property to the value defined
-transitions: Transition {
+in the end state of the \l Transition (i.e. the value defined in the
-...
+PropertyChanges object) so that the rotation animation begins with the
-PropertyAction { target: theWebView; property: "url" }
+correct transform origin.
-...
-}
+\sa {QML Animation}, QtDeclarative
-\endcode
-\sa QtDeclarative
-*/
-/*!
-\internal
-\class QDeclarativePropertyAction
 */
 QDeclarativePropertyAction::QDeclarativePropertyAction(QObject *parent)
 : QDeclarativeAbstractAnimation(*(new QDeclarativePropertyActionPrivate), parent)
 {
 Q_D(QDeclarativePropertyAction);
 {
 Q_D(QDeclarativePropertyAction);
 if (d->target == o)
 return;
 d->target = o;
-emit targetChanged(d->target, d->propertyName);
+emit targetChanged();
 }
 QString QDeclarativePropertyAction::property() const
 {
 Q_D(const QDeclarativePropertyAction);
 {
 Q_D(QDeclarativePropertyAction);
 if (d->propertyName == n)
 return;
 d->propertyName = n;
-emit targetChanged(d->target, d->propertyName);
+emit propertyChanged();
 }
 /*!
 \qmlproperty Object PropertyAction::target
 \qmlproperty list<Object> PropertyAction::targets
 }
 /*!
 \qmlproperty any PropertyAction::value
 This property holds the value to be set on the property.
-If not set, then the value defined for the end state of the transition.
+If the PropertyAction is defined within a \l Transition or \l Behavior,
+this value defaults to the value defined in the end state of the
+\l Transition, or the value of the property change that triggered the
+\l Behavior.
 */
 QVariant QDeclarativePropertyAction::value() const
 {
 Q_D(const QDeclarativePropertyAction);
 return d->value;
 }
 }
 /*!
 \qmlclass NumberAnimation QDeclarativeNumberAnimation
+\ingroup qml-animation-transition
 \since 4.7
 \inherits PropertyAnimation
 \brief The NumberAnimation element animates changes in qreal-type values.
 NumberAnimation is a specialized PropertyAnimation that defines an
 \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
+sources. The \l {QML Animation} 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
-*/
 QDeclarativeNumberAnimation::QDeclarativeNumberAnimation(QObject *parent)
 : QDeclarativePropertyAnimation(parent)
 {
 init();
 }
 d->interpolator = QVariantAnimationPrivate::getInterpolator(d->interpolatorType);
 }
 /*!
 \qmlproperty real NumberAnimation::from
-This property holds the starting number value.
+This property holds the starting value for the animation.
 For example, the following animation is not applied until the \c x value
 has reached 100:
 \qml
 NumberAnimation { properties: "x"; from: 100; duration: 200 }
 }
 }
 \endqml
-If this value is not set and the NumberAnimation is defined within
+If the NumberAnimation is defined within a \l Transition or \l Behavior,
-a \l Transition, it defaults to the value defined in the start
+this value defaults to the value defined in the starting state of the
-state of the \l Transition.
+\l Transition, or the current value of the property at the moment the
+\l Behavior is triggered.
+\sa {QML Animation}
 */
 qreal QDeclarativeNumberAnimation::from() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 QDeclarativePropertyAnimation::setFrom(f);
 }
 /*!
 \qmlproperty real NumberAnimation::to
-This property holds the ending number value.
+This property holds the end value for the animation.
-If this value is not set and the NumberAnimation is defined within
+If the NumberAnimation is defined within a \l Transition or \l Behavior,
-a \l Transition or \l Behavior, it defaults to the value defined in the end
+this value defaults to the value defined in the end state of the
-state of the \l Transition or \l Behavior.
+\l Transition, or the value of the property change that triggered the
+\l Behavior.
+\sa {QML Animation}
 */
 qreal QDeclarativeNumberAnimation::to() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 return d->to.toReal();
 /*!
 \qmlclass Vector3dAnimation QDeclarativeVector3dAnimation
+\ingroup qml-animation-transition
 \since 4.7
 \inherits PropertyAnimation
 \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.
+Like any other animation element, a Vector3dAnimation can be applied in a
+number of ways, including transitions, behaviors and property value
+sources. The \l {QML Animation} documentation shows a variety of methods
+for creating animations.
 \sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
-/*!
-\internal
-\class QDeclarativeVector3dAnimation
-*/
 QDeclarativeVector3dAnimation::QDeclarativeVector3dAnimation(QObject *parent)
 : QDeclarativePropertyAnimation(parent)
 {
 Q_D(QDeclarativePropertyAnimation);
 d->interpolatorType = QMetaType::QVector3D;
 {
 }
 /*!
 \qmlproperty real Vector3dAnimation::from
-This property holds the starting value.
+This property holds the starting value for the animation.
-If this value is not set, it defaults to the value defined in the start
+If the Vector3dAnimation is defined within a \l Transition or \l Behavior,
-state of the \l Transition.
+this value defaults to the value defined in the starting state of the
+\l Transition, or the current value of the property at the moment the
+\l Behavior is triggered.
+\sa {QML Animation}
 */
 QVector3D QDeclarativeVector3dAnimation::from() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 return d->from.value<QVector3D>();
 QDeclarativePropertyAnimation::setFrom(f);
 }
 /*!
 \qmlproperty real Vector3dAnimation::to
-This property holds the ending value.
+This property holds the end value for the animation.
-If this value is not set, it defaults to the value defined in the end
+If the Vector3dAnimation is defined within a \l Transition or \l Behavior,
-state of the \l Transition or \l Behavior.
+this value defaults to the value defined in the end state of the
+\l Transition, or the value of the property change that triggered the
+\l Behavior.
+\sa {QML Animation}
 */
 QVector3D QDeclarativeVector3dAnimation::to() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 return d->to.value<QVector3D>();
 /*!
 \qmlclass RotationAnimation QDeclarativeRotationAnimation
+\ingroup qml-animation-transition
 \since 4.7
 \inherits PropertyAnimation
 \brief The RotationAnimation element animates changes in rotation values.
 RotationAnimation is a specialized PropertyAnimation that gives control
 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}
+Notice the RotationAnimation did not need to set a \l 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 \l {PropertyAnimation::properties}{properties} or
 \l {PropertyAnimation::property}{property}.
+Also, note the \l Rectangle will be rotated around its default
+\l {Item::}{transformOrigin} (which is \c Item.Center). To use a different
+transform origin, set the origin in the PropertyChanges object and apply
+the change at the start of the animation using PropertyAction. See the
+PropertyAction documentation for more details.
 Like any other animation element, a RotationAnimation can be applied in a
 number of ways, including transitions, behaviors and property value
-sources. The \l PropertyAnimation documentation shows a variety of methods
+sources. The \l {QML Animation} documentation shows a variety of methods
 for creating animations.
 \sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
-/*!
-\internal
-\class QDeclarativeRotationAnimation
-*/
 QVariant _q_interpolateShortestRotation(qreal &f, qreal &t, qreal progress)
 {
 qreal newt = t;
 qreal diff = t-f;
 while(diff > 180.0){
 {
 }
 /*!
 \qmlproperty real RotationAnimation::from
-This property holds the starting number value.
+This property holds the starting value for the animation.
 For example, the following animation is not applied until the \c angle value
 has reached 100:
 \qml
 RotationAnimation { properties: "angle"; from: 100; duration: 2000 }
 }
 }
 \endqml
-If this value is not set, it defaults to the value defined in the start
+If the RotationAnimation is defined within a \l Transition or \l Behavior,
-state of the \l Transition.
+this value defaults to the value defined in the starting state of the
+\l Transition, or the current value of the property at the moment the
+\l Behavior is triggered.
+\sa {QML Animation}
 */
 qreal QDeclarativeRotationAnimation::from() const
 {
 Q_D(const QDeclarativeRotationAnimation);
 return d->from.toReal();
 QDeclarativePropertyAnimation::setFrom(f);
 }
 /*!
 \qmlproperty real RotationAnimation::to
-This property holds the ending value.
+This property holds the end value for the animation..
-If this value is not set, it defaults to the value defined in the end
+If the RotationAnimation is defined within a \l Transition or \l Behavior,
-state of the \l Transition or \l Behavior.
+this value defaults to the value defined in the end state of the
+\l Transition, or the value of the property change that triggered the
+\l Behavior.
+\sa {QML Animation}
 */
 qreal QDeclarativeRotationAnimation::to() const
 {
 Q_D(const QDeclarativeRotationAnimation);
 return d->to.toReal();
 return list;
 }
 /*!
 \qmlclass SequentialAnimation QDeclarativeSequentialAnimation
+\ingroup qml-animation-transition
 \since 4.7
 \inherits Animation
 \brief The SequentialAnimation element allows animations to be run sequentially.
 The SequentialAnimation and ParallelAnimation elements allow multiple
 so SequentialAnimation can be used to enclose the animations in a \l Transition
 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
+sources. The \l {QML Animation} documentation shows a variety of methods
 for creating animations.
+\note Once an animation has been grouped into a SequentialAnimation or
+ParallelAnimation, it cannot be individually started and stopped; the
+SequentialAnimation or ParallelAnimation must be started and stopped as a group.
 \sa ParallelAnimation, {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 QDeclarativeSequentialAnimation::QDeclarativeSequentialAnimation(QObject *parent) :
 QDeclarativeAnimationGroup(parent)
 /*!
 \qmlclass ParallelAnimation QDeclarativeParallelAnimation
+\ingroup qml-animation-transition
 \since 4.7
 \inherits Animation
 \brief The ParallelAnimation element allows animations to be run in parallel.
 The SequentialAnimation and ParallelAnimation elements allow multiple
 \snippet doc/src/snippets/declarative/parallelanimation.qml 0
 Like any other animation element, a ParallelAnimation can be applied in a
 number of ways, including transitions, behaviors and property value
-sources. The \l PropertyAnimation documentation shows a variety of methods
+sources. The \l {QML Animation} documentation shows a variety of methods
 for creating animations.
+\note Once an animation has been grouped into a SequentialAnimation or
+ParallelAnimation, it cannot be individually started and stopped; the
+SequentialAnimation or ParallelAnimation must be started and stopped as a group.
 \sa SequentialAnimation, {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
-/*!
-\internal
-\class QDeclarativeParallelAnimation
-*/
 QDeclarativeParallelAnimation::QDeclarativeParallelAnimation(QObject *parent) :
 QDeclarativeAnimationGroup(parent)
 {
 Q_D(QDeclarativeAnimationGroup);
 d->ag = new QParallelAnimationGroup;
 }
 }
 /*!
 \qmlclass PropertyAnimation QDeclarativePropertyAnimation
+\ingroup qml-animation-transition
 \since 4.7
 \inherits Animation
 \brief The PropertyAnimation element animates changes in property values.
 PropertyAnimation provides a way to animate changes to a property's value.
 emit durationChanged(duration);
 }
 /*!
 \qmlproperty real PropertyAnimation::from
-This property holds the starting value.
+This property holds the starting value for the animation.
-If not set, then the value defined in the start state of the transition.
+If the PropertyAnimation is defined within a \l Transition or \l Behavior,
+this value defaults to the value defined in the starting state of the
+\l Transition, or the current value of the property at the moment the
+\l Behavior is triggered.
+\sa {QML Animation}
 */
 QVariant QDeclarativePropertyAnimation::from() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 return d->from;
 emit fromChanged(f);
 }
 /*!
 \qmlproperty real PropertyAnimation::to
-This property holds the ending value.
+This property holds the end value for the animation.
-If not set, then the value defined in the end state of the transition or \l Behavior.
+If the PropertyAnimation is defined within a \l Transition or \l Behavior,
+this value defaults to the value defined in the end state of the
+\l Transition, or the value of the property change that triggered the
+\l Behavior.
+\sa {QML Animation}
 */
 QVariant QDeclarativePropertyAnimation::to() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 return d->to;
 \o \c Easing.InQuart
 \o Easing curve for a quartic (t^4) function: accelerating from zero velocity.
 \o \inlineimage qeasingcurve-inquart.png
 \row
 \o \c Easing.OutQuart
-\o Easing curve for a cubic (t^4) function: decelerating from zero velocity.
+\o Easing curve for a quartic (t^4) function: decelerating from zero velocity.
 \o \inlineimage qeasingcurve-outquart.png
 \row
 \o \c Easing.InOutQuart
-\o Easing curve for a cubic (t^4) function: acceleration until halfway, then deceleration.
+\o Easing curve for a quartic (t^4) function: acceleration until halfway, then deceleration.
 \o \inlineimage qeasingcurve-inoutquart.png
 \row
 \o \c Easing.OutInQuart
-\o Easing curve for a cubic (t^4) function: deceleration until halfway, then acceleration.
+\o Easing curve for a quartic (t^4) function: deceleration until halfway, then acceleration.
 \o \inlineimage qeasingcurve-outinquart.png
 \row
 \o \c Easing.InQuint
 \o Easing curve for a quintic (t^5) function: accelerating from zero velocity.
 \o \inlineimage qeasingcurve-inquint.png
 \row
 \o \c Easing.OutQuint
-\o Easing curve for a cubic (t^5) function: decelerating from zero velocity.
+\o Easing curve for a quintic (t^5) function: decelerating from zero velocity.
 \o \inlineimage qeasingcurve-outquint.png
 \row
 \o \c Easing.InOutQuint
-\o Easing curve for a cubic (t^5) function: acceleration until halfway, then deceleration.
+\o Easing curve for a quintic (t^5) function: acceleration until halfway, then deceleration.
 \o \inlineimage qeasingcurve-inoutquint.png
 \row
 \o \c Easing.OutInQuint
-\o Easing curve for a cubic (t^5) function: deceleration until halfway, then acceleration.
+\o Easing curve for a quintic (t^5) function: deceleration until halfway, then acceleration.
 \o \inlineimage qeasingcurve-outinquint.png
 \row
 \o \c Easing.InSine
 \o Easing curve for a sinusoidal (sin(t)) function: accelerating from zero velocity.
 \o \inlineimage qeasingcurve-insine.png
 {
 Q_D(QDeclarativePropertyAnimation);
 if (d->target == o)
 return;
 d->target = o;
-emit targetChanged(d->target, d->propertyName);
+emit targetChanged();
 }
 QString QDeclarativePropertyAnimation::property() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 {
 Q_D(QDeclarativePropertyAnimation);
 if (d->propertyName == n)
 return;
 d->propertyName = n;
-emit targetChanged(d->target, d->propertyName);
+emit propertyChanged();
 }
 QString QDeclarativePropertyAnimation::properties() const
 {
 Q_D(const QDeclarativePropertyAnimation);
 d->va->setAnimValue(data, QAbstractAnimation::DeleteWhenStopped);
 d->va->setFromSourcedValue(&data->fromSourced);
 d->actions = &data->actions;
 } else {
 delete data;
+d->va->setFromSourcedValue(0);  //clear previous data
+d->va->setAnimValue(0, QAbstractAnimation::DeleteWhenStopped);  //clear previous data
 d->actions = 0;
 }
 }
 /*!
 \qmlclass ParentAnimation QDeclarativeParentAnimation
+\ingroup qml-animation-transition
 \since 4.7
 \inherits Animation
 \brief The ParentAnimation element animates changes in parent values.
-ParentAnimation defines an animation to applied when a ParentChange
+ParentAnimation is used to animate a parent change for an \l Item.
-occurs. This allows parent changes to be smoothly animated.
 For example, the following ParentChange changes \c blueRect to become
 a child of \c redRect when it is clicked. The inclusion of the
 ParentAnimation, which defines a NumberAnimation to be applied during
 the transition, ensures the item animates smoothly as it moves to
 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.
-By default, when used in a transition, ParentAnimation animates all parent
+For convenience, when a ParentAnimation is used in a \l Transition, it will
-changes. This can be overriden by setting a specific target item using the
+animate any ParentChange that has occurred during the state change.
+This can be overridden by setting a specific target item using the
 \l target property.
+Like any other animation element, a ParentAnimation can be applied in a
+number of ways, including transitions, behaviors and property value
+sources. The \l {QML Animation} documentation shows a variety of methods
+for creating animations.
 \sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
-*/
-/*!
-\internal
-\class QDeclarativeParentAnimation
 */
 QDeclarativeParentAnimation::QDeclarativeParentAnimation(QObject *parent)
 : QDeclarativeAnimationGroup(*(new QDeclarativeParentAnimationPrivate), parent)
 {
 Q_D(QDeclarativeParentAnimation);
 /*!
 \qmlproperty Item ParentAnimation::newParent
 The new parent to animate to.
-If not set, then the parent defined in the end state of the transition.
+If the ParentAnimation is defined within a \l Transition or \l Behavior,
+this value defaults to the value defined in the end state of the
+\l Transition, or the value of the property change that triggered the
+\l Behavior.
 */
 QDeclarativeItem *QDeclarativeParentAnimation::newParent() const
 {
 Q_D(const QDeclarativeParentAnimation);
 return d->newParent;
 return d->topLevelGroup;
 }
 /*!
 \qmlclass AnchorAnimation QDeclarativeAnchorAnimation
+\ingroup qml-animation-transition
 \since 4.7
 \inherits Animation
 \brief The AnchorAnimation element animates changes in anchor values.
-AnchorAnimation is used to animate an AnchorChange. It will anchor all
+AnchorAnimation is used to animate an anchor change.
-anchor changes specified in a \l State.
 In the following snippet we animate the addition of a right anchor to a \l Rectangle:
 \snippet doc/src/snippets/declarative/anchoranimation.qml 0
-\sa AnchorChanges
+For convenience, when an AnchorAnimation is used in a \l Transition, it will
+animate any AnchorChanges that have occurred during the state change.
+This can be overridden by setting a specific target item using the
+\l target property.
+Like any other animation element, an AnchorAnimation can be applied in a
+number of ways, including transitions, behaviors and property value
+sources. The \l {QML Animation} documentation shows a variety of methods
+for creating animations.
+\sa {QML Animation}, AnchorChanges
 */
 QDeclarativeAnchorAnimation::QDeclarativeAnchorAnimation(QObject *parent)
 : QDeclarativeAbstractAnimation(*(new QDeclarativeAnchorAnimationPrivate), parent)
 {

changeset 37	758a864f9613
parent 33	3e2da88830cd