Rewrite Positioners

Cleans up code, reduces memory footprint and increases performance.
Largely by removing large chunks of functionality that we don't
actually use.

Also now that we are clearer on what the new positioner transitions are
(how the item moves it's position when it is positioned by a positioner)
a remove transition makes no sense and is discarded, and the auto tests
have been updated as add transitions are slightly different.

3 files changed, 102 insertions, 314 deletions

diff --git a/src/declarative/graphicsitems/qmlgraphicspositioners.cpp b/src/declarative/graphicsitems/qmlgraphicspositioners.cpp
index db0cc7c..101fae2 100644
--- a/src/declarative/graphicsitems/qmlgraphicspositioners.cpp
+++ b/src/declarative/graphicsitems/qmlgraphicspositioners.cpp
@@ -66,8 +66,10 @@ void QmlGraphicsBasePositionerPrivate::watchChanges(QmlGraphicsItem *other)
 
     QmlGraphicsItemPrivate *otherPrivate = static_cast<QmlGraphicsItemPrivate*>(QGraphicsItemPrivate::get(other));
 
-    otherPrivate->connectToHeightChanged(q, prePosIdx);
-    otherPrivate->connectToWidthChanged(q, prePosIdx);
+    if(type == QmlGraphicsBasePositioner::Vertical || type == QmlGraphicsBasePositioner::Both)
+        otherPrivate->connectToHeightChanged(q, prePosIdx);
+    if(type == QmlGraphicsBasePositioner::Horizontal || type == QmlGraphicsBasePositioner::Both)
+        otherPrivate->connectToWidthChanged(q, prePosIdx);
 
     otherPrivate->registerSiblingOrderNotification(this);
     watched << other;
@@ -77,11 +79,14 @@ void QmlGraphicsBasePositionerPrivate::unwatchChanges(QmlGraphicsItem* other)
 {
     Q_Q(QmlGraphicsBasePositioner);
     QmlGraphicsItemPrivate *otherPrivate = static_cast<QmlGraphicsItemPrivate*>(QGraphicsItemPrivate::get(other));
-    bool stillAlive = false; //Use the return from disconnect to see if it was deleted or just reparented
+    bool stillAlive = false; //Use the returns from disconnect to see if it was deleted or just reparented
     stillAlive |= QMetaObject::disconnect(other, visibleIdx, q, prePosIdx);
     stillAlive |= QMetaObject::disconnect(other, opacityIdx, q, prePosIdx);
-    stillAlive |= otherPrivate->disconnectFromHeightChanged(q, prePosIdx);
-    stillAlive |= otherPrivate->disconnectFromWidthChanged(q, prePosIdx);
+    //Is disconnect expensive enough to be worth this check?
+    if(type == QmlGraphicsBasePositioner::Vertical || type == QmlGraphicsBasePositioner::Both)
+        stillAlive |= otherPrivate->disconnectFromHeightChanged(q, prePosIdx);
+    if(type == QmlGraphicsBasePositioner::Horizontal || type == QmlGraphicsBasePositioner::Both)
+        stillAlive |= otherPrivate->disconnectFromWidthChanged(q, prePosIdx);
 
     if(stillAlive)
         otherPrivate->unregisterSiblingOrderNotification(this);
@@ -96,24 +101,24 @@ void QmlGraphicsBasePositionerPrivate::unwatchChanges(QmlGraphicsItem* other)
 
     To create a QmlGraphics Positioner, simply subclass QmlGraphicsBasePositioner and implement
     doLayout(), which is automatically called when the layout might need
-    updating.
+    updating. In doLayout() use the setX and setY functions from QmlBasePositioner, and the
+    base class will apply the positions along with the appropriate transitions. The items to
+    position are provided in order as the protected member positionedItems.
 
-    It is strongly recommended that in your implementation of doLayout()
-    that you use the move, remove and add transitions when those conditions
-    arise. You can use the applyAdd, applyMove and applyRemove functions
-    to do this easily.
+    You also need to set a PositionerType, to declare whether you are positioning the x, y or both
+    for the child items. Depending on the chosen type, only x or y changes will be applied.
 
-    Note also that the subclass is responsible for adding the
+    Note that the subclass is responsible for adding the
     spacing in between items.
 */
-QmlGraphicsBasePositioner::QmlGraphicsBasePositioner(AutoUpdateType at, QmlGraphicsItem *parent)
+QmlGraphicsBasePositioner::QmlGraphicsBasePositioner(PositionerType at, QmlGraphicsItem *parent)
     : QmlGraphicsItem(*(new QmlGraphicsBasePositionerPrivate), parent)
 {
     Q_D(QmlGraphicsBasePositioner);
     d->init(at);
 }
 
-QmlGraphicsBasePositioner::QmlGraphicsBasePositioner(QmlGraphicsBasePositionerPrivate &dd, AutoUpdateType at, QmlGraphicsItem *parent)
+QmlGraphicsBasePositioner::QmlGraphicsBasePositioner(QmlGraphicsBasePositionerPrivate &dd, PositionerType at, QmlGraphicsItem *parent)
     : QmlGraphicsItem(dd, parent)
 {
     Q_D(QmlGraphicsBasePositioner);
@@ -123,15 +128,15 @@ QmlGraphicsBasePositioner::QmlGraphicsBasePositioner(QmlGraphicsBasePositionerPr
 int QmlGraphicsBasePositioner::spacing() const
 {
     Q_D(const QmlGraphicsBasePositioner);
-    return d->_spacing;
+    return d->spacing;
 }
 
 void QmlGraphicsBasePositioner::setSpacing(int s)
 {
     Q_D(QmlGraphicsBasePositioner);
-    if (s==d->_spacing)
+    if (s==d->spacing)
         return;
-    d->_spacing = s;
+    d->spacing = s;
     prePositioning();
     emit spacingChanged();
 }
@@ -160,18 +165,6 @@ void QmlGraphicsBasePositioner::setAdd(QmlTransition *add)
     d->addTransition = add;
 }
 
-QmlTransition *QmlGraphicsBasePositioner::remove() const
-{
-    Q_D(const QmlGraphicsBasePositioner);
-    return d->removeTransition;
-}
-
-void QmlGraphicsBasePositioner::setRemove(QmlTransition *remove)
-{
-    Q_D(QmlGraphicsBasePositioner);
-    d->removeTransition = remove;
-}
-
 void QmlGraphicsBasePositioner::componentComplete()
 {
     QmlGraphicsItem::componentComplete();
@@ -192,114 +185,49 @@ QVariant QmlGraphicsBasePositioner::itemChange(GraphicsItemChange change,
     return QmlGraphicsItem::itemChange(change, value);
 }
 
-bool QmlGraphicsBasePositioner::event(QEvent *e)
-{
-    Q_D(QmlGraphicsBasePositioner);
-    if (e->type() == QEvent::User) {
-        d->_ep = false;
-        d->_stableItems += d->_newItems;
-        d->_leavingItems.clear();
-        d->_newItems.clear();
-        return true;
-    }
-    return QmlGraphicsItem::event(e);
-}
-
-/*!
-  Items that have just been added to the positioner. This includes invisible items
-  that have turned visible.
-*/
-QSet<QmlGraphicsItem *>* QmlGraphicsBasePositioner::newItems()
-{
-    Q_D(QmlGraphicsBasePositioner);
-    return &d->_newItems;
-}
-
-/*!
-  Items that are visible in the positioner, not including ones that have just been added.
-*/
-QSet<QmlGraphicsItem *>* QmlGraphicsBasePositioner::items()
-{
-    Q_D(QmlGraphicsBasePositioner);
-    return &d->_stableItems;
-}
-
-/*!
-  Items that have just left the positioner. This includes visible items
-  that have turned invisible.
-*/
-QSet<QmlGraphicsItem *>* QmlGraphicsBasePositioner::leavingItems()
-{
-    Q_D(QmlGraphicsBasePositioner);
-    return &d->_leavingItems;
-}
-
 void QmlGraphicsBasePositioner::prePositioning()
 {
     Q_D(QmlGraphicsBasePositioner);
-    if (!isComponentComplete() || d->_movingItem)
+    if (!isComponentComplete())
         return;
 
     d->queuedPositioning = false;
-    if (!d->_ep) {
-        d->_ep = true;
-        QCoreApplication::postEvent(this, new QEvent(QEvent::User));
-    }
     //Need to order children by creation order modified by stacking order
-    //###can we avoid using the QGraphicsItemPrivate?
     QList<QGraphicsItem *> children = childItems();
     qSort(children.begin(), children.end(), d->insertionOrder);
     positionedItems.clear();
+    d->newItems.clear();
 
-    if (d->_items.isEmpty()) {
-        for (int ii = 0; ii < children.count(); ++ii) {
-            QmlGraphicsItem *child = qobject_cast<QmlGraphicsItem *>(children.at(ii));
-            if (!child)
-                continue;
+    for (int ii = 0; ii < children.count(); ++ii) {
+        QmlGraphicsItem *child = qobject_cast<QmlGraphicsItem *>(children.at(ii));
+        if (!child)
+            continue;
+        if(!d->watched.contains(child))
             d->watchChanges(child);
-            d->_items += child;
-            if (child->opacity() != 0.0)
-                d->_newItems += child;
-            positionedItems << child;
-        }
-    } else {
-        QSet<QmlGraphicsItem *> allItems;
-        allItems.reserve(children.count());
-        for (int ii = 0; ii < children.count(); ++ii) {
-            QmlGraphicsItem *child = qobject_cast<QmlGraphicsItem *>(children.at(ii));
-            if (!child)
-                continue;
-            if (!d->_items.contains(child)){
-                d->watchChanges(child);
-                d->_items += child;
-            }
-            if (child->opacity() == 0.0){
-                if (d->_stableItems.contains(child)){
-                    d->_leavingItems += child;
-                    d->_stableItems -= child;
-                }
-            }else if (!d->_stableItems.contains(child)){
-                d->_newItems+=child;
-            }
-            allItems += child;
-            positionedItems << child;
+        if(child->opacity() <= 0.0 || !child->isVisible())
+            continue;
+        if (!d->items.contains(child)){
+            d->items += child;
+            d->newItems += child;
         }
-        if (d->_items.count() != allItems.count()) {
-            QSet<QmlGraphicsItem *> deletedItems = d->_items - allItems;
-            foreach(QmlGraphicsItem *child, deletedItems){
-                d->unwatchChanges(child);
-                d->_items -= child;
-            }
+        positionedItems << child;
+    }
+    if(d->items.count() > positionedItems.count()){
+        //Assumed that (aside from init) every add/remove triggers this check
+        //thus the above check will be triggered every time an item is removed
+        QSet<QmlGraphicsItem *> deletedItems = d->items - positionedItems.toSet();
+        foreach(QmlGraphicsItem *child, deletedItems){
+            d->unwatchChanges(child);
+            d->items -= child;
         }
     }
-    d->_animated.clear();
     doPositioning();
-    finishApplyTransitions();
+    if(d->addTransition || d->moveTransition)
+        finishApplyTransitions();
     //Set implicit size to the size of its children
-    //###To keep this valid, do we need to update on pos change as well?
     qreal h = 0.0f;
     qreal w = 0.0f;
-    foreach(QmlGraphicsItem *child, d->_items){
+    foreach(QmlGraphicsItem *child, d->items){
         if(!child->isVisible() || child->opacity() <= 0)
             continue;
         h = qMax(h, child->y() + child->height());
@@ -309,69 +237,45 @@ void QmlGraphicsBasePositioner::prePositioning()
     setImplicitWidth(w);
 }
 
-void QmlGraphicsBasePositioner::applyTransition(const QList<QPair<QString, QVariant> >& changes, QmlGraphicsItem* target, QmlStateOperation::ActionList &actions)
+void QmlGraphicsBasePositioner::positionX(int x, QmlGraphicsItem* target)
 {
     Q_D(QmlGraphicsBasePositioner);
-    if (!target)
-        return;
-
-    for (int ii=0; ii<changes.size(); ++ii){
-
-        QVariant val = changes[ii].second;
-        actions << Action(target, changes[ii].first, val);
-
+    if(d->type == Horizontal || d->type == Both){
+        if(!d->addTransition && !d->moveTransition){
+            target->setX(x);
+        }else{
+            if(d->newItems.contains(target))
+                d->addActions << Action(target, QLatin1String("x"), QVariant(x));
+            else
+                d->moveActions << Action(target, QLatin1String("x"), QVariant(x));
+        }
     }
+}
 
-    d->_animated << target;
+void QmlGraphicsBasePositioner::positionY(int y, QmlGraphicsItem* target)
+{
+    Q_D(QmlGraphicsBasePositioner);
+    if(d->type == Vertical || d->type == Both){
+        if(!d->addTransition && !d->moveTransition){
+            target->setY(y);
+        }else{
+            if(d->newItems.contains(target))
+                d->addActions << Action(target, QLatin1String("y"), QVariant(y));
+            else
+                d->moveActions << Action(target, QLatin1String("y"), QVariant(y));
+        }
+    }
 }
 
 void QmlGraphicsBasePositioner::finishApplyTransitions()
 {
     Q_D(QmlGraphicsBasePositioner);
     // Note that if a transition is not set the transition manager will
-    // apply the changes directly, in the case someone uses applyAdd/Move/Remove
-    // without testing add()/move()/remove().
+    // 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->removeTransitionManager.transition(d->removeActions, d->removeTransition);
     d->addActions.clear();
     d->moveActions.clear();
-    d->removeActions.clear();
-}
-void QmlGraphicsBasePositioner::setMovingItem(QmlGraphicsItem *i)
-{
-    Q_D(QmlGraphicsBasePositioner);
-    d->_movingItem = i;
-}
-
-/*!
-  Applies the positioner's add transition to the \a target item.\a changes is a list of property,value
-  pairs which will be changed on the target using the add transition.
-*/
-void QmlGraphicsBasePositioner::applyAdd(const QList<QPair<QString, QVariant> >& changes, QmlGraphicsItem* target)
-{
-    Q_D(QmlGraphicsBasePositioner);
-    applyTransition(changes,target, d->addActions);
-}
-
-/*!
-  Applies the positioner's move transition to the \a target.\a changes is a list of property,value pairs
-  which will be changed on the target using the move transition.
-*/
-void QmlGraphicsBasePositioner::applyMove(const QList<QPair<QString, QVariant> >& changes, QmlGraphicsItem* target)
-{
-    Q_D(QmlGraphicsBasePositioner);
-    applyTransition(changes,target, d->moveActions);
-}
-
-/*!
-  Applies the positioner's remove transition to the \a target item.\a changes is a list of
-  property,value pairs which will be changed on the target using the remove transition.
-*/
-void QmlGraphicsBasePositioner::applyRemove(const QList<QPair<QString, QVariant> >& changes, QmlGraphicsItem* target)
-{
-    Q_D(QmlGraphicsBasePositioner);
-    applyTransition(changes,target, d->removeActions);
 }
 
 QML_DEFINE_TYPE(Qt,4,6,Column,QmlGraphicsColumn)
@@ -425,14 +329,6 @@ Column {
 
 */
 /*!
-    \qmlproperty Transition Column::remove
-    This property holds the transition to apply when removing an item from the positioner. The transition is only applied to the removed items.
-    Positioner transitions will only affect the position (x,y) of items.
-
-    Removed can mean that either the object has been deleted or reparented, and thus is now longer a child of the positioner, or that the object has had its opacity set to zero, and thus is no longer visible.
-
-*/
-/*!
     \qmlproperty Transition 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.
@@ -499,36 +395,14 @@ void QmlGraphicsColumn::doPositioning()
 {
     int voffset = 0;
 
-    foreach(QmlGraphicsItem* item, *leavingItems()){
-        if (remove()){
-            QList<QPair<QString,QVariant> > changes;
-            applyRemove(changes, item);
-        }
-    }
-
-    QList<QmlGraphicsItem *> children = positionedItems;
-    for (int ii = 0; ii < children.count(); ++ii) {
-        QmlGraphicsItem *child = children.at(ii);
+    for (int ii = 0; ii < positionedItems.count(); ++ii) {
+        QmlGraphicsItem *child = positionedItems.at(ii);
         if (!child || isInvisible(child))
             continue;
 
-        bool needMove = (child->y() != voffset || child->x());
-
-        if (needMove && move() && items()->contains(child)) {
-            QList<QPair<QString, QVariant> > changes;
-            changes << qMakePair(QString(QLatin1String("y")),QVariant(voffset));
-            changes << qMakePair(QString(QLatin1String("x")),QVariant(0));
-            applyMove(changes,child);
-        } else if (add() && !items()->contains(child)) {
-            QList<QPair<QString, QVariant> > changes;
-            changes << qMakePair(QString(QLatin1String("y")),QVariant(voffset));
-            changes << qMakePair(QString(QLatin1String("x")),QVariant(0));
-            applyAdd(changes,child);
-        } else if (needMove) {
-            setMovingItem(child);
-            child->setY(voffset);
-            setMovingItem(0);
-        }
+        if(child->y() != voffset)
+            positionY(voffset, child);
+
         voffset += child->height();
         voffset += spacing();
     }
@@ -567,18 +441,6 @@ Row {
 
 */
 /*!
-    \qmlproperty Transition Row::remove
-    This property holds the transition to apply when removing an item from the positioner.
-    The transition will only be applied to the removed item(s).
-    Positioner transitions will only affect the position (x,y) of items.
-
-    Removed can mean that either the object has been deleted or reparented, and thus is now longer a child of the positioner, or that the object has had its opacity set to zero, and thus is no longer visible.
-
-    Note that if the item counts as removed because its opacity is zero it will not be visible during the transition unless you set the opacity in the transition, like in the below example.
-
-
-*/
-/*!
     \qmlproperty Transition Row::add
     This property holds the transition to apply when adding an item to the positioner.
     The transition will only be applied to the added item(s).
@@ -638,35 +500,14 @@ void QmlGraphicsRow::doPositioning()
 {
     int hoffset = 0;
 
-    foreach(QmlGraphicsItem* item, *leavingItems()){
-        if (remove()){
-            QList<QPair<QString,QVariant> > changes;
-            applyRemove(changes, item);
-        }
-    }
-    QList<QmlGraphicsItem *> children = positionedItems;
-    for (int ii = 0; ii < children.count(); ++ii) {
-        QmlGraphicsItem *child = children.at(ii);
+    for (int ii = 0; ii < positionedItems.count(); ++ii) {
+        QmlGraphicsItem *child = positionedItems.at(ii);
         if (!child || isInvisible(child))
             continue;
 
-        bool needMove = (child->x() != hoffset || child->y());
-
-        if (needMove && move() && items()->contains(child)) {
-            QList<QPair<QString, QVariant> > changes;
-            changes << qMakePair(QString(QLatin1String("x")),QVariant(hoffset));
-            changes << qMakePair(QString(QLatin1String("y")),QVariant(0));
-            applyMove(changes,child);
-        } else if (add() && !items()->contains(child)) {
-            QList<QPair<QString, QVariant> > changes;
-            changes << qMakePair(QString(QLatin1String("x")),QVariant(hoffset));
-            changes << qMakePair(QString(QLatin1String("y")),QVariant(0));
-            applyAdd(changes,child);
-        } else if (needMove) {
-            setMovingItem(child);
-            child->setX(hoffset);
-            setMovingItem(0);
-        }
+        if(child->x() != hoffset)
+            positionX(hoffset, child);
+
         hoffset += child->width();
         hoffset += spacing();
     }
@@ -720,19 +561,6 @@ Grid {
   positioner may exhibit strange behaviour.
 */
 /*!
-    \qmlproperty Transition Grid::remove
-    This property holds the transition to apply when removing an item from the positioner.
-    The transition is only applied to the removed item(s).
-    Positioner transitions will only affect the position (x,y) of items.
-
-    Removed can mean that either the object has been deleted or
-    reparented, and thus is now longer a child of the positioner, or that
-    the object has had its opacity set to zero, and thus is no longer
-    visible.
-
-
-*/
-/*!
     \qmlproperty Transition Grid::add
     This property holds the transition to apply when adding an item to the positioner.
     The transition is only applied to the added item(s).
@@ -815,7 +643,7 @@ QmlGraphicsGrid::QmlGraphicsGrid(QmlGraphicsItem *parent) :
 void QmlGraphicsGrid::doPositioning()
 {
     int c=_columns,r=_rows;//Actual number of rows/columns
-    int numVisible = items()->size() + newItems()->size();
+    int numVisible = positionedItems.count();
     if (_columns==-1 && _rows==-1){
         c = 4;
         r = (numVisible+3)/4;
@@ -828,7 +656,6 @@ void QmlGraphicsGrid::doPositioning()
     QList<int> maxColWidth;
     QList<int> maxRowHeight;
     int childIndex =0;
-    QList<QmlGraphicsItem *> children = positionedItems;
     for (int i=0; i<r; i++){
         for (int j=0; j<c; j++){
             if (j==0)
@@ -836,9 +663,9 @@ void QmlGraphicsGrid::doPositioning()
             if (i==0)
                 maxColWidth << 0;
 
-            if (childIndex == children.count())
+            if (childIndex == positionedItems.count())
                 continue;
-            QmlGraphicsItem *child = children.at(childIndex++);
+            QmlGraphicsItem *child = positionedItems.at(childIndex++);
             if (!child || isInvisible(child))
                 continue;
             if (child->width() > maxColWidth[j])
@@ -852,29 +679,12 @@ void QmlGraphicsGrid::doPositioning()
     int yoffset=0;
     int curRow =0;
     int curCol =0;
-    foreach(QmlGraphicsItem* item, *leavingItems()){
-        if (remove()){
-            QList<QPair<QString,QVariant> > changes;
-            applyRemove(changes, item);
-        }
-    }
-    foreach(QmlGraphicsItem* child, children){
+    foreach(QmlGraphicsItem* child, positionedItems){
         if (!child || isInvisible(child))
             continue;
-        bool needMove = (child->x()!=xoffset)||(child->y()!=yoffset);
-        QList<QPair<QString, QVariant> > changes;
-        changes << qMakePair(QString(QLatin1String("x")),QVariant(xoffset));
-        changes << qMakePair(QString(QLatin1String("y")),QVariant(yoffset));
-        if (newItems()->contains(child) && add()) {
-            applyAdd(changes,child);
-        } else if (needMove) {
-            if (move()){
-                applyMove(changes,child);
-            }else{
-                setMovingItem(child);
-                child->setPos(QPointF(xoffset, yoffset));
-                setMovingItem(0);
-            }
+        if((child->x()!=xoffset)||(child->y()!=yoffset)){
+            positionX(xoffset, child);
+            positionY(yoffset, child);
         }
         xoffset+=maxColWidth[curCol]+spacing();
         curCol++;
diff --git a/src/declarative/graphicsitems/qmlgraphicspositioners_p.h b/src/declarative/graphicsitems/qmlgraphicspositioners_p.h
index 03e0f41..bc8315e 100644
--- a/src/declarative/graphicsitems/qmlgraphicspositioners_p.h
+++ b/src/declarative/graphicsitems/qmlgraphicspositioners_p.h
@@ -63,10 +63,9 @@ class Q_DECLARATIVE_EXPORT QmlGraphicsBasePositioner : public QmlGraphicsItem
     Q_PROPERTY(int spacing READ spacing WRITE setSpacing NOTIFY spacingChanged)
     Q_PROPERTY(QmlTransition *move READ move WRITE setMove)
     Q_PROPERTY(QmlTransition *add READ add WRITE setAdd)
-    Q_PROPERTY(QmlTransition *remove READ remove WRITE setRemove)
 public:
-    enum AutoUpdateType { None = 0x0, Horizontal = 0x1, Vertical = 0x2, Both = 0x3 };
-    QmlGraphicsBasePositioner(AutoUpdateType, QmlGraphicsItem *parent);
+    enum PositionerType { None = 0x0, Horizontal = 0x1, Vertical = 0x2, Both = 0x3 };
+    QmlGraphicsBasePositioner(PositionerType, QmlGraphicsItem *parent);
 
     int spacing() const;
     void setSpacing(int);
@@ -77,23 +76,13 @@ public:
     QmlTransition *add() const;
     void setAdd(QmlTransition *);
 
-    QmlTransition *remove() const;
-    void setRemove(QmlTransition *);
-
 protected:
+    QmlGraphicsBasePositioner(QmlGraphicsBasePositionerPrivate &dd, PositionerType at, QmlGraphicsItem *parent);
     virtual void componentComplete();
     virtual QVariant itemChange(GraphicsItemChange, const QVariant &);
-    virtual bool event(QEvent *);
-    QSet<QmlGraphicsItem *>* newItems();
-    QSet<QmlGraphicsItem *>* leavingItems();
-    QSet<QmlGraphicsItem *>* items();
-    void applyAdd(const QList<QPair<QString, QVariant> >& changes, QmlGraphicsItem* target);
-    void applyMove(const QList<QPair<QString, QVariant> >& changes, QmlGraphicsItem* target);
-    void applyRemove(const QList<QPair<QString, QVariant> >& changes, QmlGraphicsItem* target);
     void finishApplyTransitions();
 
 Q_SIGNALS:
-    void layoutItemChanged();
     void spacingChanged();
 
 protected Q_SLOTS:
@@ -103,13 +92,11 @@ private Q_SLOTS:
     void prePositioning();
 
 protected:
-    QmlGraphicsBasePositioner(QmlGraphicsBasePositionerPrivate &dd, AutoUpdateType at, QmlGraphicsItem *parent);
-    void setMovingItem(QmlGraphicsItem *);
     QList<QmlGraphicsItem *> positionedItems;
+    void positionX(int,QmlGraphicsItem* target);
+    void positionY(int,QmlGraphicsItem* target);
 
 private:
-    void applyTransition(const QList<QPair<QString, QVariant> >& changes, QmlGraphicsItem* target,
-            QmlStateOperation::ActionList &actions);
     Q_DISABLE_COPY(QmlGraphicsBasePositioner)
     Q_DECLARE_PRIVATE_D(QGraphicsItem::d_ptr.data(), QmlGraphicsBasePositioner)
 };
diff --git a/src/declarative/graphicsitems/qmlgraphicspositioners_p_p.h b/src/declarative/graphicsitems/qmlgraphicspositioners_p_p.h
index b079f6a..db795ec 100644
--- a/src/declarative/graphicsitems/qmlgraphicspositioners_p_p.h
+++ b/src/declarative/graphicsitems/qmlgraphicspositioners_p_p.h
@@ -72,9 +72,8 @@ class QmlGraphicsBasePositionerPrivate : public QmlGraphicsItemPrivate
 
 public:
     QmlGraphicsBasePositionerPrivate()
-        : _ep(false), _componentComplete(false), _spacing(0),
-        aut(QmlGraphicsBasePositioner::None), moveTransition(0), addTransition(0),
-        removeTransition(0), _movingItem(0), queuedPositioning(false)
+        : spacing(0), type(QmlGraphicsBasePositioner::None), moveTransition(0), addTransition(0),
+          queuedPositioning(false)
     {
     }
 
@@ -85,9 +84,9 @@ public:
             unwatchChanges(other);//Need to deregister from a list in QmlGI Private
     }
 
-    void init(QmlGraphicsBasePositioner::AutoUpdateType at)
+    void init(QmlGraphicsBasePositioner::PositionerType at)
     {
-        aut = at;
+        type = at;
         if (prePosIdx == -1) {
             prePosIdx = QmlGraphicsBasePositioner::staticMetaObject.indexOfSlot("prePositioning()");
             visibleIdx = QmlGraphicsItem::staticMetaObject.indexOfSignal("visibleChanged()");
@@ -95,29 +94,20 @@ public:
         }
     }
 
-    bool _ep;
-    bool _componentComplete;
-    int _spacing;
-    QmlGraphicsBasePositioner::AutoUpdateType aut;
+    int spacing;
+    QmlGraphicsBasePositioner::PositionerType type;
     QmlTransition *moveTransition;
     QmlTransition *addTransition;
-    QmlTransition *removeTransition;
-    QSet<QmlGraphicsItem *> _items;
-    QSet<QmlGraphicsItem *> _leavingItems;
-    QSet<QmlGraphicsItem *> _stableItems;
-    QSet<QmlGraphicsItem *> _newItems;
-    QSet<QmlGraphicsItem *> _animated;
+    QSet<QmlGraphicsItem *> items;
+    QSet<QmlGraphicsItem *> newItems;
     QmlStateOperation::ActionList addActions;
     QmlStateOperation::ActionList moveActions;
-    QmlStateOperation::ActionList removeActions;
     QmlTransitionManager addTransitionManager;
     QmlTransitionManager moveTransitionManager;
-    QmlTransitionManager removeTransitionManager;
-    QmlGraphicsItem *_movingItem;
 
     void watchChanges(QmlGraphicsItem *other);
     void unwatchChanges(QmlGraphicsItem* other);
-    QList<QGuard<QmlGraphicsItem> > watched;
+    QList<QGuard<QmlGraphicsItem> > watched;//Can't have QSet and QGuard at the same time?
     bool queuedPositioning;
 
     static int prePosIdx;
@@ -130,6 +120,7 @@ public:
         Q_UNUSED(other);
         if(!queuedPositioning){
             //Delay is due to many children often being reordered at once
+            //And we only want to reposition them all once
             QTimer::singleShot(0,q,SLOT(prePositioning()));
             queuedPositioning = true;
         }