Merge branch 'master' of git://gitorious.org/qt/qtdeclarative into api_changes

Change-Id: I578b1e2f1bb374da6194e6ba04a0fd459b2632fe

17 files changed, 478 insertions, 112 deletions

diff --git a/src/quick/items/qquickcanvas.cpp b/src/quick/items/qquickcanvas.cpp
index 170a37c979..60f1992b57 100644
--- a/src/quick/items/qquickcanvas.cpp
+++ b/src/quick/items/qquickcanvas.cpp
@@ -374,6 +374,14 @@ static QQuickMouseEventEx touchToMouseEvent(QEvent::Type type, const QTouchEvent
 
 void QQuickCanvasPrivate::translateTouchToMouse(QTouchEvent *event)
 {
+    if (event->type() == QEvent::TouchCancel) {
+        touchMouseId = -1;
+        if (!mouseGrabberItem)
+            return;
+        mouseGrabberItem->ungrabMouse();
+        mouseGrabberItem = 0;
+        return;
+    }
     for (int i = 0; i < event->touchPoints().count(); ++i) {
         QTouchEvent::TouchPoint p = event->touchPoints().at(i);
         if (touchMouseId == -1 && p.state() & Qt::TouchPointPressed) {
@@ -1177,7 +1185,8 @@ bool QQuickCanvasPrivate::deliverWheelEvent(QQuickItem *item, QWheelEvent *event
 
     QPointF p = item->mapFromScene(event->posF());
     if (QRectF(0, 0, item->width(), item->height()).contains(p)) {
-        QWheelEvent wheel(p, event->delta(), event->buttons(), event->modifiers(), event->orientation());
+        QWheelEvent wheel(p, p, event->pixelDelta(), event->angleDelta(), event->delta(),
+                          event->orientation(), event->buttons(), event->modifiers());
         wheel.accept();
         q->sendEvent(item, &wheel);
         if (wheel.isAccepted()) {
diff --git a/src/quick/items/qquickevents.cpp b/src/quick/items/qquickevents.cpp
index 597e64eb18..9222a7766d 100644
--- a/src/quick/items/qquickevents.cpp
+++ b/src/quick/items/qquickevents.cpp
@@ -236,4 +236,108 @@ Item {
 */
 
 
+/*!
+    \qmlclass WheelEvent QQuickWheelEvent
+    \inqmlmodule QtQuick 2
+    \ingroup qml-event-elements
+
+    \brief The WheelEvent object provides information about a mouse wheel event.
+
+    The position of the mouse can be found via the \l x and \l y properties.
+
+    \sa MouseArea
+*/
+
+/*!
+    \internal
+    \class QQuickWheelEvent
+*/
+
+/*!
+    \qmlproperty int QtQuick2::WheelEvent::x
+    \qmlproperty int QtQuick2::WheelEvent::y
+
+    These properties hold the coordinates of the position supplied by the wheel event.
+*/
+
+/*!
+    \qmlproperty bool QtQuick2::WheelEvent::accepted
+
+    Setting \a accepted to true prevents the wheel event from being
+    propagated to items below this item.
+
+    Generally, if the item acts on the wheel event then it should be accepted
+    so that items lower in the stacking order do not also respond to the same event.
+*/
+
+/*!
+    \qmlproperty int QtQuick2::WheelEvent::buttons
+
+    This property holds the mouse buttons pressed when the wheel event was generated.
+
+    It contains a bitwise combination of:
+    \list
+    \o Qt.LeftButton
+    \o Qt.RightButton
+    \o Qt.MiddleButton
+    \endlist
+*/
+
+/*!
+    \qmlproperty point QtQuick2::WheelEvent::angleDelta
+
+    This property holds the distance that the wheel is rotated in wheel degrees.
+    The x and y cordinate of this property holds the delta in horizontal and
+    vertical orientation.
+
+    A positive value indicates that the wheel was rotated up/right;
+    a negative value indicates that the wheel was rotated down/left.
+
+    Most mouse types work in steps of 15 degrees, in which case the delta value is a
+    multiple of 120; i.e., 120 units * 1/8 = 15 degrees.
+*/
+
+/*!
+    \qmlproperty point QtQuick2::WheelEvent::pixelDelta
+
+    This property holds the delta in screen pixels and is available in plataforms that
+    have high-resolution trackpads, such as Mac OS X.
+    The x and y cordinate of this property holds the delta in horizontal and
+    vertical orientation. The value should be used directly to scroll content on screen.
+
+    For platforms without high-resolution trackpad support, pixelDelta will always be (0,0),
+    and angleDelta should be used instead.
+*/
+
+/*!
+    \qmlproperty int QtQuick2::WheelEvent::modifiers
+
+    This property holds the keyboard modifier flags that existed immediately
+    before the event occurred.
+
+    It contains a bitwise combination of:
+    \list
+    \o Qt.NoModifier - No modifier key is pressed.
+    \o Qt.ShiftModifier - A Shift key on the keyboard is pressed.
+    \o Qt.ControlModifier - A Ctrl key on the keyboard is pressed.
+    \o Qt.AltModifier - An Alt key on the keyboard is pressed.
+    \o Qt.MetaModifier - A Meta key on the keyboard is pressed.
+    \o Qt.KeypadModifier - A keypad button is pressed.
+    \endlist
+
+    For example, to react to a Control key pressed during the wheel event:
+    \qml
+    MouseArea {
+        onWheel: {
+            if (wheel.modifiers & Qt.ControlModifier) {
+                if (wheel.angleDelta.y > 0)
+                    zoomIn();
+                else
+                    zoomOut();
+            }
+        }
+    }
+    \endqml
+*/
+
 QT_END_NAMESPACE
diff --git a/src/quick/items/qquickevents_p_p.h b/src/quick/items/qquickevents_p_p.h
index 6300b0f2a7..004daafb04 100644
--- a/src/quick/items/qquickevents_p_p.h
+++ b/src/quick/items/qquickevents_p_p.h
@@ -201,9 +201,47 @@ private:
 };
 
 
+class QQuickWheelEvent : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(qreal x READ x)
+    Q_PROPERTY(qreal y READ y)
+    Q_PROPERTY(QPoint angleDelta READ angleDelta)
+    Q_PROPERTY(QPoint pixelDelta READ pixelDelta)
+    Q_PROPERTY(int buttons READ buttons)
+    Q_PROPERTY(int modifiers READ modifiers)
+    Q_PROPERTY(bool accepted READ isAccepted WRITE setAccepted)
+
+public:
+    QQuickWheelEvent(qreal x, qreal y, const QPoint& angleDelta, const QPoint& pixelDelta,
+                     Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers)
+        : _x(x), _y(y), _angleDelta(angleDelta), _pixelDelta(pixelDelta), _buttons(buttons),
+          _modifiers(modifiers), _accepted(true) {}
+
+    qreal x() const { return _x; }
+    qreal y() const { return _y; }
+    QPoint angleDelta() const { return _angleDelta; }
+    QPoint pixelDelta() const { return _pixelDelta; }
+    int buttons() const { return _buttons; }
+    int modifiers() const { return _modifiers; }
+
+    bool isAccepted() { return _accepted; }
+    void setAccepted(bool accepted) { _accepted = accepted; }
+
+private:
+    qreal _x;
+    qreal _y;
+    QPoint _angleDelta;
+    QPoint _pixelDelta;
+    Qt::MouseButtons _buttons;
+    Qt::KeyboardModifiers _modifiers;
+    bool _accepted;
+};
+
 QT_END_NAMESPACE
 
 QML_DECLARE_TYPE(QQuickKeyEvent)
 QML_DECLARE_TYPE(QQuickMouseEvent)
+QML_DECLARE_TYPE(QQuickWheelEvent)
 
 #endif // QQUICKEVENTS_P_P_H
diff --git a/src/quick/items/qquickgridview.cpp b/src/quick/items/qquickgridview.cpp
index a78ab4c4e5..78899b27e5 100644
--- a/src/quick/items/qquickgridview.cpp
+++ b/src/quick/items/qquickgridview.cpp
@@ -120,8 +120,8 @@ public:
                 return itemX() + view->cellWidth();
         }
     }
-    void setPosition(qreal col, qreal row) {
-        moveTo(pointForPosition(col, row));
+    void setPosition(qreal col, qreal row, bool immediate = false) {
+        moveTo(pointForPosition(col, row), immediate);
     }
     bool contains(qreal x, qreal y) const {
         return (x >= itemX() && x < itemX() + view->cellWidth() &&
@@ -483,7 +483,7 @@ bool QQuickGridViewPrivate::addVisibleItems(qreal fillFrom, qreal fillTo, bool d
         if (!(item = static_cast<FxGridItemSG*>(createItem(modelIndex, doBuffer))))
             break;
         if (!transitioner || !transitioner->canTransition(QQuickItemViewTransitioner::PopulateTransition, true)) // pos will be set by layoutVisibleItems()
-            item->setPosition(colPos, rowPos);
+            item->setPosition(colPos, rowPos, true);
         item->item->setVisible(!doBuffer);
         visibleItems.append(item);
         if (++colNum >= columns) {
@@ -521,7 +521,7 @@ bool QQuickGridViewPrivate::addVisibleItems(qreal fillFrom, qreal fillTo, bool d
             break;
         --visibleIndex;
         if (!transitioner || !transitioner->canTransition(QQuickItemViewTransitioner::PopulateTransition, true)) // pos will be set by layoutVisibleItems()
-            item->setPosition(colPos, rowPos);
+            item->setPosition(colPos, rowPos, true);
         item->item->setVisible(!doBuffer);
         visibleItems.prepend(item);
         if (--colNum < 0) {
@@ -2165,12 +2165,10 @@ bool QQuickGridViewPrivate::applyInsertionChange(const QQuickChangeSet::Insert &
         FxViewItem *item = visibleItems.at(i);
         if (item->index != -1 && item->index >= modelIndex) {
             item->index += count;
-            if (transitioner) {
-                if (change.isMove())
-                    transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::MoveTransition, false);
-                else
-                    transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::AddTransition, false);
-            }
+            if (change.isMove())
+                item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::MoveTransition, false);
+            else
+                item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::AddTransition, false);
         }
     }
 
@@ -2201,8 +2199,7 @@ bool QQuickGridViewPrivate::applyInsertionChange(const QQuickChangeSet::Insert &
                     insertResult->changedFirstItem = true;
                 if (!change.isMove()) {
                     addedItems->append(item);
-                    if (transitioner)
-                        transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::AddTransition, true);
+                    item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::AddTransition, true);
                 }
                 insertResult->sizeChangesBeforeVisiblePos += rowSize();
             }
@@ -2239,8 +2236,7 @@ bool QQuickGridViewPrivate::applyInsertionChange(const QQuickChangeSet::Insert &
                     movingIntoView->append(MovedItem(item, change.moveKey(item->index)));
             } else {
                 addedItems->append(item);
-                if (transitioner)
-                    transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::AddTransition, true);
+                item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::AddTransition, true);
             }
             insertResult->sizeChangesAfterVisiblePos += rowSize();
 
@@ -2291,7 +2287,7 @@ void QQuickGridViewPrivate::translateAndTransitionItemsAfter(int afterModelIndex
             qreal origColPos = gridItem->rowPos();
             int indexDiff = gridItem->index - countItemsRemoved;
             gridItem->setPosition((indexDiff % columns) * colSize(), (indexDiff / columns) * rowSize());
-            transitioner->transitionNextReposition(gridItem, QQuickItemViewTransitioner::RemoveTransition, false);
+            gridItem->transitionNextReposition(transitioner, QQuickItemViewTransitioner::RemoveTransition, false);
             gridItem->setPosition(origRowPos, origColPos);
         }
     }
diff --git a/src/quick/items/qquickitemsmodule.cpp b/src/quick/items/qquickitemsmodule.cpp
index 3d23f7b03a..421a4cd0b1 100644
--- a/src/quick/items/qquickitemsmodule.cpp
+++ b/src/quick/items/qquickitemsmodule.cpp
@@ -169,6 +169,7 @@ static void qt_quickitems_defineModule(const char *uri, int major, int minor)
     qmlRegisterType<QQuickAnchors>();
     qmlRegisterType<QQuickKeyEvent>();
     qmlRegisterType<QQuickMouseEvent>();
+    qmlRegisterType<QQuickWheelEvent>();
     qmlRegisterType<QQuickTransform>();
     qmlRegisterType<QQuickPathElement>();
     qmlRegisterType<QQuickCurve>();
diff --git a/src/quick/items/qquickitemview.cpp b/src/quick/items/qquickitemview.cpp
index e368d1aaec..c6f45aaf0b 100644
--- a/src/quick/items/qquickitemview.cpp
+++ b/src/quick/items/qquickitemview.cpp
@@ -46,12 +46,16 @@ QT_BEGIN_NAMESPACE
 
 
 FxViewItem::FxViewItem(QQuickItem *i, bool own)
-    : QQuickViewItem(i), ownItem(own), releaseAfterTransition(false)
+    : item(i)
+    , transitionableItem(0)
+    , ownItem(own)
+    , releaseAfterTransition(false)
 {
 }
 
 FxViewItem::~FxViewItem()
 {
+    delete transitionableItem;
     if (ownItem && item) {
         item->setParentItem(0);
         item->deleteLater();
@@ -59,6 +63,71 @@ FxViewItem::~FxViewItem()
     }
 }
 
+qreal FxViewItem::itemX() const
+{
+    return transitionableItem ? transitionableItem->itemX() : item->x();
+}
+
+qreal FxViewItem::itemY() const
+{
+    return transitionableItem ? transitionableItem->itemY() : item->y();
+}
+
+void FxViewItem::moveTo(const QPointF &pos, bool immediate)
+{
+    if (transitionableItem)
+        transitionableItem->moveTo(pos, immediate);
+    else
+        item->setPos(pos);
+}
+
+void FxViewItem::setVisible(bool visible)
+{
+    if (!visible && transitionableItem && transitionableItem->transitionScheduledOrRunning())
+        return;
+    item->setVisible(visible);
+}
+
+QQuickItemViewTransitioner::TransitionType FxViewItem::scheduledTransitionType() const
+{
+    return transitionableItem ? transitionableItem->nextTransitionType : QQuickItemViewTransitioner::NoTransition;
+}
+
+bool FxViewItem::transitionScheduledOrRunning() const
+{
+    return transitionableItem ? transitionableItem->transitionScheduledOrRunning() : false;
+}
+
+bool FxViewItem::transitionRunning() const
+{
+    return transitionableItem ? transitionableItem->transitionRunning() : false;
+}
+
+bool FxViewItem::isPendingRemoval() const
+{
+    return transitionableItem ? transitionableItem->isPendingRemoval() : false;
+}
+
+void FxViewItem::transitionNextReposition(QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, bool asTarget)
+{
+    if (!transitioner)
+        return;
+    if (!transitionableItem)
+        transitionableItem = new QQuickItemViewTransitionableItem(item);
+    transitioner->transitionNextReposition(transitionableItem, type, asTarget);
+}
+
+bool FxViewItem::prepareTransition(QQuickItemViewTransitioner *transitioner, const QRectF &viewBounds)
+{
+    return transitionableItem ? transitionableItem->prepareTransition(transitioner, index, viewBounds) : false;
+}
+
+void FxViewItem::startTransition(QQuickItemViewTransitioner *transitioner)
+{
+    if (transitionableItem)
+        transitionableItem->startTransition(transitioner, index);
+}
+
 
 QQuickItemViewChangeSet::QQuickItemViewChangeSet()
     : active(false)
@@ -1615,7 +1684,7 @@ void QQuickItemViewPrivate::layout()
         // assume that any items moving now are moving due to the remove - if they schedule
         // a different transition, that will override this one anyway
         for (int i=0; i<visibleItems.count(); i++)
-            transitioner->transitionNextReposition(visibleItems[i], QQuickItemViewTransitioner::RemoveTransition, false);
+            visibleItems[i]->transitionNextReposition(transitioner, QQuickItemViewTransitioner::RemoveTransition, false);
     }
 
     ChangeResult insertionPosChanges;
@@ -1631,7 +1700,7 @@ void QQuickItemViewPrivate::layout()
 
     if (transitioner && transitioner->canTransition(QQuickItemViewTransitioner::PopulateTransition, true)) {
         for (int i=0; i<visibleItems.count(); i++)
-            transitioner->transitionNextReposition(visibleItems.at(i), QQuickItemViewTransitioner::PopulateTransition, true);
+            visibleItems.at(i)->transitionNextReposition(transitioner, QQuickItemViewTransitioner::PopulateTransition, true);
     }
     layoutVisibleItems();
 
@@ -1791,7 +1860,7 @@ bool QQuickItemViewPrivate::applyModelChanges(ChangeResult *totalInsertionResult
                     repositionItemAt(movingIntoView[i].item, fromIndex, -totalInsertionResult->sizeChangesAfterVisiblePos);
                 else
                     repositionItemAt(movingIntoView[i].item, fromIndex, totalInsertionResult->sizeChangesAfterVisiblePos);
-                transitioner->transitionNextReposition(movingIntoView[i].item, QQuickItemViewTransitioner::MoveTransition, true);
+                movingIntoView[i].item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::MoveTransition, true);
             }
         }
     }
@@ -1855,12 +1924,10 @@ bool QQuickItemViewPrivate::applyRemovalChange(const QQuickChangeSet::Remove &re
         } else if (item->index >= removal.index + removal.count) {
             // after removed items
             item->index -= removal.count;
-            if (transitioner) {
-                if (removal.isMove())
-                    transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::MoveTransition, false);
-                else
-                    transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::RemoveTransition, false);
-            }
+            if (removal.isMove())
+                item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::MoveTransition, false);
+            else
+                item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::RemoveTransition, false);
             ++it;
         } else {
             // removed item
@@ -1894,8 +1961,7 @@ void QQuickItemViewPrivate::removeItem(FxViewItem *item, const QQuickChangeSet::
     }
     if (removal.isMove()) {
         currentChanges.removedItems.insert(removal.moveKey(item->index), item);
-        if (transitioner)
-            transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::MoveTransition, true);
+        item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::MoveTransition, true);
     } else {
         // track item so it is released later
         currentChanges.removedItems.insertMulti(QQuickChangeSet::MoveKey(), item);
@@ -1977,7 +2043,7 @@ void QQuickItemViewPrivate::prepareRemoveTransitions(QHash<QQuickChangeSet::Move
                 FxViewItem *item = *it;
                 item->releaseAfterTransition = true;
                 releasePendingTransition.append(item);
-                transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::RemoveTransition, true);
+                item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::RemoveTransition, true);
                 it = removedItems->erase(it);
             } else {
                 ++it;
@@ -1996,7 +2062,7 @@ bool QQuickItemViewPrivate::prepareNonVisibleItemTransition(FxViewItem *item, co
     if (!transitioner)
         return false;
 
-    if (item->nextTransitionType == QQuickItemViewTransitioner::MoveTransition)
+    if (item->scheduledTransitionType() == QQuickItemViewTransitioner::MoveTransition)
         repositionItemAt(item, item->index, 0);
 
     if (item->prepareTransition(transitioner, viewBounds)) {
@@ -2006,12 +2072,13 @@ bool QQuickItemViewPrivate::prepareNonVisibleItemTransition(FxViewItem *item, co
     return false;
 }
 
-void QQuickItemViewPrivate::viewItemTransitionFinished(QQuickViewItem *i)
+void QQuickItemViewPrivate::viewItemTransitionFinished(QQuickItemViewTransitionableItem *item)
 {
-    FxViewItem *item = static_cast<FxViewItem *>(i);
-    if (item->releaseAfterTransition) {
-        releasePendingTransition.removeOne(item);
-        releaseItem(item);
+    for (int i=0; i<releasePendingTransition.count(); i++) {
+        if (releasePendingTransition[i]->transitionableItem == item) {
+            releaseItem(releasePendingTransition.takeAt(i));
+            return;
+        }
     }
 }
 
diff --git a/src/quick/items/qquickitemview_p_p.h b/src/quick/items/qquickitemview_p_p.h
index 80dacc0cb4..dfc0a8bc7e 100644
--- a/src/quick/items/qquickitemview_p_p.h
+++ b/src/quick/items/qquickitemview_p_p.h
@@ -57,12 +57,27 @@ QT_BEGIN_NAMESPACE
 QT_MODULE(Quick)
 
 
-class FxViewItem : public QQuickViewItem
+class FxViewItem
 {
 public:
     FxViewItem(QQuickItem *, bool own);
     virtual ~FxViewItem();
 
+    qreal itemX() const;
+    qreal itemY() const;
+
+    void moveTo(const QPointF &pos, bool immediate);
+    void setVisible(bool visible);
+
+    QQuickItemViewTransitioner::TransitionType scheduledTransitionType() const;
+    bool transitionScheduledOrRunning() const;
+    bool transitionRunning() const;
+    bool isPendingRemoval() const;
+
+    void transitionNextReposition(QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, bool asTarget);
+    bool prepareTransition(QQuickItemViewTransitioner *transitioner, const QRectF &viewBounds);
+    void startTransition(QQuickItemViewTransitioner *transitioner);
+
     // these are positions and sizes along the current direction of scrolling/flicking
     virtual qreal position() const = 0;
     virtual qreal endPosition() const = 0;
@@ -71,7 +86,10 @@ public:
 
     virtual bool contains(qreal x, qreal y) const = 0;
 
+    QQuickItem *item;
+    QQuickItemViewTransitionableItem *transitionableItem;
     QQuickItemViewAttached *attached;
+    int index;
     bool ownItem;
     bool releaseAfterTransition;
 };
@@ -192,7 +210,7 @@ public:
     void prepareVisibleItemTransitions();
     void prepareRemoveTransitions(QHash<QQuickChangeSet::MoveKey, FxViewItem *> *removedItems);
     bool prepareNonVisibleItemTransition(FxViewItem *item, const QRectF &viewBounds);
-    virtual void viewItemTransitionFinished(QQuickViewItem *item);
+    virtual void viewItemTransitionFinished(QQuickItemViewTransitionableItem *item);
 
     int findMoveKeyIndex(QQuickChangeSet::MoveKey key, const QVector<QQuickChangeSet::Remove> &changes) const;
 
diff --git a/src/quick/items/qquickitemviewtransition.cpp b/src/quick/items/qquickitemviewtransition.cpp
index 5669ef927e..d9dce49349 100644
--- a/src/quick/items/qquickitemviewtransition.cpp
+++ b/src/quick/items/qquickitemviewtransition.cpp
@@ -55,13 +55,14 @@ public:
     QQuickItemViewTransitionJob();
     ~QQuickItemViewTransitionJob();
 
-    void startTransition(QQuickViewItem *item, QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, const QPointF &to, bool isTargetItem);
+    void startTransition(QQuickItemViewTransitionableItem *item, int index, QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, const QPointF &to, bool isTargetItem);
 
     QQuickItemViewTransitioner *m_transitioner;
-    QQuickViewItem *m_item;
+    QQuickItemViewTransitionableItem *m_item;
     QPointF m_toPos;
     QQuickItemViewTransitioner::TransitionType m_type;
     bool m_isTarget;
+    bool *m_wasDeleted;
 
 protected:
     virtual void finished();
@@ -73,16 +74,19 @@ QQuickItemViewTransitionJob::QQuickItemViewTransitionJob()
     , m_item(0)
     , m_type(QQuickItemViewTransitioner::NoTransition)
     , m_isTarget(false)
+    , m_wasDeleted(0)
 {
 }
 
 QQuickItemViewTransitionJob::~QQuickItemViewTransitionJob()
 {
+    if (m_wasDeleted)
+        *m_wasDeleted = true;
     if (m_transitioner)
         m_transitioner->runningJobs.remove(this);
 }
 
-void QQuickItemViewTransitionJob::startTransition(QQuickViewItem *item, QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, const QPointF &to, bool isTargetItem)
+void QQuickItemViewTransitionJob::startTransition(QQuickItemViewTransitionableItem *item, int index, QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, const QPointF &to, bool isTargetItem)
 {
     if (type == QQuickItemViewTransitioner::NoTransition)
         return;
@@ -110,7 +114,7 @@ void QQuickItemViewTransitionJob::startTransition(QQuickViewItem *item, QQuickIt
     QQuickViewTransitionAttached *attached =
             static_cast<QQuickViewTransitionAttached*>(qmlAttachedPropertiesObject<QQuickViewTransitionAttached>(trans));
     if (attached) {
-        attached->m_index = item->index;
+        attached->m_index = index;
         attached->m_item = item->item;
         attached->m_destination = to;
         attached->m_targetIndexes = m_transitioner->targetIndexes(type);
@@ -134,8 +138,16 @@ void QQuickItemViewTransitionJob::finished()
 {
     QQuickTransitionManager::finished();
 
-    if (m_transitioner)
+    if (m_transitioner) {
+        bool deleted = false;
+        m_wasDeleted = &deleted;
         m_transitioner->finishedTransition(this, m_item);
+        if (deleted)
+            return;
+        m_wasDeleted = 0;
+
+        m_transitioner = 0;
+    }
 
     m_item = 0;
     m_toPos.setX(0);
@@ -197,12 +209,12 @@ bool QQuickItemViewTransitioner::canTransition(QQuickItemViewTransitioner::Trans
     return false;
 }
 
-void QQuickItemViewTransitioner::transitionNextReposition(QQuickViewItem *item, QQuickItemViewTransitioner::TransitionType type, bool isTarget)
+void QQuickItemViewTransitioner::transitionNextReposition(QQuickItemViewTransitionableItem *item, QQuickItemViewTransitioner::TransitionType type, bool isTarget)
 {
     item->setNextTransition(type, isTarget);
 }
 
-void QQuickItemViewTransitioner::addToTargetLists(QQuickItemViewTransitioner::TransitionType type, QQuickViewItem *item, int index)
+void QQuickItemViewTransitioner::addToTargetLists(QQuickItemViewTransitioner::TransitionType type, QQuickItemViewTransitionableItem *item, int index)
 {
     switch (type) {
     case NoTransition:
@@ -302,7 +314,7 @@ const QList<QObject *> &QQuickItemViewTransitioner::targetItems(QQuickItemViewTr
     return qquickitemviewtransition_emptyTargets;
 }
 
-void QQuickItemViewTransitioner::finishedTransition(QQuickItemViewTransitionJob *job, QQuickViewItem *item)
+void QQuickItemViewTransitioner::finishedTransition(QQuickItemViewTransitionJob *job, QQuickItemViewTransitionableItem *item)
 {
     if (!runningJobs.contains(job))
         return;
@@ -315,23 +327,22 @@ void QQuickItemViewTransitioner::finishedTransition(QQuickItemViewTransitionJob
 }
 
 
-QQuickViewItem::QQuickViewItem(QQuickItem *i)
+QQuickItemViewTransitionableItem::QQuickItemViewTransitionableItem(QQuickItem *i)
     : item(i)
     , transition(0)
     , nextTransitionType(QQuickItemViewTransitioner::NoTransition)
-    , index(-1)
     , isTransitionTarget(false)
     , nextTransitionToSet(false)
     , prepared(false)
 {
 }
 
-QQuickViewItem::~QQuickViewItem()
+QQuickItemViewTransitionableItem::~QQuickItemViewTransitionableItem()
 {
     delete transition;
 }
 
-qreal QQuickViewItem::itemX() const
+qreal QQuickItemViewTransitionableItem::itemX() const
 {
     if (nextTransitionType != QQuickItemViewTransitioner::NoTransition)
         return nextTransitionToSet ? nextTransitionTo.x() : item->x();
@@ -341,7 +352,7 @@ qreal QQuickViewItem::itemX() const
         return item->x();
 }
 
-qreal QQuickViewItem::itemY() const
+qreal QQuickItemViewTransitionableItem::itemY() const
 {
     // If item is transitioning to some pos, return that dest pos.
     // If item was redirected to some new pos before the current transition finished,
@@ -354,35 +365,33 @@ qreal QQuickViewItem::itemY() const
         return item->y();
 }
 
-void QQuickViewItem::moveTo(const QPointF &pos)
+void QQuickItemViewTransitionableItem::moveTo(const QPointF &pos, bool immediate)
 {
-    if (transitionScheduledOrRunning()) {
+    if (immediate || !transitionScheduledOrRunning()) {
+        if (immediate) {
+            if (transition)
+                transition->cancel();
+            resetTransitionData();
+        }
+        item->setPos(pos);
+    } else {
         nextTransitionTo = pos;
         nextTransitionToSet = true;
-    } else {
-        item->setPos(pos);
     }
 }
 
-void QQuickViewItem::setVisible(bool visible)
-{
-    if (!visible && transitionScheduledOrRunning())
-        return;
-    item->setVisible(visible);
-}
-
-bool QQuickViewItem::transitionScheduledOrRunning() const
+bool QQuickItemViewTransitionableItem::transitionScheduledOrRunning() const
 {
     return (transition && transition->isRunning())
             || nextTransitionType != QQuickItemViewTransitioner::NoTransition;
 }
 
-bool QQuickViewItem::transitionRunning() const
+bool QQuickItemViewTransitionableItem::transitionRunning() const
 {
     return (transition && transition->isRunning());
 }
 
-bool QQuickViewItem::isPendingRemoval() const
+bool QQuickItemViewTransitionableItem::isPendingRemoval() const
 {
     if (nextTransitionType == QQuickItemViewTransitioner::RemoveTransition)
         return isTransitionTarget;
@@ -391,7 +400,7 @@ bool QQuickViewItem::isPendingRemoval() const
     return false;
 }
 
-bool QQuickViewItem::prepareTransition(QQuickItemViewTransitioner *transitioner, const QRectF &viewBounds)
+bool QQuickItemViewTransitionableItem::prepareTransition(QQuickItemViewTransitioner *transitioner, int index, const QRectF &viewBounds)
 {
     bool doTransition = false;
 
@@ -466,7 +475,7 @@ bool QQuickViewItem::prepareTransition(QQuickItemViewTransitioner *transitioner,
     return doTransition;
 }
 
-void QQuickViewItem::startTransition(QQuickItemViewTransitioner *transitioner)
+void QQuickItemViewTransitionableItem::startTransition(QQuickItemViewTransitioner *transitioner, int index)
 {
     if (nextTransitionType == QQuickItemViewTransitioner::NoTransition)
         return;
@@ -486,12 +495,12 @@ void QQuickViewItem::startTransition(QQuickItemViewTransitioner *transitioner)
     if (!nextTransitionToSet)
         moveTo(item->pos());
 
-    transition->startTransition(this, transitioner, nextTransitionType, nextTransitionTo, isTransitionTarget);
+    transition->startTransition(this, index, transitioner, nextTransitionType, nextTransitionTo, isTransitionTarget);
     nextTransitionType = QQuickItemViewTransitioner::NoTransition;
     prepared = false;
 }
 
-void QQuickViewItem::setNextTransition(QQuickItemViewTransitioner::TransitionType type, bool isTargetItem)
+void QQuickItemViewTransitionableItem::setNextTransition(QQuickItemViewTransitioner::TransitionType type, bool isTargetItem)
 {
     // Don't reset nextTransitionToSet - once it is set, it cannot be changed
     // until the animation finishes since the itemX() and itemY() may be used
@@ -500,20 +509,20 @@ void QQuickViewItem::setNextTransition(QQuickItemViewTransitioner::TransitionTyp
     isTransitionTarget = isTargetItem;
 }
 
-bool QQuickViewItem::transitionWillChangePosition() const
+bool QQuickItemViewTransitionableItem::transitionWillChangePosition() const
 {
     if (transitionRunning() && transition->m_toPos != nextTransitionTo)
         return true;
     return nextTransitionTo != item->pos();
 }
 
-void QQuickViewItem::finishedTransition()
+void QQuickItemViewTransitionableItem::finishedTransition()
 {
     nextTransitionToSet = false;
     nextTransitionTo = QPointF();
 }
 
-void QQuickViewItem::resetTransitionData()
+void QQuickItemViewTransitionableItem::resetTransitionData()
 {
     nextTransitionType = QQuickItemViewTransitioner::NoTransition;
     isTransitionTarget = false;
diff --git a/src/quick/items/qquickitemviewtransition_p.h b/src/quick/items/qquickitemviewtransition_p.h
index 73c238e929..a4babdca05 100644
--- a/src/quick/items/qquickitemviewtransition_p.h
+++ b/src/quick/items/qquickitemviewtransition_p.h
@@ -51,7 +51,7 @@ QT_BEGIN_NAMESPACE
 QT_MODULE(Quick)
 
 class QQuickItem;
-class QQuickViewItem;
+class QQuickItemViewTransitionableItem;
 class QQuickItemViewTransitionJob;
 
 
@@ -61,7 +61,7 @@ public:
     QQuickItemViewTransitionChangeListener() {}
     virtual ~QQuickItemViewTransitionChangeListener() {}
 
-    virtual void viewItemTransitionFinished(QQuickViewItem *item) = 0;
+    virtual void viewItemTransitionFinished(QQuickItemViewTransitionableItem *item) = 0;
 };
 
 
@@ -80,9 +80,9 @@ public:
     virtual ~QQuickItemViewTransitioner();
 
     bool canTransition(QQuickItemViewTransitioner::TransitionType type, bool asTarget) const;
-    void transitionNextReposition(QQuickViewItem *item, QQuickItemViewTransitioner::TransitionType type, bool isTarget);
+    void transitionNextReposition(QQuickItemViewTransitionableItem *item, QQuickItemViewTransitioner::TransitionType type, bool isTarget);
 
-    void addToTargetLists(QQuickItemViewTransitioner::TransitionType type, QQuickViewItem *item, int index);
+    void addToTargetLists(QQuickItemViewTransitioner::TransitionType type, QQuickItemViewTransitionableItem *item, int index);
     void resetTargetLists();
 
     QQuickTransition *transitionObject(QQuickItemViewTransitioner::TransitionType type, bool asTarget);
@@ -116,37 +116,35 @@ private:
     QQuickItemViewTransitionChangeListener *changeListener;
     bool usePopulateTransition;
 
-    void finishedTransition(QQuickItemViewTransitionJob *job, QQuickViewItem *item);
+    void finishedTransition(QQuickItemViewTransitionJob *job, QQuickItemViewTransitionableItem *item);
 };
 
 
 /*
-  An item in a view, that can be transitioned using QQuickViewTransitionJob.
+  An item that can be transitioned using QQuickViewTransitionJob.
   */
-class QQuickViewItem
+class QQuickItemViewTransitionableItem
 {
 public:
-    QQuickViewItem(QQuickItem *i);
-    virtual ~QQuickViewItem();
+    QQuickItemViewTransitionableItem(QQuickItem *i);
+    virtual ~QQuickItemViewTransitionableItem();
 
     qreal itemX() const;
     qreal itemY() const;
 
-    void moveTo(const QPointF &pos);
-    void setVisible(bool visible);
+    void moveTo(const QPointF &pos, bool immediate = false);
 
     bool transitionScheduledOrRunning() const;
     bool transitionRunning() const;
     bool isPendingRemoval() const;
 
-    bool prepareTransition(QQuickItemViewTransitioner *transitioner, const QRectF &viewBounds);
-    void startTransition(QQuickItemViewTransitioner *transitioner);
+    bool prepareTransition(QQuickItemViewTransitioner *transitioner, int index, const QRectF &viewBounds);
+    void startTransition(QQuickItemViewTransitioner *transitioner, int index);
 
     QPointF nextTransitionTo;
     QQuickItem *item;
     QQuickItemViewTransitionJob *transition;
     QQuickItemViewTransitioner::TransitionType nextTransitionType;
-    int index;
     bool isTransitionTarget;
     bool nextTransitionToSet;
     bool prepared;
diff --git a/src/quick/items/qquicklistview.cpp b/src/quick/items/qquicklistview.cpp
index a2f687c86b..9db2060d89 100644
--- a/src/quick/items/qquicklistview.cpp
+++ b/src/quick/items/qquicklistview.cpp
@@ -292,7 +292,7 @@ public:
                     : itemX() + item->width());
         }
     }
-    void setPosition(qreal pos) {
+    void setPosition(qreal pos, bool immediate = false) {
         // position the section immediately even if there is a transition
         if (section()) {
             if (view->orientation() == QQuickListView::Vertical) {
@@ -304,7 +304,7 @@ public:
                     section()->setX(pos);
             }
         }
-        moveTo(pointForPosition(pos));
+        moveTo(pointForPosition(pos), immediate);
     }
     void setSize(qreal size) {
         if (view->orientation() == QQuickListView::Vertical)
@@ -638,7 +638,7 @@ bool QQuickListViewPrivate::addVisibleItems(qreal fillFrom, qreal fillTo, bool d
         if (!(item = static_cast<FxListItemSG*>(createItem(modelIndex, doBuffer))))
             break;
         if (!transitioner || !transitioner->canTransition(QQuickItemViewTransitioner::PopulateTransition, true)) // pos will be set by layoutVisibleItems()
-            item->setPosition(pos);
+            item->setPosition(pos, true);
         item->item->setVisible(!doBuffer);
         pos += item->size() + spacing;
         visibleItems.append(item);
@@ -658,7 +658,7 @@ bool QQuickListViewPrivate::addVisibleItems(qreal fillFrom, qreal fillTo, bool d
         --visibleIndex;
         visiblePos -= item->size() + spacing;
         if (!transitioner || !transitioner->canTransition(QQuickItemViewTransitioner::PopulateTransition, true)) // pos will be set by layoutVisibleItems()
-            item->setPosition(visiblePos);
+            item->setPosition(visiblePos, true);
         item->item->setVisible(!doBuffer);
         visibleItems.prepend(item);
         changed = true;
@@ -2786,8 +2786,7 @@ bool QQuickListViewPrivate::applyInsertionChange(const QQuickChangeSet::Insert &
                     insertResult->changedFirstItem = true;
                 if (!change.isMove()) {
                     addedItems->append(item);
-                    if (transitioner)
-                        transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::AddTransition, true);
+                    item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::AddTransition, true);
                 }
                 insertResult->sizeChangesBeforeVisiblePos += item->size() + spacing;
                 pos -= item->size() + spacing;
@@ -2817,8 +2816,7 @@ bool QQuickListViewPrivate::applyInsertionChange(const QQuickChangeSet::Insert &
                     movingIntoView->append(MovedItem(item, change.moveKey(item->index)));
             } else {
                 addedItems->append(item);
-                if (transitioner)
-                    transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::AddTransition, true);
+                item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::AddTransition, true);
             }
             insertResult->sizeChangesAfterVisiblePos += item->size() + spacing;
             pos += item->size() + spacing;
@@ -2828,13 +2826,12 @@ bool QQuickListViewPrivate::applyInsertionChange(const QQuickChangeSet::Insert &
 
     for (; index < visibleItems.count(); ++index) {
         FxViewItem *item = visibleItems.at(index);
-        if (item->index != -1)
+        if (item->index != -1) {
             item->index += count;
-        if (transitioner) {
             if (change.isMove())
-                transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::MoveTransition, false);
+                item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::MoveTransition, false);
             else
-                transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::AddTransition, false);
+                item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::AddTransition, false);
         }
     }
 
@@ -2869,7 +2866,7 @@ void QQuickListViewPrivate::translateAndTransitionItemsAfter(int afterModelIndex
         if (!listItem->transitionScheduledOrRunning()) {
             qreal pos = listItem->position();
             listItem->setPosition(pos - sizeRemoved);
-            transitioner->transitionNextReposition(listItem, QQuickItemViewTransitioner::RemoveTransition, false);
+            listItem->transitionNextReposition(transitioner, QQuickItemViewTransitioner::RemoveTransition, false);
             listItem->setPosition(pos);
         }
     }
diff --git a/src/quick/items/qquickmousearea.cpp b/src/quick/items/qquickmousearea.cpp
index ef57242319..efb804bd18 100644
--- a/src/quick/items/qquickmousearea.cpp
+++ b/src/quick/items/qquickmousearea.cpp
@@ -236,6 +236,13 @@ bool QQuickMouseAreaPrivate::isClickConnected()
     return QObjectPrivate::get(q)->isSignalConnected(idx);
 }
 
+bool QQuickMouseAreaPrivate::isWheelConnected()
+{
+    Q_Q(QQuickMouseArea);
+    static int idx = QObjectPrivate::get(q)->signalIndex("wheel(QQuickWheelEvent*)");
+    return QObjectPrivate::get(q)->isSignalConnected(idx);
+}
+
 void QQuickMouseAreaPrivate::propagate(QQuickMouseEvent* event, PropagateType t)
 {
     Q_Q(QQuickMouseArea);
@@ -331,7 +338,8 @@ bool QQuickMouseAreaPrivate::propagateHelper(QQuickMouseEvent *ev, QQuickItem *i
     Information about the mouse position and button clicks are provided via
     signals for which event handler properties are defined. The most commonly
     used involved handling mouse presses and clicks: onClicked, onDoubleClicked,
-    onPressed, onReleased and onPressAndHold.
+    onPressed, onReleased and onPressAndHold. It's also possible to handle mouse
+    wheel events via the onWheel signal.
 
     By default, MouseArea items only report mouse clicks and not changes to the
     position of the mouse cursor. Setting the hoverEnabled property ensures that
@@ -513,6 +521,17 @@ bool QQuickMouseAreaPrivate::propagateHelper(QQuickMouseEvent *ev, QQuickItem *i
     the logic when the MouseArea has lost the mouse handling to the \l Flickable,
     \c onCanceled should be used in addition to onReleased.
 */
+
+/*!
+    \qmlsignal QtQuick2::MouseArea::onWheel(WheelEvent mouse)
+
+    This handler is called in response to both mouse wheel and trackpad scroll gestures.
+
+    The \l {WheelEvent}{wheel} parameter provides information about the event, including the x and y
+    position, any buttons currently pressed, and information about the wheel movement, including
+    angleDelta and pixelDelta.
+*/
+
 QQuickMouseArea::QQuickMouseArea(QQuickItem *parent)
   : QQuickItem(*(new QQuickMouseAreaPrivate), parent)
 {
@@ -860,6 +879,22 @@ void QQuickMouseArea::hoverLeaveEvent(QHoverEvent *event)
         setHovered(false);
 }
 
+void QQuickMouseArea::wheelEvent(QWheelEvent *event)
+{
+    Q_D(QQuickMouseArea);
+    if (!d->absorb) {
+        QQuickItem::wheelEvent(event);
+        return;
+    }
+
+    QQuickWheelEvent we(event->posF().x(), event->posF().y(), event->angleDelta(),
+                        event->pixelDelta(), event->buttons(), event->modifiers());
+    we.setAccepted(d->isWheelConnected());
+    emit wheel(&we);
+    if (!we.isAccepted())
+        QQuickItem::wheelEvent(event);
+}
+
 void QQuickMouseArea::ungrabMouse()
 {
     Q_D(QQuickMouseArea);
diff --git a/src/quick/items/qquickmousearea_p.h b/src/quick/items/qquickmousearea_p.h
index 93a0635eb5..7eb9e5da05 100644
--- a/src/quick/items/qquickmousearea_p.h
+++ b/src/quick/items/qquickmousearea_p.h
@@ -119,6 +119,7 @@ private:
 };
 
 class QQuickMouseAreaPrivate;
+class QQuickWheelEvent;
 // used in QtLocation
 class Q_QUICK_EXPORT QQuickMouseArea : public QQuickItem
 {
@@ -182,6 +183,7 @@ Q_SIGNALS:
     void released(QQuickMouseEvent *mouse);
     void clicked(QQuickMouseEvent *mouse);
     void doubleClicked(QQuickMouseEvent *mouse);
+    void wheel(QQuickWheelEvent *wheel);
     void entered();
     void exited();
     void canceled();
@@ -199,6 +201,7 @@ protected:
     virtual void hoverEnterEvent(QHoverEvent *event);
     virtual void hoverMoveEvent(QHoverEvent *event);
     virtual void hoverLeaveEvent(QHoverEvent *event);
+    virtual void wheelEvent(QWheelEvent *event);
     virtual bool childMouseEventFilter(QQuickItem *i, QEvent *e);
     virtual void timerEvent(QTimerEvent *event);
     virtual void windowDeactivateEvent();
diff --git a/src/quick/items/qquickmousearea_p_p.h b/src/quick/items/qquickmousearea_p_p.h
index bcdf033cba..f5521d9228 100644
--- a/src/quick/items/qquickmousearea_p_p.h
+++ b/src/quick/items/qquickmousearea_p_p.h
@@ -83,6 +83,7 @@ public:
     bool isPressAndHoldConnected();
     bool isDoubleClickConnected();
     bool isClickConnected();
+    bool isWheelConnected();
 
     bool absorb : 1;
     bool hovered : 1;
diff --git a/src/quick/items/qquickpositioners.cpp b/src/quick/items/qquickpositioners.cpp
index e9a0c179e0..7c4cd18346 100644
--- a/src/quick/items/qquickpositioners.cpp
+++ b/src/quick/items/qquickpositioners.cpp
@@ -72,6 +72,60 @@ void QQuickBasePositionerPrivate::unwatchChanges(QQuickItem* other)
     otherPrivate->removeItemChangeListener(this, watchedChanges);
 }
 
+
+QQuickBasePositioner::PositionedItem::PositionedItem(QQuickItem *i)
+    : item(i)
+    , transitionableItem(0)
+    , index(-1)
+    , isNew(false)
+    , isVisible(true)
+{
+}
+
+QQuickBasePositioner::PositionedItem::~PositionedItem()
+{
+    delete transitionableItem;
+}
+
+qreal QQuickBasePositioner::PositionedItem::itemX() const
+{
+    return transitionableItem ? transitionableItem->itemX() : item->x();
+}
+
+qreal QQuickBasePositioner::PositionedItem::itemY() const
+{
+    return transitionableItem ? transitionableItem->itemY() : item->y();
+}
+
+void QQuickBasePositioner::PositionedItem::moveTo(const QPointF &pos)
+{
+    if (transitionableItem)
+        transitionableItem->moveTo(pos);
+    else
+        item->setPos(pos);
+}
+
+void QQuickBasePositioner::PositionedItem::transitionNextReposition(QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, bool asTarget)
+{
+    if (!transitioner)
+        return;
+    if (!transitionableItem)
+        transitionableItem = new QQuickItemViewTransitionableItem(item);
+    transitioner->transitionNextReposition(transitionableItem, type, asTarget);
+}
+
+bool QQuickBasePositioner::PositionedItem::prepareTransition(QQuickItemViewTransitioner *transitioner, const QRectF &viewBounds)
+{
+    return transitionableItem ? transitionableItem->prepareTransition(transitioner, index, viewBounds) : false;
+}
+
+void QQuickBasePositioner::PositionedItem::startTransition(QQuickItemViewTransitioner *transitioner)
+{
+    if (transitionableItem)
+        transitionableItem->startTransition(transitioner, index);
+}
+
+
 QQuickBasePositioner::QQuickBasePositioner(PositionerType at, QQuickItem *parent)
     : QQuickImplicitSizeItem(*(new QQuickBasePositionerPrivate), parent)
 {
@@ -114,7 +168,8 @@ QQuickBasePositioner::~QQuickBasePositioner()
         d->unwatchChanges(positionedItems.at(i).item);
     for (int i = 0; i < unpositionedItems.count(); ++i)
         d->unwatchChanges(unpositionedItems.at(i).item);
-    positionedItems.clear();
+    clearPositionedItems(&positionedItems);
+    clearPositionedItems(&unpositionedItems);
 }
 
 void QQuickBasePositioner::updatePolish()
@@ -194,10 +249,10 @@ void QQuickBasePositioner::itemChange(ItemChange change, const ItemChangeData &v
         int idx = positionedItems.find(posItem);
         if (idx >= 0) {
             d->unwatchChanges(child);
-            positionedItems.remove(idx);
+            removePositionedItem(&positionedItems, idx);
         } else if ((idx = unpositionedItems.find(posItem)) >= 0) {
             d->unwatchChanges(child);
-            unpositionedItems.remove(idx);
+            removePositionedItem(&unpositionedItems, idx);
         }
         d->setPositioningDirty();
     }
@@ -246,8 +301,7 @@ void QQuickBasePositioner::prePositioning()
                     if (addedIndex < 0)
                         addedIndex = posItem.index;
                     PositionedItem *theItem = &positionedItems[positionedItems.count()-1];
-                    d->transitioner->transitionNextReposition(theItem,
-                            QQuickItemViewTransitioner::AddTransition, true);
+                    theItem->transitionNextReposition(d->transitioner, QQuickItemViewTransitioner::AddTransition, true);
                 }
             }
         } else {
@@ -268,8 +322,7 @@ void QQuickBasePositioner::prePositioning()
                 if (d->transitioner) {
                     if (addedIndex < 0)
                         addedIndex = item->index;
-                    d->transitioner->transitionNextReposition(&positionedItems[positionedItems.count()-1],
-                            QQuickItemViewTransitioner::AddTransition, true);
+                    positionedItems[positionedItems.count()-1].transitionNextReposition(d->transitioner, QQuickItemViewTransitioner::AddTransition, true);
                 }
             } else {
                 item->isNew = false;
@@ -283,11 +336,11 @@ void QQuickBasePositioner::prePositioning()
         for (int i=0; i<positionedItems.count(); i++) {
             if (!positionedItems[i].isNew) {
                 if (addedIndex >= 0) {
-                    d->transitioner->transitionNextReposition(&positionedItems[i], QQuickItemViewTransitioner::AddTransition, false);
+                    positionedItems[i].transitionNextReposition(d->transitioner, 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);
+                    positionedItems[i].transitionNextReposition(d->transitioner, QQuickItemViewTransitioner::MoveTransition, false);
                 }
             }
         }
@@ -342,6 +395,24 @@ void QQuickBasePositioner::positionItemY(qreal y, PositionedItem *target)
     }
 }
 
+/*
+  Since PositionedItem values are stored by value, their internal transitionableItem pointers
+  must be cleaned up when a PositionedItem is removed from a QPODVector, otherwise the pointer
+  is never deleted since QPODVector doesn't invoke the destructor.
+  */
+void QQuickBasePositioner::removePositionedItem(QPODVector<PositionedItem,8> *items, int index)
+{
+    Q_ASSERT(index >= 0 && index < items->count());
+    delete items->at(index).transitionableItem;
+    items->remove(index);
+}
+void QQuickBasePositioner::clearPositionedItems(QPODVector<PositionedItem,8> *items)
+{
+    for (int i=0; i<items->count(); i++)
+        delete items->at(i).transitionableItem;
+    items->clear();
+}
+
 QQuickPositionerAttached *QQuickBasePositioner::qmlAttachedProperties(QObject *obj)
 {
     return new QQuickPositionerAttached(obj);
diff --git a/src/quick/items/qquickpositioners_p.h b/src/quick/items/qquickpositioners_p.h
index 8921bfa39b..c13d9975af 100644
--- a/src/quick/items/qquickpositioners_p.h
+++ b/src/quick/items/qquickpositioners_p.h
@@ -133,22 +133,39 @@ protected:
     virtual void doPositioning(QSizeF *contentSize)=0;
     virtual void reportConflictingAnchors()=0;
 
-    class PositionedItem : public QQuickViewItem
+    class PositionedItem
     {
     public :
-        PositionedItem(QQuickItem *i) : QQuickViewItem(i), isNew(false), isVisible(true) {}
+        PositionedItem(QQuickItem *i);
+        ~PositionedItem();
         bool operator==(const PositionedItem &other) const { return other.item == item; }
 
+        qreal itemX() const;
+        qreal itemY() const;
+
+        void moveTo(const QPointF &pos);
+
+        void transitionNextReposition(QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, bool asTarget);
+        bool prepareTransition(QQuickItemViewTransitioner *transitioner, const QRectF &viewBounds);
+        void startTransition(QQuickItemViewTransitioner *transitioner);
+
+        QQuickItem *item;
+        QQuickItemViewTransitionableItem *transitionableItem;
+        int index;
         bool isNew;
         bool isVisible;
     };
 
     QPODVector<PositionedItem,8> positionedItems;
     QPODVector<PositionedItem,8> unpositionedItems;//Still 'in' the positioner, just not positioned
+
     void positionItem(qreal x, qreal y, PositionedItem *target);
     void positionItemX(qreal, PositionedItem *target);
     void positionItemY(qreal, PositionedItem *target);
 
+    void removePositionedItem(QPODVector<PositionedItem,8> *items, int index);
+    void clearPositionedItems(QPODVector<PositionedItem,8> *items);
+
 private:
     Q_DISABLE_COPY(QQuickBasePositioner)
     Q_DECLARE_PRIVATE(QQuickBasePositioner)
diff --git a/src/quick/items/qquickpositioners_p_p.h b/src/quick/items/qquickpositioners_p_p.h
index 21fa67574b..8c6bf7f101 100644
--- a/src/quick/items/qquickpositioners_p_p.h
+++ b/src/quick/items/qquickpositioners_p_p.h
@@ -139,7 +139,9 @@ public:
     void itemDestroyed(QQuickItem *item)
     {
         Q_Q(QQuickBasePositioner);
-        q->positionedItems.removeOne(QQuickBasePositioner::PositionedItem(item));
+        int index = q->positionedItems.find(QQuickBasePositioner::PositionedItem(item));
+        if (index >= 0)
+            q->removePositionedItem(&q->positionedItems, index);
     }
 
     static Qt::LayoutDirection getLayoutDirection(const QQuickBasePositioner *positioner)
diff --git a/src/quick/items/qquicktextedit.cpp b/src/quick/items/qquicktextedit.cpp
index a9bff73bd9..3db5f5a7a3 100644
--- a/src/quick/items/qquicktextedit.cpp
+++ b/src/quick/items/qquicktextedit.cpp
@@ -1626,7 +1626,7 @@ QSGNode *QQuickTextEdit::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *
         QRectF bounds = boundingRect();
 
         node->addTextDocument(bounds.topLeft(), d->document, d->color, QQuickText::Normal, QColor(),
-                              d->selectionColor, d->selectedTextColor, selectionStart(),
+                              QColor(), d->selectionColor, d->selectedTextColor, selectionStart(),
                               selectionEnd() - 1);  // selectionEnd() returns first char after
                                                     // selection