Improved transitions for Row, Column, Grid, Flow

The view transitions functionality for ListView and GridView has been
integrated into the positioner elements. Not all of this
functionality is available for positioners, though, since they don't
have models (and thus cannot identify certain model operations) and
they don't manage the lifetime of their children.

Task-number: QTBUG-24336

Change-Id: I71588de289555d2ef5a763af11358bc0af7b31a7
Reviewed-by: Alan Alpert <alan.alpert@nokia.com>

4 files changed, 250 insertions, 181 deletions

diff --git a/src/quick/items/qquickitemviewtransition.cpp b/src/quick/items/qquickitemviewtransition.cpp
index 9235321418..abff768ad3 100644
--- a/src/quick/items/qquickitemviewtransition.cpp
+++ b/src/quick/items/qquickitemviewtransition.cpp
@@ -377,6 +377,12 @@ bool QQuickViewItem::prepareTransition(const QRectF &viewBounds)
 {
     bool doTransition = false;
 
+    // If item is not already moving somewhere, set it to not move anywhere.
+    // This ensures that removed targets don't transition to the default (0,0) and that
+    // items set for other transition types only transition if they actually move somewhere.
+    if (nextTransitionType != QQuickItemViewTransitioner::NoTransition && !nextTransitionToSet)
+        moveTo(item->pos());
+
     switch (nextTransitionType) {
     case QQuickItemViewTransitioner::NoTransition:
     {
@@ -390,7 +396,12 @@ bool QQuickViewItem::prepareTransition(const QRectF &viewBounds)
     case QQuickItemViewTransitioner::RemoveTransition:
         // For Add targets, do transition if item is moving into visible area
         // For Remove targets, do transition if item is currently in visible area
-        if (isTransitionTarget) {
+        if (viewBounds.isNull()) {
+            if (isTransitionTarget)
+                doTransition = true;
+            else
+                doTransition = (nextTransitionTo != item->pos());
+        } else if (isTransitionTarget) {
             doTransition = (nextTransitionType == QQuickItemViewTransitioner::AddTransition)
                     ? viewBounds.intersects(QRectF(nextTransitionTo.x(), nextTransitionTo.y(), item->width(), item->height()))
                     : viewBounds.intersects(QRectF(item->x(), item->y(), item->width(), item->height()));
@@ -408,7 +419,8 @@ bool QQuickViewItem::prepareTransition(const QRectF &viewBounds)
     case QQuickItemViewTransitioner::MoveTransition:
         // do transition if moving from or into visible area
         if (nextTransitionTo != item->pos()) {
-            doTransition = viewBounds.intersects(QRectF(item->x(), item->y(), item->width(), item->height()))
+            doTransition = viewBounds.isNull()
+                    || viewBounds.intersects(QRectF(item->x(), item->y(), item->width(), item->height()))
                     || viewBounds.intersects(QRectF(nextTransitionTo.x(), nextTransitionTo.y(), item->width(), item->height()));
             if (!doTransition)
                 item->setPos(nextTransitionTo);
@@ -503,7 +515,19 @@ QQuickViewTransitionAttached::QQuickViewTransitionAttached(QObject *parent)
        generic displaced transition if specified)
     \endlist
 
-    Such view transitions additionally have access to a ViewTransition attached property that
+    For the \l Row, \l Column, \l Grid and \l Flow positioner elements, which operate with collections of child
+    items rather than data models, the following properties are used instead:
+
+    \list
+    \o \c add - the transition to apply to items that are created for the positioner, added to
+       or reparented to the positioner, or items that have become \l {Item::}{visible}
+    \o \c move - the transition to apply to items that have moved within the positioner, including
+       when they are displaced due to the addition or removal of other items, or when items are otherwise
+       rearranged within the positioner, or when items are repositioned due to the resizing of other
+       items in the positioner
+    \endlist
+
+    View transitions have access to a ViewTransition attached property that
     provides details of the items that are under transition and the operation that triggered the
     transition. Since view transitions are run once per item, these details can be used to customise
     each transition for each individual item.
@@ -525,6 +549,10 @@ QQuickViewTransitionAttached::QQuickViewTransitionAttached(QObject *parent)
     \o ViewTransition.targetItems - the target items themselves
     \endlist
 
+    (Note that for the \l Row, \l Column, \l Grid and \l Flow positioner elements, the \c move transition only
+    provides these two additional details when the transition is triggered by the addition of items
+    to a positioner.)
+
     View transitions can be written without referring to any of the attributes listed
     above. These attributes merely provide extra details that are useful for customising view
     transitions.
diff --git a/src/quick/items/qquickpositioners.cpp b/src/quick/items/qquickpositioners.cpp
index 95ee9bfb58..6ed35a9f42 100644
--- a/src/quick/items/qquickpositioners.cpp
+++ b/src/quick/items/qquickpositioners.cpp
@@ -109,6 +109,7 @@ QQuickBasePositioner::QQuickBasePositioner(QQuickBasePositionerPrivate &dd, Posi
 QQuickBasePositioner::~QQuickBasePositioner()
 {
     Q_D(QQuickBasePositioner);
+    delete d->transitioner;
     for (int i = 0; i < positionedItems.count(); ++i)
         d->unwatchChanges(positionedItems.at(i).item);
     for (int i = 0; i < unpositionedItems.count(); ++i)
@@ -142,31 +143,36 @@ void QQuickBasePositioner::setSpacing(qreal s)
 QDeclarativeTransition *QQuickBasePositioner::move() const
 {
     Q_D(const QQuickBasePositioner);
-    return d->moveTransition;
+    return d->transitioner ? d->transitioner->displacedTransition : 0;
 }
 
 void QQuickBasePositioner::setMove(QDeclarativeTransition *mt)
 {
     Q_D(QQuickBasePositioner);
-    if (mt == d->moveTransition)
+    if (!d->transitioner)
+        d->transitioner = new QQuickItemViewTransitioner;
+    if (mt == d->transitioner->displacedTransition)
         return;
-    d->moveTransition = mt;
+
+    d->transitioner->displacedTransition = mt;
     emit moveChanged();
 }
 
 QDeclarativeTransition *QQuickBasePositioner::add() const
 {
     Q_D(const QQuickBasePositioner);
-    return d->addTransition;
+    return d->transitioner ? d->transitioner->addTransition : 0;
 }
 
 void QQuickBasePositioner::setAdd(QDeclarativeTransition *add)
 {
     Q_D(QQuickBasePositioner);
-    if (add == d->addTransition)
+    if (!d->transitioner)
+        d->transitioner = new QQuickItemViewTransitioner;
+    if (add == d->transitioner->addTransition)
         return;
 
-    d->addTransition = add;
+    d->transitioner->addTransition = add;
     emit addChanged();
 }
 
@@ -218,6 +224,7 @@ void QQuickBasePositioner::prePositioning()
     for (int ii = 0; ii < unpositionedItems.count(); ii++)
         oldItems.append(unpositionedItems[ii]);
     unpositionedItems.clear();
+    int addedIndex = -1;
 
     for (int ii = 0; ii < children.count(); ++ii) {
         QQuickItem *child = children.at(ii);
@@ -229,9 +236,22 @@ void QQuickBasePositioner::prePositioning()
             posItem.isNew = true;
             if (!childPrivate->explicitVisible || !child->width() || !child->height()) {
                 posItem.isVisible = false;
+                posItem.index = -1;
                 unpositionedItems.append(posItem);
             } else {
+                posItem.index = positionedItems.count();
                 positionedItems.append(posItem);
+
+                if (d->transitioner) {
+                    if (addedIndex < 0)
+                        addedIndex = posItem.index;
+                    PositionedItem *theItem = &positionedItems[positionedItems.count()-1];
+
+                    d->transitioner->transitionNextReposition(theItem,
+                            QQuickItemViewTransitioner::AddTransition, true);
+                    d->transitioner->addTransitionIndexes << posItem.index;
+                    d->transitioner->addTransitionTargets << posItem.item;
+                }
             }
         } else {
             PositionedItem *item = &oldItems[wIdx];
@@ -239,75 +259,93 @@ void QQuickBasePositioner::prePositioning()
             // i.e. their positioning is not affected if an ancestor is hidden.
             if (!childPrivate->explicitVisible || !child->width() || !child->height()) {
                 item->isVisible = false;
+                item->index = -1;
                 unpositionedItems.append(*item);
             } else if (!item->isVisible) {
+                // item changed from non-visible to visible, treat it as a "new" item
                 item->isVisible = true;
                 item->isNew = true;
+                item->index = positionedItems.count();
                 positionedItems.append(*item);
+
+                if (d->transitioner) {
+                    if (addedIndex < 0)
+                        addedIndex = item->index;
+                    d->transitioner->transitionNextReposition(&positionedItems[positionedItems.count()-1],
+                            QQuickItemViewTransitioner::AddTransition, true);
+                    d->transitioner->addTransitionIndexes << item->index;
+                    d->transitioner->addTransitionTargets << item->item;
+                }
             } else {
                 item->isNew = false;
+                item->index = positionedItems.count();
                 positionedItems.append(*item);
             }
         }
     }
+
+    if (d->transitioner) {
+        for (int i=0; i<positionedItems.count(); i++) {
+            if (!positionedItems[i].isNew) {
+                if (addedIndex >= 0) {
+                    d->transitioner->transitionNextReposition(&positionedItems[i], QQuickItemViewTransitioner::AddTransition, false);
+                } else {
+                    // just queue the item for a move-type displace - if the item hasn't
+                    // moved anywhere, it won't be transitioned anyway
+                    d->transitioner->transitionNextReposition(&positionedItems[i], QQuickItemViewTransitioner::MoveTransition, false);
+                }
+            }
+        }
+    }
+
     QSizeF contentSize(0,0);
     reportConflictingAnchors();
     if (!d->anchorConflict) {
         doPositioning(&contentSize);
         updateAttachedProperties();
     }
-    if (!d->addActions.isEmpty() || !d->moveActions.isEmpty())
-        finishApplyTransitions();
+
+    if (d->transitioner) {
+        QRectF viewBounds;
+        for (int i=0; i<positionedItems.count(); i++) {
+            if (positionedItems[i].prepareTransition(viewBounds))
+                positionedItems[i].startTransition(d->transitioner);
+        }
+        d->transitioner->addTransitionIndexes.clear();
+        d->transitioner->addTransitionTargets.clear();
+    }
+
     d->doingPositioning = false;
+
     //Set implicit size to the size of its children
     setImplicitSize(contentSize.width(), contentSize.height());
 }
 
-void QQuickBasePositioner::positionX(qreal x, const PositionedItem &target)
+void QQuickBasePositioner::positionItem(qreal x, qreal y, PositionedItem *target)
 {
     Q_D(QQuickBasePositioner);
-    if (d->type == Horizontal || d->type == Both) {
-        if (target.isNew) {
-            if (!d->addTransition || !d->addTransition->enabled())
-                target.item->setX(x);
-            else
-                d->addActions << QDeclarativeAction(target.item, QLatin1String("x"), QVariant(x));
-        } else if (x != target.item->x()) {
-            if (!d->moveTransition || !d->moveTransition->enabled())
-                target.item->setX(x);
-            else
-                d->moveActions << QDeclarativeAction(target.item, QLatin1String("x"), QVariant(x));
-        }
+    if ( (target->itemX() != x || target->itemY() != y)
+            && d->type == Both) {
+        target->moveTo(QPointF(x, y));
     }
 }
 
-void QQuickBasePositioner::positionY(qreal y, const PositionedItem &target)
+void QQuickBasePositioner::positionItemX(qreal x, PositionedItem *target)
 {
     Q_D(QQuickBasePositioner);
-    if (d->type == Vertical || d->type == Both) {
-        if (target.isNew) {
-            if (!d->addTransition || !d->addTransition->enabled())
-                target.item->setY(y);
-            else
-                d->addActions << QDeclarativeAction(target.item, QLatin1String("y"), QVariant(y));
-        } else if (y != target.item->y()) {
-            if (!d->moveTransition || !d->moveTransition->enabled())
-                target.item->setY(y);
-            else
-                d->moveActions << QDeclarativeAction(target.item, QLatin1String("y"), QVariant(y));
-        }
+    if (target->itemX() != x
+            && (d->type == Horizontal || d->type == Both)) {
+        target->moveTo(QPointF(x, target->itemY()));
     }
 }
 
-void QQuickBasePositioner::finishApplyTransitions()
+void QQuickBasePositioner::positionItemY(qreal y, PositionedItem *target)
 {
     Q_D(QQuickBasePositioner);
-    // Note that if a transition is not set the transition manager will
-    // apply the changes directly, in the case add/move aren't set
-    d->addTransitionManager.transition(d->addActions, d->addTransition);
-    d->moveTransitionManager.transition(d->moveActions, d->moveTransition);
-    d->addActions.clear();
-    d->moveActions.clear();
+    if (target->itemY() != y
+            && (d->type == Vertical || d->type == Both)) {
+        target->moveTo(QPointF(target->itemX(), y));
+    }
 }
 
 QQuickPositionerAttached *QQuickBasePositioner::qmlAttachedProperties(QObject *obj)
@@ -501,30 +539,42 @@ void QQuickPositionerAttached::setIsLastItem(bool isLastItem)
 /*!
     \qmlproperty Transition QtQuick2::Column::add
 
-    This property holds the transition to be applied when adding an
-    item to the positioner. The transition will only be applied to the
-    added item(s).  Positioner transitions will only affect the
-    position (x, y) of items.
+    This property holds the transition to be run for items that are added to this
+    positioner. For a positioner, this applies to:
+
+    \list
+    \o Items that are created or reparented as a child of the positioner
+    \o Child items that change their \l visible property from false to true, and thus
+       are now visible
+    \endlist
 
-    For a positioner, adding an item can mean that either the object
-    has been created or reparented, and thus is now a child or the
-    positioner, or that the object has changed its \l visible property
-    from false to true, and thus is now visible.
+    The transition can use the \l ViewTransition property to access more details about
+    the item that is being added. See the \l ViewTransition documentation for more details
+    and examples on using these transitions.
 
-    \sa move
+    \sa move, ViewTransition, {declarative/positioners}{Positioners example}
 */
 /*!
     \qmlproperty Transition QtQuick2::Column::move
 
-    This property holds the transition to apply to any item that has moved
-    within the positioner. Positioner transitions will only affect
-    the position (x, y) of items.
+    This property holds the transition to run for items that have moved within the
+    positioner. For a positioner, this applies to:
 
-    This transition is applied to items that are displaced as a result of the
-    addition or removal of other items in the positioner, or when items move due to
-    a move operation in a related model, or when items resize themselves.
+    \list
+    \o Child items that move when they are displaced due to the addition, removal or
+       rearrangement of other items in the positioner
+    \o Child items that are repositioned due to the resizing of other items in the positioner
+    \endlist
+
+    The transition can use the \l ViewTransition property to access more details about
+    the item that is being moved. Note, however, that for this move transition, the
+    ViewTransition.targetIndexes and ViewTransition.targetItems lists are only set when
+    this transition is triggered by the addition of other items in the positioner; in other
+    cases, these lists will be empty.
+
+    See the \l ViewTransition documentation for more details and examples on using these transitions.
 
-    \sa add, {declarative/positioners}{Positioners example}
+    \sa add, ViewTransition, {declarative/positioners}{Positioners example}
 */
 /*!
   \qmlproperty real QtQuick2::Column::spacing
@@ -545,11 +595,8 @@ void QQuickColumn::doPositioning(QSizeF *contentSize)
     qreal voffset = 0;
 
     for (int ii = 0; ii < positionedItems.count(); ++ii) {
-        const PositionedItem &child = positionedItems.at(ii);
-
-        if (child.item->y() != voffset)
-            positionY(voffset, child);
-
+        PositionedItem &child = positionedItems[ii];
+        positionItemY(voffset, &child);
         contentSize->setWidth(qMax(contentSize->width(), child.item->width()));
 
         voffset += child.item->height();
@@ -625,42 +672,42 @@ void QQuickColumn::reportConflictingAnchors()
 /*!
     \qmlproperty Transition QtQuick2::Row::add
 
-    This property holds the transition to be applied when adding an
-    item to the positioner. The transition will only be applied to the
-    added item(s).  Positioner transitions will only affect the
-    position (x, y) of items.
+    This property holds the transition to be run for items that are added to this
+    positioner. For a positioner, this applies to:
 
-    For a positioner, adding an item can mean that either the object
-    has been created or reparented, and thus is now a child or the
-    positioner, or that the object has changed its \l visible property
-    from false to true, and thus is now visible.
+    \list
+    \o Items that are created or reparented as a child of the positioner
+    \o Child items that change their \l visible property from false to true, and thus
+       are now visible
+    \endlist
+
+    The transition can use the \l ViewTransition property to access more details about
+    the item that is being added. See the \l ViewTransition documentation for more details
+    and examples on using these transitions.
 
-    \sa move
+    \sa move, ViewTransition, {declarative/positioners}{Positioners example}
 */
 /*!
     \qmlproperty Transition QtQuick2::Row::move
 
-    This property holds the transition to apply to any item that has moved
-    within the positioner. Positioner transitions will only affect
-    the position (x, y) of items.
-
-    This transition is applied to items that are displaced as a result of the
-    addition or removal of other items in the positioner, or when items move due to
-    a move operation in a related model, or when items resize themselves.
-
-    \qml
-    Row {
-        id: positioner
-        move: Transition {
-            NumberAnimation {
-                properties: "x"
-                duration: 1000
-            }
-        }
-    }
-    \endqml
+    This property holds the transition to run for items that have moved within the
+    positioner. For a positioner, this applies to:
+
+    \list
+    \o Child items that move when they are displaced due to the addition, removal or
+       rearrangement of other items in the positioner
+    \o Child items that are repositioned due to the resizing of other items in the positioner
+    \endlist
+
+    The transition can use the \l ViewTransition property to access more details about
+    the item that is being moved. Note, however, that for this move transition, the
+    ViewTransition.targetIndexes and ViewTransition.targetItems lists are only set when
+    this transition is triggered by the addition of other items in the positioner; in other
+    cases, these lists will be empty.
 
-    \sa add, {declarative/positioners}{Positioners example}
+    See the \l ViewTransition documentation for more details and examples on using these transitions.
+
+    \sa add, ViewTransition, {declarative/positioners}{Positioners example}
 */
 /*!
   \qmlproperty real QtQuick2::Row::spacing
@@ -736,11 +783,10 @@ void QQuickRow::doPositioning(QSizeF *contentSize)
 
     QList<qreal> hoffsets;
     for (int ii = 0; ii < positionedItems.count(); ++ii) {
-        const PositionedItem &child = positionedItems.at(ii);
+        PositionedItem &child = positionedItems[ii];
 
         if (d->isLeftToRight()) {
-            if (child.item->x() != hoffset)
-                positionX(hoffset, child);
+            positionItemX(hoffset, &child);
         } else {
             hoffsets << hoffset;
         }
@@ -767,10 +813,9 @@ void QQuickRow::doPositioning(QSizeF *contentSize)
 
     int acc = 0;
     for (int ii = 0; ii < positionedItems.count(); ++ii) {
-        const PositionedItem &child = positionedItems.at(ii);
+        PositionedItem &child = positionedItems[ii];
         hoffset = end - hoffsets[acc++] - child.item->width();
-        if (child.item->x() != hoffset)
-            positionX(hoffset, child);
+        positionItemX(hoffset, &child);
     }
 }
 
@@ -839,41 +884,42 @@ void QQuickRow::reportConflictingAnchors()
 /*!
     \qmlproperty Transition QtQuick2::Grid::add
 
-    This property holds the transition to be applied when adding an
-    item to the positioner. The transition will only be applied to the
-    added item(s).  Positioner transitions will only affect the
-    position (x, y) of items.
+    This property holds the transition to be run for items that are added to this
+    positioner. For a positioner, this applies to:
+
+    \list
+    \o Items that are created or reparented as a child of the positioner
+    \o Child items that change their \l visible property from false to true, and thus
+       are now visible
+    \endlist
 
-    For a positioner, adding an item can mean that either the object
-    has been created or reparented, and thus is now a child or the
-    positioner, or that the object has changed its \l visible property
-    from false to true, and thus is now visible.
+    The transition can use the \l ViewTransition property to access more details about
+    the item that is being added. See the \l ViewTransition documentation for more details
+    and examples on using these transitions.
 
-    \sa move
+    \sa move, ViewTransition, {declarative/positioners}{Positioners example}
 */
 /*!
     \qmlproperty Transition QtQuick2::Grid::move
 
-    This property holds the transition to apply to any item that has moved
-    within the positioner. Positioner transitions will only affect
-    the position (x, y) of items.
+    This property holds the transition to run for items that have moved within the
+    positioner. For a positioner, this applies to:
+
+    \list
+    \o Child items that move when they are displaced due to the addition, removal or
+       rearrangement of other items in the positioner
+    \o Child items that are repositioned due to the resizing of other items in the positioner
+    \endlist
 
-    This transition is applied to items that are displaced as a result of the
-    addition or removal of other items in the positioner, or when items move due to
-    a move operation in a related model, or when items resize themselves.
+    The transition can use the \l ViewTransition property to access more details about
+    the item that is being moved. Note, however, that for this move transition, the
+    ViewTransition.targetIndexes and ViewTransition.targetItems lists are only set when
+    this transition is triggered by the addition of other items in the positioner; in other
+    cases, these lists will be empty.
 
-    \qml
-    Grid {
-        move: Transition {
-            NumberAnimation {
-                properties: "x,y"
-                duration: 1000
-            }
-        }
-    }
-    \endqml
+    See the \l ViewTransition documentation for more details and examples on using these transitions.
 
-    \sa add, {declarative/positioners}{Positioners example}
+    \sa add, ViewTransition, {declarative/positioners}{Positioners example}
 */
 /*!
   \qmlproperty qreal QtQuick2::Grid::spacing
@@ -1160,14 +1206,11 @@ void QQuickGrid::doPositioning(QSizeF *contentSize)
     int curRow =0;
     int curCol =0;
     for (int i = 0; i < positionedItems.count(); ++i) {
-        const PositionedItem &child = positionedItems.at(i);
+        PositionedItem &child = positionedItems[i];
         qreal childXOffset = xoffset;
         if (!d->isLeftToRight())
             childXOffset -= child.item->width();
-        if ((child.item->x() != childXOffset) || (child.item->y() != yoffset)) {
-            positionX(childXOffset, child);
-            positionY(yoffset, child);
-        }
+        positionItem(childXOffset, yoffset, &child);
 
         if (m_flow == LeftToRight) {
             if (d->isLeftToRight())
@@ -1254,42 +1297,42 @@ void QQuickGrid::reportConflictingAnchors()
 /*!
     \qmlproperty Transition QtQuick2::Flow::add
 
-    This property holds the transition to be applied when adding an
-    item to the positioner. The transition will only be applied to the
-    added item(s).  Positioner transitions will only affect the
-    position (x, y) of items.
+    This property holds the transition to be run for items that are added to this
+    positioner. For a positioner, this applies to:
+
+    \list
+    \o Items that are created or reparented as a child of the positioner
+    \o Child items that change their \l visible property from false to true, and thus
+       are now visible
+    \endlist
 
-    For a positioner, adding an item can mean that either the object
-    has been created or reparented, and thus is now a child or the
-    positioner, or that the object has changed its \l visible property
-    from false to true, and thus is now visible.
+    The transition can use the \l ViewTransition property to access more details about
+    the item that is being added. See the \l ViewTransition documentation for more details
+    and examples on using these transitions.
 
-    \sa move
+    \sa move, ViewTransition, {declarative/positioners}{Positioners example}
 */
 /*!
     \qmlproperty Transition QtQuick2::Flow::move
 
-    This property holds the transition to apply to any item that has moved
-    within the positioner. Positioner transitions will only affect
-    the position (x, y) of items.
-
-    This transition is applied to items that are displaced as a result of the
-    addition or removal of other items in the positioner, or when items move due to
-    a move operation in a related model, or when items resize themselves.
-
-    \qml
-    Flow {
-        id: positioner
-        move: Transition {
-            NumberAnimation {
-                properties: "x,y"
-                ease: "easeOutBounce"
-            }
-        }
-    }
-    \endqml
+    This property holds the transition to run for items that have moved within the
+    positioner. For a positioner, this applies to:
+
+    \list
+    \o Child items that move when they are displaced due to the addition, removal or
+       rearrangement of other items in the positioner
+    \o Child items that are repositioned due to the resizing of other items in the positioner
+    \endlist
+
+    The transition can use the \l ViewTransition property to access more details about
+    the item that is being moved. Note, however, that for this move transition, the
+    ViewTransition.targetIndexes and ViewTransition.targetItems lists are only set when
+    this transition is triggered by the addition of other items in the positioner; in other
+    cases, these lists will be empty.
+
+    See the \l ViewTransition documentation for more details and examples on using these transitions.
 
-    \sa add, {declarative/positioners}{Positioners example}
+    \sa add, ViewTransition, {declarative/positioners}{Positioners example}
 */
 /*!
   \qmlproperty real QtQuick2::Flow::spacing
@@ -1414,7 +1457,7 @@ void QQuickFlow::doPositioning(QSizeF *contentSize)
     QList<qreal> hoffsets;
 
     for (int i = 0; i < positionedItems.count(); ++i) {
-        const PositionedItem &child = positionedItems.at(i);
+        PositionedItem &child = positionedItems[i];
 
         if (d->flow == LeftToRight)  {
             if (widthValid() && hoffset && hoffset + child.item->width() > width()) {
@@ -1431,13 +1474,11 @@ void QQuickFlow::doPositioning(QSizeF *contentSize)
         }
 
         if (d->isLeftToRight()) {
-            if (child.item->x() != hoffset)
-                positionX(hoffset, child);
+            positionItem(hoffset, voffset, &child);
         } else {
             hoffsets << hoffset;
+            positionItemY(voffset, &child);
         }
-        if (child.item->y() != voffset)
-            positionY(voffset, child);
 
         contentSize->setWidth(qMax(contentSize->width(), hoffset + child.item->width()));
         contentSize->setHeight(qMax(contentSize->height(), voffset + child.item->height()));
@@ -1462,10 +1503,9 @@ void QQuickFlow::doPositioning(QSizeF *contentSize)
         end = contentSize->width();
     int acc = 0;
     for (int i = 0; i < positionedItems.count(); ++i) {
-        const PositionedItem &child = positionedItems.at(i);
+        PositionedItem &child = positionedItems[i];
         hoffset = end - hoffsets[acc++] - child.item->width();
-        if (child.item->x() != hoffset)
-            positionX(hoffset, child);
+        positionItemX(hoffset, &child);
     }
 }
 
diff --git a/src/quick/items/qquickpositioners_p.h b/src/quick/items/qquickpositioners_p.h
index a4f18cfc21..32dd9030fe 100644
--- a/src/quick/items/qquickpositioners_p.h
+++ b/src/quick/items/qquickpositioners_p.h
@@ -43,6 +43,7 @@
 #define QQUICKPOSITIONERS_P_H
 
 #include "qquickimplicitsizeitem_p.h"
+#include "qquickitemviewtransition_p.h"
 
 #include <QtQuick/private/qdeclarativestate_p.h>
 #include <private/qpodvector_p.h>
@@ -96,6 +97,7 @@ class Q_QUICK_PRIVATE_EXPORT QQuickBasePositioner : public QQuickImplicitSizeIte
     Q_PROPERTY(QDeclarativeTransition *add READ add WRITE setAdd NOTIFY addChanged)
 public:
     enum PositionerType { None = 0x0, Horizontal = 0x1, Vertical = 0x2, Both = 0x3 };
+
     QQuickBasePositioner(PositionerType, QQuickItem *parent);
     ~QQuickBasePositioner();
 
@@ -116,7 +118,6 @@ protected:
     QQuickBasePositioner(QQuickBasePositionerPrivate &dd, PositionerType at, QQuickItem *parent);
     virtual void componentComplete();
     virtual void itemChange(ItemChange, const ItemChangeData &);
-    void finishApplyTransitions();
 
     virtual void updatePolish();
 
@@ -131,19 +132,22 @@ protected Q_SLOTS:
 protected:
     virtual void doPositioning(QSizeF *contentSize)=0;
     virtual void reportConflictingAnchors()=0;
-    class PositionedItem {
+
+    class PositionedItem : public QQuickViewItem
+    {
     public :
-        PositionedItem(QQuickItem *i) : item(i), isNew(false), isVisible(true) {}
+        PositionedItem(QQuickItem *i) : QQuickViewItem(i), isNew(false), isVisible(true) {}
         bool operator==(const PositionedItem &other) const { return other.item == item; }
-        QQuickItem *item;
+
         bool isNew;
         bool isVisible;
     };
 
     QPODVector<PositionedItem,8> positionedItems;
     QPODVector<PositionedItem,8> unpositionedItems;//Still 'in' the positioner, just not positioned
-    void positionX(qreal,const PositionedItem &target);
-    void positionY(qreal,const PositionedItem &target);
+    void positionItem(qreal x, qreal y, PositionedItem *target);
+    void positionItemX(qreal, PositionedItem *target);
+    void positionItemY(qreal, PositionedItem *target);
 
 private:
     Q_DISABLE_COPY(QQuickBasePositioner)
diff --git a/src/quick/items/qquickpositioners_p_p.h b/src/quick/items/qquickpositioners_p_p.h
index d281f1a372..f1d174dc0a 100644
--- a/src/quick/items/qquickpositioners_p_p.h
+++ b/src/quick/items/qquickpositioners_p_p.h
@@ -66,6 +66,8 @@
 
 QT_BEGIN_NAMESPACE
 
+class QQuickItemViewTransitioner;
+
 class QQuickBasePositionerPrivate : public QQuickImplicitSizeItemPrivate, public QQuickItemChangeListener
 {
     Q_DECLARE_PUBLIC(QQuickBasePositioner)
@@ -73,7 +75,7 @@ class QQuickBasePositionerPrivate : public QQuickImplicitSizeItemPrivate, public
 public:
     QQuickBasePositionerPrivate()
         : spacing(0), type(QQuickBasePositioner::None)
-        , moveTransition(0), addTransition(0), positioningDirty(false)
+        , transitioner(0), positioningDirty(false)
         , doingPositioning(false), anchorConflict(false), layoutDirection(Qt::LeftToRight)
     {
     }
@@ -87,12 +89,7 @@ public:
     qreal spacing;
 
     QQuickBasePositioner::PositionerType type;
-    QDeclarativeTransition *moveTransition;
-    QDeclarativeTransition *addTransition;
-    QDeclarativeStateOperation::ActionList addActions;
-    QDeclarativeStateOperation::ActionList moveActions;
-    QDeclarativeTransitionManager addTransitionManager;
-    QDeclarativeTransitionManager moveTransitionManager;
+    QQuickItemViewTransitioner *transitioner;
 
     void watchChanges(QQuickItem *other);
     void unwatchChanges(QQuickItem* other);