Replace QmlList* and QList* support with a single QmlListProperty type

As a value type QmlListProperty doesn't consume any memory in the object.
It also has a companion QmlListReference class that is part of the public
API for C++ developers to interact with that also manages memory issues
that existed with previous solutions (if the containing QObject was
destroyed it left a dangling pointer).

64 files changed, 1123 insertions, 1432 deletions

diff --git a/src/declarative/graphicsitems/qmlgraphicsflickable.cpp b/src/declarative/graphicsitems/qmlgraphicsflickable.cpp
index bfee8d4..e92fea4 100644
--- a/src/declarative/graphicsitems/qmlgraphicsflickable.cpp
+++ b/src/declarative/graphicsitems/qmlgraphicsflickable.cpp
@@ -945,51 +945,22 @@ void QmlGraphicsFlickable::cancelFlick()
     movementEnding();
 }
 
-void QmlGraphicsFlickablePrivate::data_removeAt(int)
+void QmlGraphicsFlickablePrivate::data_append(QmlListProperty<QObject> *prop, QObject *o)
 {
-    // ###
-}
-
-int QmlGraphicsFlickablePrivate::data_count() const
-{
-    // ###
-    return 0;
-}
-
-void QmlGraphicsFlickablePrivate::data_append(QObject *o)
-{
-    Q_Q(QmlGraphicsFlickable);
     QmlGraphicsItem *i = qobject_cast<QmlGraphicsItem *>(o);
     if (i)
-        viewport->fxChildren()->append(i);
+        i->setParentItem(static_cast<QmlGraphicsFlickablePrivate*>(prop->data)->viewport);
     else
-        o->setParent(q);
+        o->setParent(prop->object);
 }
 
-void QmlGraphicsFlickablePrivate::data_insert(int, QObject *)
-{
-    // ###
-}
-
-QObject *QmlGraphicsFlickablePrivate::data_at(int) const
-{
-    // ###
-    return 0;
-}
-
-void QmlGraphicsFlickablePrivate::data_clear()
-{
-    // ###
-}
-
-
-QmlList<QObject *> *QmlGraphicsFlickable::flickableData()
+QmlListProperty<QObject> QmlGraphicsFlickable::flickableData()
 {
     Q_D(QmlGraphicsFlickable);
-    return &d->data;
+    return QmlListProperty<QObject>(this, (void *)d, QmlGraphicsFlickablePrivate::data_append);
 }
 
-QmlList<QmlGraphicsItem *> *QmlGraphicsFlickable::flickableChildren()
+QmlListProperty<QmlGraphicsItem> QmlGraphicsFlickable::flickableChildren()
 {
     Q_D(QmlGraphicsFlickable);
     return d->viewport->fxChildren();
diff --git a/src/declarative/graphicsitems/qmlgraphicsflickable_p.h b/src/declarative/graphicsitems/qmlgraphicsflickable_p.h
index 373815b..580d01e 100644
--- a/src/declarative/graphicsitems/qmlgraphicsflickable_p.h
+++ b/src/declarative/graphicsitems/qmlgraphicsflickable_p.h
@@ -82,8 +82,8 @@ class Q_DECLARATIVE_EXPORT QmlGraphicsFlickable : public QmlGraphicsItem
 
     Q_PROPERTY(QmlGraphicsFlickableVisibleArea *visibleArea READ visibleArea CONSTANT)
 
-    Q_PROPERTY(QmlList<QObject *>* flickableData READ flickableData)
-    Q_PROPERTY(QmlList<QmlGraphicsItem *>* flickableChildren READ flickableChildren)
+    Q_PROPERTY(QmlListProperty<QObject> flickableData READ flickableData)
+    Q_PROPERTY(QmlListProperty<QmlGraphicsItem> flickableChildren READ flickableChildren)
     Q_CLASSINFO("DefaultProperty", "flickableData")
 
     Q_ENUMS(FlickDirection)
@@ -92,8 +92,8 @@ public:
     QmlGraphicsFlickable(QmlGraphicsItem *parent=0);
     ~QmlGraphicsFlickable();
 
-    QmlList<QObject *> *flickableData();
-    QmlList<QmlGraphicsItem *> *flickableChildren();
+    QmlListProperty<QObject> flickableData();
+    QmlListProperty<QmlGraphicsItem> flickableChildren();
 
     bool overShoot() const;
     void setOverShoot(bool);
diff --git a/src/declarative/graphicsitems/qmlgraphicsflickable_p_p.h b/src/declarative/graphicsitems/qmlgraphicsflickable_p_p.h
index a76ee8a..e58cc0c 100644
--- a/src/declarative/graphicsitems/qmlgraphicsflickable_p_p.h
+++ b/src/declarative/graphicsitems/qmlgraphicsflickable_p_p.h
@@ -149,15 +149,7 @@ public:
     void handleMouseReleaseEvent(QGraphicsSceneMouseEvent *);
 
     // flickableData property
-    void data_removeAt(int);
-    int data_count() const;
-    void data_append(QObject *);
-    void data_insert(int, QObject *);
-    QObject *data_at(int) const;
-    void data_clear();
-
-    friend class QmlGraphicsFlickableVisibleArea;
-    QML_DECLARE_LIST_PROXY(QmlGraphicsFlickablePrivate, QObject *, data)
+    static void data_append(QmlListProperty<QObject> *, QObject *);
 };
 
 class QmlGraphicsFlickableVisibleArea : public QObject
diff --git a/src/declarative/graphicsitems/qmlgraphicsflipable.cpp b/src/declarative/graphicsitems/qmlgraphicsflipable.cpp
index f5abc18..5bab868 100644
--- a/src/declarative/graphicsitems/qmlgraphicsflipable.cpp
+++ b/src/declarative/graphicsitems/qmlgraphicsflipable.cpp
@@ -149,7 +149,7 @@ void QmlGraphicsFlipable::setFront(QmlGraphicsItem *front)
         return;
     }
     d->front = front;
-    fxChildren()->append(d->front);
+    d->front->setParentItem(this);
     if (Back == d->current)
         d->front->setOpacity(0.);
 }
@@ -168,7 +168,7 @@ void QmlGraphicsFlipable::setBack(QmlGraphicsItem *back)
         return;
     }
     d->back = back;
-    fxChildren()->append(d->back);
+    d->back->setParentItem(this);
     if (Front == d->current)
         d->back->setOpacity(0.);
 }
diff --git a/src/declarative/graphicsitems/qmlgraphicsitem.cpp b/src/declarative/graphicsitems/qmlgraphicsitem.cpp
index 22beb12..2e68264 100644
--- a/src/declarative/graphicsitems/qmlgraphicsitem.cpp
+++ b/src/declarative/graphicsitems/qmlgraphicsitem.cpp
@@ -892,7 +892,6 @@ void QmlGraphicsKeyNavigationAttached::keyReleased(QKeyEvent *event)
     parameter provides information about the event.
 */
 
-
 const QmlGraphicsKeysAttached::SigMap QmlGraphicsKeysAttached::sigMap[] = {
     { Qt::Key_Left, "leftPressed" },
     { Qt::Key_Right, "rightPressed" },
@@ -1420,154 +1419,95 @@ QmlGraphicsAnchors *QmlGraphicsItem::anchors()
     return d->anchors();
 }
 
-void QmlGraphicsItemPrivate::data_removeAt(int)
-{
-    // ###
-}
-
-int QmlGraphicsItemPrivate::data_count() const
+void QmlGraphicsItemPrivate::data_append(QmlListProperty<QObject> *prop, QObject *o)
 {
-    // ###
-    return 0;
-}
-
-void QmlGraphicsItemPrivate::data_append(QObject *o)
-{
-    Q_Q(QmlGraphicsItem);
     QmlGraphicsItem *i = qobject_cast<QmlGraphicsItem *>(o);
-    if (i)
-        q->fxChildren()->append(i);
+    if (i) 
+        i->setParentItem(static_cast<QmlGraphicsItem *>(prop->object));
     else
-        resources_append(o);
-}
-
-void QmlGraphicsItemPrivate::data_insert(int, QObject *)
-{
-    // ###
-}
-
-QObject *QmlGraphicsItemPrivate::data_at(int) const
-{
-    // ###
-    return 0;
+        o->setParent(static_cast<QmlGraphicsItem *>(prop->object));
 }
 
-void QmlGraphicsItemPrivate::data_clear()
+QObject *QmlGraphicsItemPrivate::resources_at(QmlListProperty<QObject> *prop, int index)
 {
-    // ###
-}
-
-void QmlGraphicsItemPrivate::resources_removeAt(int)
-{
-    // ###
-}
-
-int QmlGraphicsItemPrivate::resources_count() const
-{
-    Q_Q(const QmlGraphicsItem);
-    return q->children().count();
-}
-
-void QmlGraphicsItemPrivate::resources_append(QObject *o)
-{
-    Q_Q(QmlGraphicsItem);
-    o->setParent(q);
-}
-
-void QmlGraphicsItemPrivate::resources_insert(int, QObject *)
-{
-    // ###
-}
-
-QObject *QmlGraphicsItemPrivate::resources_at(int idx) const
-{
-    Q_Q(const QmlGraphicsItem);
-    QObjectList children = q->children();
-    if (idx < children.count())
-        return children.at(idx);
+    QObjectList children = prop->object->children();
+    if (index < children.count())
+        return children.at(index);
     else
         return 0;
 }
 
-void QmlGraphicsItemPrivate::resources_clear()
+void QmlGraphicsItemPrivate::resources_append(QmlListProperty<QObject> *prop, QObject *o)
 {
-    // ###
+    o->setParent(prop->object);
 }
 
-void QmlGraphicsItemPrivate::children_removeAt(int)
+int QmlGraphicsItemPrivate::resources_count(QmlListProperty<QObject> *prop)
 {
-    // ###
+    return prop->object->children().count();
 }
 
-int QmlGraphicsItemPrivate::children_count() const
+QmlGraphicsItem *QmlGraphicsItemPrivate::children_at(QmlListProperty<QmlGraphicsItem> *prop, int index)
 {
-    Q_Q(const QmlGraphicsItem);
-    return q->childItems().count();
-}
+    QList<QGraphicsItem *> children = static_cast<QmlGraphicsItem*>(prop->object)->childItems();
 
-void QmlGraphicsItemPrivate::children_append(QmlGraphicsItem *i)
-{
-    Q_Q(QmlGraphicsItem);
-    i->setParentItem(q);
-}
-
-void QmlGraphicsItemPrivate::children_insert(int, QmlGraphicsItem *)
-{
-    // ###
-}
-
-QmlGraphicsItem *QmlGraphicsItemPrivate::children_at(int idx) const
-{
-    Q_Q(const QmlGraphicsItem);
-    QList<QGraphicsItem *> children = q->childItems();
-    if (idx < children.count())
-        return qobject_cast<QmlGraphicsItem *>(children.at(idx));
+    if (index < children.count())
+        return qobject_cast<QmlGraphicsItem *>(children.at(index));
     else
         return 0;
 }
 
-void QmlGraphicsItemPrivate::children_clear()
+void QmlGraphicsItemPrivate::children_append(QmlListProperty<QmlGraphicsItem> *prop, QmlGraphicsItem *i)
 {
-    // ###
-}
-
-
-void QmlGraphicsItemPrivate::transform_removeAt(int i)
-{
-    if (!transformData)
-        return;
-    transformData->graphicsTransforms.removeAt(i);
-    dirtySceneTransform = 1;
+    if (i)
+        i->setParentItem(static_cast<QmlGraphicsItem*>(prop->object));
 }
 
-int QmlGraphicsItemPrivate::transform_count() const
+int QmlGraphicsItemPrivate::children_count(QmlListProperty<QmlGraphicsItem> *prop)
 {
-    return transformData ? transformData->graphicsTransforms.size() : 0;
+    return static_cast<QmlGraphicsItem*>(prop->object)->childItems().count();
 }
 
-void QmlGraphicsItemPrivate::transform_append(QGraphicsTransform *item)
+int QmlGraphicsItemPrivate::transform_count(QmlListProperty<QGraphicsTransform> *list)
 {
-    appendGraphicsTransform(item);
+    QGraphicsObject *object = qobject_cast<QGraphicsObject *>(list->object);
+    if (object) {
+        QGraphicsItemPrivate *d = QGraphicsItemPrivate::get(object);
+        return d->transformData ? d->transformData->graphicsTransforms.size() : 0;
+    } else {
+        return 0;
+    }
 }
 
-void QmlGraphicsItemPrivate::transform_insert(int, QGraphicsTransform *)
+void QmlGraphicsItemPrivate::transform_append(QmlListProperty<QGraphicsTransform> *list, QGraphicsTransform *item)
 {
-    // ###
+    QGraphicsObject *object = qobject_cast<QGraphicsObject *>(list->object);
+    if (object)
+        QGraphicsItemPrivate::get(object)->appendGraphicsTransform(item);
 }
 
-QGraphicsTransform *QmlGraphicsItemPrivate::transform_at(int idx) const
+QGraphicsTransform *QmlGraphicsItemPrivate::transform_at(QmlListProperty<QGraphicsTransform> *list, int idx)
 {
-    if (!transformData)
+    QGraphicsObject *object = qobject_cast<QGraphicsObject *>(list->object);
+    if (object) {
+        QGraphicsItemPrivate *d = QGraphicsItemPrivate::get(object);
+        if (!d->transformData)
+            return 0;
+        return d->transformData->graphicsTransforms.at(idx);
+    } else {
         return 0;
-    return transformData->graphicsTransforms.at(idx);
+    }
 }
 
-void QmlGraphicsItemPrivate::transform_clear()
+void QmlGraphicsItemPrivate::transform_clear(QmlListProperty<QGraphicsTransform> *list)
 {
-    if (!transformData)
-        return;
-    Q_Q(QmlGraphicsItem);
-    q->setTransformations(QList<QGraphicsTransform *>());
+    QGraphicsObject *object = qobject_cast<QGraphicsObject *>(list->object);
+    if (object) {
+        QGraphicsItemPrivate *d = QGraphicsItemPrivate::get(object);
+        if (!d->transformData)
+            return;
+        object->setTransformations(QList<QGraphicsTransform *>());
+    }
 }
 
 /*!
@@ -1610,10 +1550,9 @@ void QmlGraphicsItemPrivate::transform_clear()
 */
 
 /*! \internal */
-QmlList<QObject *> *QmlGraphicsItem::data()
+QmlListProperty<QObject> QmlGraphicsItem::data() 
 {
-    Q_D(QmlGraphicsItem);
-    return &d->data;
+    return QmlListProperty<QObject>(this, 0, QmlGraphicsItemPrivate::data_append);
 }
 
 /*!
@@ -2215,17 +2154,19 @@ void QmlGraphicsItem::focusChanged(bool flag)
 }
 
 /*! \internal */
-QmlList<QmlGraphicsItem *> *QmlGraphicsItem::fxChildren()
+QmlListProperty<QmlGraphicsItem> QmlGraphicsItem::fxChildren()
 {
-    Q_D(QmlGraphicsItem);
-    return &(d->children);
+    return QmlListProperty<QmlGraphicsItem>(this, 0, QmlGraphicsItemPrivate::children_append,
+                                                     QmlGraphicsItemPrivate::children_count, 
+                                                     QmlGraphicsItemPrivate::children_at); 
 }
 
 /*! \internal */
-QmlList<QObject *> *QmlGraphicsItem::resources()
+QmlListProperty<QObject> QmlGraphicsItem::resources()
 {
-    Q_D(QmlGraphicsItem);
-    return &(d->resources);
+    return QmlListProperty<QObject>(this, 0, QmlGraphicsItemPrivate::resources_append, 
+                                             QmlGraphicsItemPrivate::resources_count, 
+                                             QmlGraphicsItemPrivate::resources_at); 
 }
 
 /*!
@@ -2250,7 +2191,7 @@ QmlList<QObject *> *QmlGraphicsItem::resources()
   \internal
 */
 /*! \internal */
-QmlList<QmlState *>* QmlGraphicsItem::states()
+QmlListProperty<QmlState> QmlGraphicsItem::states()
 {
     Q_D(QmlGraphicsItem);
     return d->states()->statesProperty();
@@ -2279,7 +2220,7 @@ QmlList<QmlState *>* QmlGraphicsItem::states()
 */
 
 /*! \internal */
-QmlList<QmlTransition *>* QmlGraphicsItem::transitions()
+QmlListProperty<QmlTransition> QmlGraphicsItem::transitions()
 {
     Q_D(QmlGraphicsItem);
     return d->states()->transitionsProperty();
@@ -2387,10 +2328,11 @@ void QmlGraphicsItem::setState(const QString &state)
 */
 
 /*! \internal */
-QmlList<QGraphicsTransform *>* QmlGraphicsItem::transform()
+QmlListProperty<QGraphicsTransform> QmlGraphicsItem::transform()
 {
     Q_D(QmlGraphicsItem);
-    return &(d->transform);
+    return QmlListProperty<QGraphicsTransform>(this, 0, d->transform_append, d->transform_count,
+                                               d->transform_at, d->transform_clear);
 }
 
 /*!
diff --git a/src/declarative/graphicsitems/qmlgraphicsitem.h b/src/declarative/graphicsitems/qmlgraphicsitem.h
index e1cf035..891fc88 100644
--- a/src/declarative/graphicsitems/qmlgraphicsitem.h
+++ b/src/declarative/graphicsitems/qmlgraphicsitem.h
@@ -70,11 +70,11 @@ class Q_DECLARATIVE_EXPORT QmlGraphicsItem : public QGraphicsObject, public QmlP
     Q_INTERFACES(QmlParserStatus)
 
     Q_PROPERTY(QmlGraphicsItem * parent READ parentItem WRITE setParentItem NOTIFY parentChanged DESIGNABLE false FINAL)
-    Q_PROPERTY(QmlList<QObject *> *data READ data DESIGNABLE false)
-    Q_PROPERTY(QmlList<QmlGraphicsItem *>* children READ fxChildren DESIGNABLE false NOTIFY childrenChanged)
-    Q_PROPERTY(QmlList<QObject *>* resources READ resources DESIGNABLE false)
-    Q_PROPERTY(QmlList<QmlState *>* states READ states DESIGNABLE false)
-    Q_PROPERTY(QmlList<QmlTransition *>* transitions READ transitions DESIGNABLE false)
+    Q_PROPERTY(QmlListProperty<QObject> data READ data DESIGNABLE false)
+    Q_PROPERTY(QmlListProperty<QmlGraphicsItem> children READ fxChildren DESIGNABLE false NOTIFY childrenChanged)
+    Q_PROPERTY(QmlListProperty<QObject> resources READ resources DESIGNABLE false)
+    Q_PROPERTY(QmlListProperty<QmlState> states READ states DESIGNABLE false)
+    Q_PROPERTY(QmlListProperty<QmlTransition> transitions READ transitions DESIGNABLE false)
     Q_PROPERTY(QString state READ state WRITE setState NOTIFY stateChanged)
     Q_PROPERTY(qreal width READ width WRITE setWidth NOTIFY widthChanged RESET resetWidth FINAL)
     Q_PROPERTY(qreal height READ height WRITE setHeight NOTIFY heightChanged RESET resetHeight FINAL)
@@ -91,7 +91,7 @@ class Q_DECLARATIVE_EXPORT QmlGraphicsItem : public QGraphicsObject, public QmlP
     Q_PROPERTY(bool clip READ clip WRITE setClip NOTIFY clipChanged) // ### move to QGI/QGO, NOTIFY
     Q_PROPERTY(bool focus READ hasFocus WRITE setFocus NOTIFY focusChanged FINAL)
     Q_PROPERTY(bool wantsFocus READ wantsFocus NOTIFY wantsFocusChanged)
-    Q_PROPERTY(QmlList<QGraphicsTransform *>* transform READ transform DESIGNABLE false FINAL)
+    Q_PROPERTY(QmlListProperty<QGraphicsTransform> transform READ transform DESIGNABLE false FINAL)
     Q_PROPERTY(TransformOrigin transformOrigin READ transformOrigin WRITE setTransformOrigin NOTIFY transformOriginChanged)
     Q_PROPERTY(bool smooth READ smooth WRITE setSmooth NOTIFY smoothChanged)
     Q_PROPERTY(QGraphicsEffect *effect READ graphicsEffect WRITE setGraphicsEffect)
@@ -112,9 +112,9 @@ public:
     void setParentItem(QmlGraphicsItem *parent);
     void setParent(QmlGraphicsItem *parent) { setParentItem(parent); }
 
-    QmlList<QObject *> *data();
-    QmlList<QmlGraphicsItem *> *fxChildren();
-    QmlList<QObject *> *resources();
+    QmlListProperty<QObject> data();
+    QmlListProperty<QmlGraphicsItem> fxChildren();
+    QmlListProperty<QObject> resources();
 
     QmlGraphicsAnchors *anchors();
     QRectF childrenRect();
@@ -122,8 +122,8 @@ public:
     bool clip() const;
     void setClip(bool);
 
-    QmlList<QmlState *>* states();
-    QmlList<QmlTransition *>* transitions();
+    QmlListProperty<QmlState> states();
+    QmlListProperty<QmlTransition> transitions();
 
     QString state() const;
     void setState(const QString &);
@@ -131,7 +131,7 @@ public:
     qreal baselineOffset() const;
     void setBaselineOffset(qreal);
 
-    QmlList<QGraphicsTransform *> *transform();
+    QmlListProperty<QGraphicsTransform> transform();
 
     qreal width() const;
     void setWidth(qreal);
diff --git a/src/declarative/graphicsitems/qmlgraphicsitem_p.h b/src/declarative/graphicsitems/qmlgraphicsitem_p.h
index 7662a3b..4860b83 100644
--- a/src/declarative/graphicsitems/qmlgraphicsitem_p.h
+++ b/src/declarative/graphicsitems/qmlgraphicsitem_p.h
@@ -137,40 +137,23 @@ public:
     QString _id;
 
     // data property
-    void data_removeAt(int);
-    int data_count() const;
-    void data_append(QObject *);
-    void data_insert(int, QObject *);
-    QObject *data_at(int) const;
-    void data_clear();
-    QML_DECLARE_LIST_PROXY(QmlGraphicsItemPrivate, QObject *, data)
+    static void data_append(QmlListProperty<QObject> *, QObject *);
 
     // resources property
-    void resources_removeAt(int);
-    int resources_count() const;
-    void resources_append(QObject *);
-    void resources_insert(int, QObject *);
-    QObject *resources_at(int) const;
-    void resources_clear();
-    QML_DECLARE_LIST_PROXY(QmlGraphicsItemPrivate, QObject *, resources)
+    static QObject *resources_at(QmlListProperty<QObject> *, int);
+    static void resources_append(QmlListProperty<QObject> *, QObject *);
+    static int resources_count(QmlListProperty<QObject> *);
 
     // children property
-    void children_removeAt(int);
-    int children_count() const;
-    void children_append(QmlGraphicsItem *);
-    void children_insert(int, QmlGraphicsItem *);
-    QmlGraphicsItem *children_at(int) const;
-    void children_clear();
-    QML_DECLARE_LIST_PROXY(QmlGraphicsItemPrivate, QmlGraphicsItem *, children)
+    static QmlGraphicsItem *children_at(QmlListProperty<QmlGraphicsItem> *, int);
+    static void children_append(QmlListProperty<QmlGraphicsItem> *, QmlGraphicsItem *);
+    static int children_count(QmlListProperty<QmlGraphicsItem> *);
 
     // transform property
-    void transform_removeAt(int);
-    int transform_count() const;
-    void transform_append(QGraphicsTransform *);
-    void transform_insert(int, QGraphicsTransform *);
-    QGraphicsTransform *transform_at(int) const;
-    void transform_clear();
-    QML_DECLARE_LIST_PROXY(QmlGraphicsItemPrivate, QGraphicsTransform *, transform)
+    static int transform_count(QmlListProperty<QGraphicsTransform> *list);
+    static void transform_append(QmlListProperty<QGraphicsTransform> *list, QGraphicsTransform *);
+    static QGraphicsTransform *transform_at(QmlListProperty<QGraphicsTransform> *list, int);
+    static void transform_clear(QmlListProperty<QGraphicsTransform> *list);
 
     QmlGraphicsAnchors *anchors() {
         if (!_anchors) {
@@ -381,7 +364,7 @@ class QmlGraphicsKeysAttached : public QObject, public QmlGraphicsItemKeyFilter
     Q_DECLARE_PRIVATE(QmlGraphicsKeysAttached)
 
     Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
-    Q_PROPERTY(QList<QmlGraphicsItem *> *forwardTo READ forwardTo)
+    Q_PROPERTY(QmlListProperty<QmlGraphicsItem> forwardTo READ forwardTo)
 
 public:
     QmlGraphicsKeysAttached(QObject *parent=0);
@@ -396,9 +379,9 @@ public:
         }
     }
 
-    QList<QmlGraphicsItem *> *forwardTo() {
+    QmlListProperty<QmlGraphicsItem> forwardTo() {
         Q_D(QmlGraphicsKeysAttached);
-        return &d->targets;
+        return QmlListProperty<QmlGraphicsItem>(this, d->targets);
     }
 
     virtual void componentComplete();
diff --git a/src/declarative/graphicsitems/qmlgraphicspath.cpp b/src/declarative/graphicsitems/qmlgraphicspath.cpp
index 7916bd3..4e4459d 100644
--- a/src/declarative/graphicsitems/qmlgraphicspath.cpp
+++ b/src/declarative/graphicsitems/qmlgraphicspath.cpp
@@ -155,10 +155,10 @@ bool QmlGraphicsPath::isClosed() const
     \snippet doc/src/snippets/declarative/pathview/pathattributes.qml 2
 */
 
-QList<QmlGraphicsPathElement *>* QmlGraphicsPath::pathElements()
+QmlListProperty<QmlGraphicsPathElement> QmlGraphicsPath::pathElements()
 {
     Q_D(QmlGraphicsPath);
-    return &(d->_pathElements);
+    return QmlListProperty<QmlGraphicsPathElement>(this, d->_pathElements);
 }
 
 void QmlGraphicsPath::interpolate(int idx, const QString &name, qreal value)
diff --git a/src/declarative/graphicsitems/qmlgraphicspath_p.h b/src/declarative/graphicsitems/qmlgraphicspath_p.h
index 51b7262..7ba5bbc 100644
--- a/src/declarative/graphicsitems/qmlgraphicspath_p.h
+++ b/src/declarative/graphicsitems/qmlgraphicspath_p.h
@@ -189,7 +189,7 @@ class Q_DECLARATIVE_EXPORT QmlGraphicsPath : public QObject, public QmlParserSta
     Q_OBJECT
 
     Q_INTERFACES(QmlParserStatus)
-    Q_PROPERTY(QList<QmlGraphicsPathElement *>* pathElements READ pathElements)
+    Q_PROPERTY(QmlListProperty<QmlGraphicsPathElement> pathElements READ pathElements)
     Q_PROPERTY(qreal startX READ startX WRITE setStartX)
     Q_PROPERTY(qreal startY READ startY WRITE setStartY)
     Q_PROPERTY(bool closed READ isClosed NOTIFY changed)
@@ -199,7 +199,7 @@ public:
     QmlGraphicsPath(QObject *parent=0);
     ~QmlGraphicsPath();
 
-    QList<QmlGraphicsPathElement *>* pathElements();
+    QmlListProperty<QmlGraphicsPathElement> pathElements();
 
     qreal startX() const;
     void setStartX(qreal x);
diff --git a/src/declarative/graphicsitems/qmlgraphicsrectangle_p.h b/src/declarative/graphicsitems/qmlgraphicsrectangle_p.h
index c566027..66552f6 100644
--- a/src/declarative/graphicsitems/qmlgraphicsrectangle_p.h
+++ b/src/declarative/graphicsitems/qmlgraphicsrectangle_p.h
@@ -107,14 +107,14 @@ class Q_DECLARATIVE_EXPORT QmlGraphicsGradient : public QObject
 {
     Q_OBJECT
 
-    Q_PROPERTY(QList<QmlGraphicsGradientStop *> *stops READ stops)
+    Q_PROPERTY(QmlListProperty<QmlGraphicsGradientStop> stops READ stops)
     Q_CLASSINFO("DefaultProperty", "stops")
 
 public:
     QmlGraphicsGradient(QObject *parent=0) : QObject(parent), m_gradient(0) {}
     ~QmlGraphicsGradient() { delete m_gradient; }
 
-    QList<QmlGraphicsGradientStop *> *stops() { return &m_stops; }
+    QmlListProperty<QmlGraphicsGradientStop> stops() { return QmlListProperty<QmlGraphicsGradientStop>(this, m_stops); }
 
     const QGradient *gradient() const;
 
diff --git a/src/declarative/graphicsitems/qmlgraphicsvisualitemmodel.cpp b/src/declarative/graphicsitems/qmlgraphicsvisualitemmodel.cpp
index 4ced2c3..b96f399 100644
--- a/src/declarative/graphicsitems/qmlgraphicsvisualitemmodel.cpp
+++ b/src/declarative/graphicsitems/qmlgraphicsvisualitemmodel.cpp
@@ -71,16 +71,14 @@ class QmlGraphicsVisualItemModelPrivate : public QObjectPrivate
 {
     Q_DECLARE_PUBLIC(QmlGraphicsVisualItemModel)
 public:
-    QmlGraphicsVisualItemModelPrivate() : QObjectPrivate(), children(this) {}
+    QmlGraphicsVisualItemModelPrivate() : QObjectPrivate() {}
 
-    struct ItemList : public QmlConcreteList<QmlGraphicsItem *>
-    {
-        ItemList(QmlGraphicsVisualItemModelPrivate *m) : QmlConcreteList<QmlGraphicsItem *>(), model(m) {}
-
-        void append(QmlGraphicsItem *item);
-
-        QmlGraphicsVisualItemModelPrivate *model;
-    };
+    static void children_append(QmlListProperty<QmlGraphicsItem> *prop, QmlGraphicsItem *item) {
+        item->QObject::setParent(prop->object);
+        static_cast<QmlGraphicsVisualItemModelPrivate *>(prop->data)->children.append(item);
+        static_cast<QmlGraphicsVisualItemModelPrivate *>(prop->data)->itemAppended();
+        static_cast<QmlGraphicsVisualItemModelPrivate *>(prop->data)->emitChildrenChanged();
+    }
 
     void itemAppended() {
         Q_Q(QmlGraphicsVisualItemModel);
@@ -94,7 +92,8 @@ public:
         Q_Q(QmlGraphicsVisualItemModel);
         emit q->childrenChanged();
     }
-    ItemList children;
+
+    QList<QmlGraphicsItem *> children;
 };
 
 
@@ -132,10 +131,10 @@ QmlGraphicsVisualItemModel::QmlGraphicsVisualItemModel()
 {
 }
 
-QmlList<QmlGraphicsItem *> *QmlGraphicsVisualItemModel::children()
+QmlListProperty<QmlGraphicsItem> QmlGraphicsVisualItemModel::children()
 {
     Q_D(QmlGraphicsVisualItemModel);
-    return &(d->children);
+    return QmlListProperty<QmlGraphicsItem>(this, d, QmlGraphicsVisualItemModelPrivate::children_append);
 }
 
 /*!
@@ -200,15 +199,6 @@ int QmlGraphicsVisualItemModel::indexOf(QmlGraphicsItem *item, QObject *) const
     return d->children.indexOf(item);
 }
 
-void QmlGraphicsVisualItemModelPrivate::ItemList::append(QmlGraphicsItem *item)
-{
-    QmlConcreteList<QmlGraphicsItem*>::append(item);
-    item->QObject::setParent(model->q_ptr);
-    model->itemAppended();
-
-    model->emitChildrenChanged();
-}
-
 QmlGraphicsVisualItemModelAttached *QmlGraphicsVisualItemModel::qmlAttachedProperties(QObject *obj)
 {
     return QmlGraphicsVisualItemModelAttached::properties(obj);
@@ -422,8 +412,7 @@ int QmlGraphicsVisualDataModelDataMetaObject::createProperty(const char *name, c
     QmlGraphicsVisualDataModelPrivate *model = QmlGraphicsVisualDataModelPrivate::get(data->m_model);
 
     if ((!model->m_listModelInterface || !model->m_abstractItemModel) && model->m_listAccessor) {
-        if (model->m_listAccessor->type() == QmlListAccessor::QmlList
-            || model->m_listAccessor->type() == QmlListAccessor::QListPtr) {
+        if (model->m_listAccessor->type() == QmlListAccessor::ListProperty) {
             model->ensureRoles();
             QObject *object = model->m_listAccessor->at(data->m_index).value<QObject*>();
             if (object && object->property(name).isValid())
@@ -685,7 +674,7 @@ void QmlGraphicsVisualDataModel::setModel(const QVariant &model)
     }
     d->m_listAccessor = new QmlListAccessor;
     d->m_listAccessor->setList(model, d->m_context?d->m_context->engine():qmlEngine(this));
-    if (d->m_listAccessor->type() != QmlListAccessor::QmlList && d->m_listAccessor->type() != QmlListAccessor::QListPtr)
+    if (d->m_listAccessor->type() != QmlListAccessor::ListProperty)
         d->m_metaDataCacheable = true;
     if (d->m_delegate && d->modelCount()) {
         emit itemsInserted(0, d->modelCount());
diff --git a/src/declarative/graphicsitems/qmlgraphicsvisualitemmodel_p.h b/src/declarative/graphicsitems/qmlgraphicsvisualitemmodel_p.h
index c0ea499..49f9b27 100644
--- a/src/declarative/graphicsitems/qmlgraphicsvisualitemmodel_p.h
+++ b/src/declarative/graphicsitems/qmlgraphicsvisualitemmodel_p.h
@@ -109,7 +109,7 @@ class Q_DECLARATIVE_EXPORT QmlGraphicsVisualItemModel : public QmlGraphicsVisual
     Q_OBJECT
     Q_DECLARE_PRIVATE(QmlGraphicsVisualItemModel)
 
-    Q_PROPERTY(QmlList<QmlGraphicsItem *>* children READ children NOTIFY childrenChanged DESIGNABLE false)
+    Q_PROPERTY(QmlListProperty<QmlGraphicsItem> children READ children NOTIFY childrenChanged DESIGNABLE false)
     Q_CLASSINFO("DefaultProperty", "children")
 
 public:
@@ -126,7 +126,7 @@ public:
 
     virtual int indexOf(QmlGraphicsItem *item, QObject *objectContext) const;
 
-    QmlList<QmlGraphicsItem *> *children();
+    QmlListProperty<QmlGraphicsItem> children();
 
     static QmlGraphicsVisualItemModelAttached *qmlAttachedProperties(QObject *obj);
 
diff --git a/src/declarative/graphicsitems/qmlgraphicswebview.cpp b/src/declarative/graphicsitems/qmlgraphicswebview.cpp
index 515f896..0c21f75 100644
--- a/src/declarative/graphicsitems/qmlgraphicswebview.cpp
+++ b/src/declarative/graphicsitems/qmlgraphicswebview.cpp
@@ -77,7 +77,6 @@ public:
             progress(1.0), status(QmlGraphicsWebView::Null), pending(PendingNone),
             newWindowComponent(0), newWindowParent(0),
             pressTime(400),
-            windowObjects(this),
             rendering(true)
     {
     }
@@ -101,19 +100,14 @@ public:
     QPoint pressPoint;
     int pressTime; // milliseconds before it's a "hold"
 
+
+    static void windowObjects_append(QmlListProperty<QObject> *prop, QObject *o) {
+        static_cast<QmlGraphicsWebViewPrivate *>(prop->data)->windowObjects.append(o);
+        static_cast<QmlGraphicsWebViewPrivate *>(prop->data)->updateWindowObjects();
+    }
+
     void updateWindowObjects();
-    class WindowObjectList : public QmlConcreteList<QObject *>
-    {
-    public:
-        WindowObjectList(QmlGraphicsWebViewPrivate *p)
-            : priv(p) {}
-        virtual void append(QObject *v) {
-            QmlConcreteList<QObject *>::append(v);
-            priv->updateWindowObjects();
-        }
-    private:
-        QmlGraphicsWebViewPrivate *priv;
-    } windowObjects;
+    QObjectList windowObjects;
 
     bool rendering;
 };
@@ -451,10 +445,10 @@ void QmlGraphicsWebView::paintPage(const QRect& r)
 
     If Javascript is not enabled for this page, then this property does nothing.
 */
-QmlList<QObject *> *QmlGraphicsWebView::javaScriptWindowObjects()
+QmlListProperty<QObject> QmlGraphicsWebView::javaScriptWindowObjects()
 {
     Q_D(QmlGraphicsWebView);
-    return &d->windowObjects;
+    return QmlListProperty<QObject>(this, d, &QmlGraphicsWebViewPrivate::windowObjects_append);
 }
 
 QmlGraphicsWebViewAttached *QmlGraphicsWebView::qmlAttachedProperties(QObject *o)
diff --git a/src/declarative/graphicsitems/qmlgraphicswebview_p.h b/src/declarative/graphicsitems/qmlgraphicswebview_p.h
index 1822ddb..30ba0e4 100644
--- a/src/declarative/graphicsitems/qmlgraphicswebview_p.h
+++ b/src/declarative/graphicsitems/qmlgraphicswebview_p.h
@@ -114,7 +114,7 @@ class Q_DECLARATIVE_EXPORT QmlGraphicsWebView : public QmlGraphicsPaintedItem
 
     Q_PROPERTY(QmlGraphicsWebSettings* settings READ settingsObject CONSTANT)
 
-    Q_PROPERTY(QmlList<QObject *>* javaScriptWindowObjects READ javaScriptWindowObjects CONSTANT)
+    Q_PROPERTY(QmlListProperty<QObject> javaScriptWindowObjects READ javaScriptWindowObjects CONSTANT)
 
     Q_PROPERTY(QmlComponent* newWindowComponent READ newWindowComponent WRITE setNewWindowComponent)
     Q_PROPERTY(QmlGraphicsItem* newWindowParent READ newWindowParent WRITE setNewWindowParent)
@@ -174,7 +174,7 @@ public:
     bool renderingEnabled() const;
     void setRenderingEnabled(bool);
 
-    QmlList<QObject *> *javaScriptWindowObjects();
+    QmlListProperty<QObject> javaScriptWindowObjects();
 
     static QmlGraphicsWebViewAttached *qmlAttachedProperties(QObject *);
 
diff --git a/src/declarative/qml/qml.h b/src/declarative/qml/qml.h
index e5e7c59..7972305 100644
--- a/src/declarative/qml/qml.h
+++ b/src/declarative/qml/qml.h
@@ -59,12 +59,10 @@ QT_MODULE(Declarative)
 
 #define QML_DECLARE_TYPE(TYPE) \
     Q_DECLARE_METATYPE(TYPE *) \
-    Q_DECLARE_METATYPE(QList<TYPE *> *) \
-    Q_DECLARE_METATYPE(QmlList<TYPE *> *)
+    Q_DECLARE_METATYPE(QmlListProperty<TYPE>) 
 
 #define QML_DECLARE_TYPE_HASMETATYPE(TYPE) \
-    Q_DECLARE_METATYPE(QList<TYPE *> *) \
-    Q_DECLARE_METATYPE(QmlList<TYPE *> *)
+    Q_DECLARE_METATYPE(QmlListProperty<TYPE>) 
 
 #define QML_DECLARE_INTERFACE(INTERFACE) \
     QML_DECLARE_TYPE(INTERFACE)
diff --git a/src/declarative/qml/qml.pri b/src/declarative/qml/qml.pri
index a8df61e..2313c37 100644
--- a/src/declarative/qml/qml.pri
+++ b/src/declarative/qml/qml.pri
@@ -51,7 +51,9 @@ SOURCES += \
     $$PWD/qmllistscriptclass.cpp \
     $$PWD/qmlworkerscript.cpp \
     $$PWD/qmlimageprovider.cpp \
-    $$PWD/qmlnetworkaccessmanagerfactory.cpp
+    $$PWD/qmlnetworkaccessmanagerfactory.cpp \
+    $$PWD/qmllist.cpp 
+
 HEADERS += \
     $$PWD/qmlparser_p.h \
     $$PWD/qmlglobal_p.h \
@@ -91,6 +93,7 @@ HEADERS += \
     $$PWD/qmlcompositetypedata_p.h \
     $$PWD/qmlcompositetypemanager_p.h \
     $$PWD/qmllist.h \
+    $$PWD/qmllist_p.h \
     $$PWD/qmldeclarativedata_p.h \
     $$PWD/qmlerror.h \
     $$PWD/qmlscriptparser_p.h \
diff --git a/src/declarative/qml/qmlbinding.cpp b/src/declarative/qml/qmlbinding.cpp
index 0dbe63b..feadd0f 100644
--- a/src/declarative/qml/qmlbinding.cpp
+++ b/src/declarative/qml/qmlbinding.cpp
@@ -54,8 +54,6 @@
 #include <QVariant>
 #include <QtCore/qdebug.h>
 
-Q_DECLARE_METATYPE(QList<QObject *>);
-
 QT_BEGIN_NAMESPACE
 
 QML_DEFINE_NOCREATE_TYPE(QmlBinding);
diff --git a/src/declarative/qml/qmlcompiler.cpp b/src/declarative/qml/qmlcompiler.cpp
index 2b1081e..bbae201 100644
--- a/src/declarative/qml/qmlcompiler.cpp
+++ b/src/declarative/qml/qmlcompiler.cpp
@@ -1495,8 +1495,7 @@ bool QmlCompiler::buildProperty(QmlParser::Property *prop,
 
         COMPILE_CHECK(buildGroupedProperty(prop, obj, ctxt));
 
-    } else if (QmlEnginePrivate::get(engine)->isQmlList(prop->type) ||
-               QmlMetaType::isList(prop->type)) {
+    } else if (QmlEnginePrivate::get(engine)->isList(prop->type)) {
 
         COMPILE_CHECK(buildListProperty(prop, obj, ctxt));
 
@@ -1552,8 +1551,7 @@ QmlCompiler::buildPropertyInNamespace(QmlEnginePrivate::ImportedNamespace *ns,
 void QmlCompiler::genValueProperty(QmlParser::Property *prop,
                                    QmlParser::Object *obj)
 {
-    if (QmlEnginePrivate::get(engine)->isQmlList(prop->type) || 
-        QmlMetaType::isList(prop->type)) {
+    if (QmlEnginePrivate::get(engine)->isList(prop->type)) {
         genListProperty(prop, obj);
     } else {
         genPropertyAssignment(prop, obj);
@@ -1563,22 +1561,10 @@ void QmlCompiler::genValueProperty(QmlParser::Property *prop,
 void QmlCompiler::genListProperty(QmlParser::Property *prop,
                                   QmlParser::Object *obj)
 {
-    QmlInstruction::Type fetchType;
-    QmlInstruction::Type storeType;
-    int listType;
-
-    if (QmlEnginePrivate::get(engine)->isQmlList(prop->type)) {
-        fetchType = QmlInstruction::FetchQmlList;
-        storeType = QmlInstruction::StoreObjectQmlList;
-        listType = QmlEnginePrivate::get(engine)->qmlListType(prop->type);
-    } else {
-        fetchType = QmlInstruction::FetchQList;
-        storeType = QmlInstruction::StoreObjectQList;
-        listType = QmlMetaType::listType(prop->type);
-    }
+    int listType = QmlEnginePrivate::get(engine)->listType(prop->type);
 
     QmlInstruction fetch;
-    fetch.type = fetchType;
+    fetch.type = QmlInstruction::FetchQList;
     fetch.line = prop->location.start.line;
     fetch.fetchQmlList.property = prop->index;
     bool listTypeIsInterface = QmlMetaType::isInterface(listType);
@@ -1598,7 +1584,7 @@ void QmlCompiler::genListProperty(QmlParser::Property *prop,
                 output->bytecode << assign;
             } else {
                 QmlInstruction store;
-                store.type = storeType;
+                store.type = QmlInstruction::StoreObjectQList;
                 store.line = prop->location.start.line;
                 output->bytecode << store;
             }
@@ -1895,67 +1881,40 @@ bool QmlCompiler::buildListProperty(QmlParser::Property *prop,
                                     QmlParser::Object *obj,
                                     const BindingContext &ctxt)
 {
-    Q_ASSERT(QmlMetaType::isList(prop->type) ||
-             QmlEnginePrivate::get(engine)->isQmlList(prop->type));
+    Q_ASSERT(QmlEnginePrivate::get(engine)->isList(prop->type));
 
     int t = prop->type;
 
     obj->addValueProperty(prop);
 
-    if (QmlEnginePrivate::get(engine)->isQmlList(t)) {
-        int listType = QmlEnginePrivate::get(engine)->qmlListType(t);
-        bool listTypeIsInterface = QmlMetaType::isInterface(listType);
-
-        for (int ii = 0; ii < prop->values.count(); ++ii) {
-            Value *v = prop->values.at(ii);
-            if (v->object) {
-                v->type = Value::CreatedObject;
-                COMPILE_CHECK(buildObject(v->object, ctxt));
-
-                // We check object coercian here.  We check interface assignment
-                // at runtime.
-                if (!listTypeIsInterface) {
-                    if (!canCoerce(listType, v->object)) {
-                        COMPILE_EXCEPTION(v, QCoreApplication::translate("QmlCompiler","Cannot assign object to list"));
-                    }
-                }
+    int listType = QmlEnginePrivate::get(engine)->listType(t);
+    bool listTypeIsInterface = QmlMetaType::isInterface(listType);
 
-            } else {
-                COMPILE_EXCEPTION(v, QCoreApplication::translate("QmlCompiler","Cannot assign primitives to lists"));
-            }
-        }
+    bool assignedBinding = false;
+    for (int ii = 0; ii < prop->values.count(); ++ii) {
+        Value *v = prop->values.at(ii);
+        if (v->object) {
+            v->type = Value::CreatedObject;
+            COMPILE_CHECK(buildObject(v->object, ctxt));
 
-    } else {
-        int listType = QmlMetaType::listType(t);
-        bool listTypeIsInterface = QmlMetaType::isInterface(listType);
-
-        bool assignedBinding = false;
-        for (int ii = 0; ii < prop->values.count(); ++ii) {
-            Value *v = prop->values.at(ii);
-            if (v->object) {
-                v->type = Value::CreatedObject;
-                COMPILE_CHECK(buildObject(v->object, ctxt));
-
-                // We check object coercian here.  We check interface assignment
-                // at runtime.
-                if (!listTypeIsInterface) {
-                    if (!canCoerce(listType, v->object)) {
-                        COMPILE_EXCEPTION(v, QCoreApplication::translate("QmlCompiler","Cannot assign object to list"));
-                    }
+            // We check object coercian here.  We check interface assignment
+            // at runtime.
+            if (!listTypeIsInterface) {
+                if (!canCoerce(listType, v->object)) {
+                    COMPILE_EXCEPTION(v, QCoreApplication::translate("QmlCompiler","Cannot assign object to list"));
                 }
+            }
 
-            } else if (v->value.isScript()) {
-                if (assignedBinding)
-                    COMPILE_EXCEPTION(v, QCoreApplication::translate("QmlCompiler","Can only assign one binding to lists"));
+        } else if (v->value.isScript()) {
+            if (assignedBinding)
+                COMPILE_EXCEPTION(v, QCoreApplication::translate("QmlCompiler","Can only assign one binding to lists"));
 
-                assignedBinding = true;
-                COMPILE_CHECK(buildBinding(v, prop, ctxt));
-                v->type = Value::PropertyBinding;
-            } else {
-                COMPILE_EXCEPTION(v, QCoreApplication::translate("QmlCompiler","Cannot assign primitives to lists"));
-            }
+            assignedBinding = true;
+            COMPILE_CHECK(buildBinding(v, prop, ctxt));
+            v->type = Value::PropertyBinding;
+        } else {
+            COMPILE_EXCEPTION(v, QCoreApplication::translate("QmlCompiler","Cannot assign primitives to lists"));
         }
-
     }
 
     return true;
@@ -2335,10 +2294,10 @@ bool QmlCompiler::buildDynamicMeta(QmlParser::Object *obj, DynamicMetaMode mode)
                     propertyType = QMetaType::QObjectStar;
                 } else {
                     readonly = true;
-                    type = "QmlList<";
+                    type = "QmlListProperty<";
                     type.append(customTypeName);
-                    type.append("*>*");
-                    propertyType = qMetaTypeId<QmlList<QObject*>* >();
+                    type.append(">");
+                    propertyType = qMetaTypeId<QmlListProperty<QObject> >();
                 }
             }
             break;
diff --git a/src/declarative/qml/qmlcontext.cpp b/src/declarative/qml/qmlcontext.cpp
index 303af42..56038cf 100644
--- a/src/declarative/qml/qmlcontext.cpp
+++ b/src/declarative/qml/qmlcontext.cpp
@@ -544,5 +544,30 @@ QUrl QmlContext::baseUrl() const
         return QUrl();
 }
 
+int QmlContextPrivate::context_count(QmlListProperty<QObject> *prop)
+{
+    QmlContext *context = static_cast<QmlContext*>(prop->object);
+    QmlContextPrivate *d = QmlContextPrivate::get(context);
+    int contextProperty = (int)(intptr_t)prop->data;
+
+    if (d->propertyValues.at(contextProperty).userType() != qMetaTypeId<QList<QObject*> >()) {
+        return 0;
+    } else {
+        return ((const QList<QObject> *)d->propertyValues.at(contextProperty).constData())->count();
+    }
+}
+
+QObject *QmlContextPrivate::context_at(QmlListProperty<QObject> *prop, int index)
+{
+    QmlContext *context = static_cast<QmlContext*>(prop->object);
+    QmlContextPrivate *d = QmlContextPrivate::get(context);
+    int contextProperty = (int)(intptr_t)prop->data;
+
+    if (d->propertyValues.at(contextProperty).userType() != qMetaTypeId<QList<QObject*> >()) {
+        return 0;
+    } else {
+        return ((const QList<QObject*> *)d->propertyValues.at(contextProperty).constData())->at(index);
+    }
+}
 
 QT_END_NAMESPACE
diff --git a/src/declarative/qml/qmlcontext.h b/src/declarative/qml/qmlcontext.h
index 21b1a1e..e96ed84 100644
--- a/src/declarative/qml/qmlcontext.h
+++ b/src/declarative/qml/qmlcontext.h
@@ -45,6 +45,7 @@
 #include <QtCore/qurl.h>
 #include <QtCore/qobject.h>
 #include <QtScript/qscriptvalue.h>
+#include <QtCore/qmetatype.h>
 
 QT_BEGIN_HEADER
 
@@ -97,9 +98,10 @@ private:
     QmlContext(QmlContext *parent, QObject *objParent, bool);
     QmlContext(QmlEngine *, bool);
 };
-
 QT_END_NAMESPACE
 
+Q_DECLARE_METATYPE(QList<QObject*>);
+
 QT_END_HEADER
 
 #endif // QMLCONTEXT_H
diff --git a/src/declarative/qml/qmlcontext_p.h b/src/declarative/qml/qmlcontext_p.h
index bd4f5d5..965eeed 100644
--- a/src/declarative/qml/qmlcontext_p.h
+++ b/src/declarative/qml/qmlcontext_p.h
@@ -152,6 +152,9 @@ public:
 
     // Only used for debugging
     QList<QPointer<QObject> > instances;
+
+    static int context_count(QmlListProperty<QObject> *);
+    static QObject *context_at(QmlListProperty<QObject> *, int);
 };
 
 QmlContextPrivate::IdNotifier::IdNotifier()
diff --git a/src/declarative/qml/qmlcontextscriptclass.cpp b/src/declarative/qml/qmlcontextscriptclass.cpp
index be3bbc3..4c71903 100644
--- a/src/declarative/qml/qmlcontextscriptclass.cpp
+++ b/src/declarative/qml/qmlcontextscriptclass.cpp
@@ -44,6 +44,7 @@
 #include "qmlengine_p.h"
 #include "qmlcontext_p.h"
 #include "qmltypenamescriptclass_p.h"
+#include "qmllistscriptclass_p.h"
 #include "qmlguard_p.h"
 
 QT_BEGIN_NAMESPACE
@@ -227,8 +228,12 @@ QmlContextScriptClass::property(Object *object, const Identifier &name)
         if (lastPropertyIndex < cp->idValueCount) {
             rv =  ep->objectClass->newQObject(cp->idValues[lastPropertyIndex].data());
         } else {
-            QVariant value = cp->propertyValues.at(lastPropertyIndex);
-            rv = ep->scriptValueFromVariant(value);
+            const QVariant &value = cp->propertyValues.at(lastPropertyIndex);
+            if (value.userType() == qMetaTypeId<QList<QObject*> >()) {
+                rv = ep->listClass->newList(QmlListProperty<QObject>(bindContext, (void*)lastPropertyIndex, 0, QmlContextPrivate::context_count, QmlContextPrivate::context_at), qMetaTypeId<QmlListProperty<QObject> >());
+            } else {
+                rv = ep->scriptValueFromVariant(value);
+            }
         }
 
         ep->capturedProperties << 
diff --git a/src/declarative/qml/qmldom.cpp b/src/declarative/qml/qmldom.cpp
index 01061ee..c75a299 100644
--- a/src/declarative/qml/qmldom.cpp
+++ b/src/declarative/qml/qmldom.cpp
@@ -1346,7 +1346,6 @@ QmlDomValue::Type QmlDomValue::type() const
 {
     if (d->property)
         if (QmlMetaType::isList(d->property->type) ||
-           QmlMetaType::isQmlList(d->property->type) ||
            (d->property && d->property->values.count() > 1))
             return List;
 
diff --git a/src/declarative/qml/qmlengine.cpp b/src/declarative/qml/qmlengine.cpp
index cf26f58..97d8250 100644
--- a/src/declarative/qml/qmlengine.cpp
+++ b/src/declarative/qml/qmlengine.cpp
@@ -66,6 +66,7 @@
 #include "qmlscriptclass_p.h"
 #include "qmlnetworkaccessmanagerfactory.h"
 #include "qmlimageprovider.h"
+#include "qmllist_p.h"
 
 #include <qfxperf_p_p.h>
 
@@ -107,7 +108,6 @@
 #endif
 
 Q_DECLARE_METATYPE(QmlMetaProperty)
-Q_DECLARE_METATYPE(QList<QObject *>);
 
 QT_BEGIN_NAMESPACE
 
@@ -1170,6 +1170,15 @@ QScriptValue QmlEnginePrivate::tint(QScriptContext *ctxt, QScriptEngine *engine)
 
 QScriptValue QmlEnginePrivate::scriptValueFromVariant(const QVariant &val)
 {
+    if (val.userType() == qMetaTypeId<QmlListReference>()) {
+        QmlListReferencePrivate *p = QmlListReferencePrivate::get((QmlListReference*)val.constData());
+        if (p->object) {
+            return listClass->newList(p->property, p->propertyType);
+        } else {
+            return scriptEngine.nullValue();
+        }
+    }
+
     bool objOk;
     QObject *obj = QmlMetaType::toQObject(val, &objOk);
     if (objOk) {
@@ -1667,7 +1676,7 @@ void QmlEnginePrivate::registerCompositeType(QmlCompiledData *data)
     QByteArray name = data->root->className();
 
     QByteArray ptr = name + '*';
-    QByteArray lst = "QmlList<" + ptr + ">*";
+    QByteArray lst = "QmlListProperty<" + name + ">";
 
     int ptr_type = QMetaType::registerType(ptr.constData(), voidptr_destructor,
                                            voidptr_constructor);
@@ -1679,9 +1688,18 @@ void QmlEnginePrivate::registerCompositeType(QmlCompiledData *data)
     data->addref();
 }
 
-bool QmlEnginePrivate::isQmlList(int t) const
+bool QmlEnginePrivate::isList(int t) const
 {
-    return m_qmlLists.contains(t) || QmlMetaType::isQmlList(t);
+    return m_qmlLists.contains(t) || QmlMetaType::isList(t);
+}
+
+int QmlEnginePrivate::listType(int t) const
+{
+    QHash<int, int>::ConstIterator iter = m_qmlLists.find(t);
+    if (iter != m_qmlLists.end())
+        return *iter;
+    else
+        return QmlMetaType::listType(t);
 }
 
 bool QmlEnginePrivate::isQObject(int t)
@@ -1700,21 +1718,12 @@ QObject *QmlEnginePrivate::toQObject(const QVariant &v, bool *ok) const
     }
 }
 
-int QmlEnginePrivate::qmlListType(int t) const
-{
-    QHash<int, int>::ConstIterator iter = m_qmlLists.find(t);
-    if (iter != m_qmlLists.end())
-        return *iter;
-    else
-        return QmlMetaType::qmlListType(t);
-}
-
 QmlMetaType::TypeCategory QmlEnginePrivate::typeCategory(int t) const
 {
     if (m_compositeTypes.contains(t))
         return QmlMetaType::Object;
     else if (m_qmlLists.contains(t))
-        return QmlMetaType::QmlList;
+        return QmlMetaType::List;
     else
         return QmlMetaType::typeCategory(t);
 }
diff --git a/src/declarative/qml/qmlengine_p.h b/src/declarative/qml/qmlengine_p.h
index 7ec6dd6..3fe7991 100644
--- a/src/declarative/qml/qmlengine_p.h
+++ b/src/declarative/qml/qmlengine_p.h
@@ -274,11 +274,12 @@ public:
 
 
     void registerCompositeType(QmlCompiledData *);
-    bool isQmlList(int) const;
+
     bool isQObject(int);
     QObject *toQObject(const QVariant &, bool *ok = 0) const;
-    int qmlListType(int) const;
     QmlMetaType::TypeCategory typeCategory(int) const;
+    bool isList(int) const;
+    int listType(int) const;
     const QMetaObject *rawMetaObjectForType(int) const;
     const QMetaObject *metaObjectForType(int) const;
     QHash<int, int> m_qmlLists;
@@ -322,7 +323,6 @@ public:
     QmlContext *getContext(QScriptContext *);
 };
 
-
 QT_END_NAMESPACE
 
 #endif // QMLENGINE_P_H
diff --git a/src/declarative/qml/qmlenginedebug.cpp b/src/declarative/qml/qmlenginedebug.cpp
index d3caa95..654157c 100644
--- a/src/declarative/qml/qmlenginedebug.cpp
+++ b/src/declarative/qml/qmlenginedebug.cpp
@@ -119,8 +119,7 @@ QmlEngineDebugServer::propertyData(QObject *obj, int propIdx)
         rv.type = QmlObjectProperty::Basic;
     } else if (QmlMetaType::isQObject(prop.userType()))  {
         rv.type = QmlObjectProperty::Object;
-    } else if (QmlMetaType::isList(prop.userType()) ||
-               QmlMetaType::isQmlList(prop.userType())) {
+    } else if (QmlMetaType::isList(prop.userType())) {
         rv.type = QmlObjectProperty::List;
     }
 
@@ -133,14 +132,15 @@ QVariant QmlEngineDebugServer::valueContents(const QVariant &value) const
     if (QVariant::Type(userType) < QVariant::UserType)
         return value;
 
-
-    if (QmlMetaType::isList(userType) || QmlMetaType::isQmlList(userType)) {
+    /*
+    if (QmlMetaType::isList(userType)) {
         int count = QmlMetaType::listCount(value);
         QVariantList contents;
         for (int i=0; i<count; i++)
             contents << valueContents(QmlMetaType::listAt(value, i));
         return contents;
-    } else if (QmlMetaType::isQObject(userType)) {
+    } else */
+    if (QmlMetaType::isQObject(userType)) {
         QObject *o = QmlMetaType::toQObject(value);
         if (o) {
             QString name = o->objectName();
diff --git a/src/declarative/qml/qmlexpression.cpp b/src/declarative/qml/qmlexpression.cpp
index d428377..8f0c945 100644
--- a/src/declarative/qml/qmlexpression.cpp
+++ b/src/declarative/qml/qmlexpression.cpp
@@ -52,8 +52,6 @@
 
 #include <private/qscriptdeclarativeclass_p.h>
 
-Q_DECLARE_METATYPE(QList<QObject *>);
-
 QT_BEGIN_NAMESPACE
 
 bool QmlDelayedError::addError(QmlEnginePrivate *e)
diff --git a/src/declarative/qml/qmlinstruction.cpp b/src/declarative/qml/qmlinstruction.cpp
index de01bfe..e37ade7 100644
--- a/src/declarative/qml/qmlinstruction.cpp
+++ b/src/declarative/qml/qmlinstruction.cpp
@@ -171,9 +171,6 @@ void QmlCompiledData::dump(QmlInstruction *instr, int idx)
     case QmlInstruction::BeginObject:
         qWarning().nospace() << idx << "\t\t" << line << "\t" << "BEGIN\t\t\t" << instr->begin.castValue;
         break;
-    case QmlInstruction::StoreObjectQmlList:
-        qWarning().nospace() << idx << "\t\t" << line << "\t" << "STORE_OBJECT_QMLLIST";
-        break;
     case QmlInstruction::StoreObjectQList:
         qWarning().nospace() << idx << "\t\t" << line << "\t" << "STORE_OBJECT_QLIST";
         break;
@@ -183,9 +180,6 @@ void QmlCompiledData::dump(QmlInstruction *instr, int idx)
     case QmlInstruction::FetchAttached:
         qWarning().nospace() << idx << "\t\t" << line << "\t" << "FETCH_ATTACHED\t\t" << instr->fetchAttached.id;
         break;
-    case QmlInstruction::FetchQmlList:
-        qWarning().nospace() << idx << "\t\t" << line << "\t" << "FETCH_QMLLIST\t\t" << instr->fetchQmlList.property << "\t" << instr->fetchQmlList.type;
-        break;
     case QmlInstruction::FetchQList:
         qWarning().nospace() << idx << "\t\t" << line << "\t" << "FETCH_QLIST\t\t" << instr->fetch.property;
         break;
diff --git a/src/declarative/qml/qmlinstruction_p.h b/src/declarative/qml/qmlinstruction_p.h
index 5613888..ea785b6 100644
--- a/src/declarative/qml/qmlinstruction_p.h
+++ b/src/declarative/qml/qmlinstruction_p.h
@@ -134,12 +134,10 @@ public:
 
         BeginObject,              /* begin */
 
-        StoreObjectQmlList,       /* NA */
         StoreObjectQList,         /* NA */
         AssignObjectList,         /* NA */
 
         FetchAttached,            /* fetchAttached */
-        FetchQmlList,             /* fetchQmlList */ 
         FetchQList,               /* fetch */
         FetchObject,              /* fetch */
         FetchValueType,           /* fetchValue */
diff --git a/src/declarative/qml/qmllist.cpp b/src/declarative/qml/qmllist.cpp
new file mode 100644
index 0000000..4cd2120
--- /dev/null
+++ b/src/declarative/qml/qmllist.cpp
@@ -0,0 +1,312 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qmllist.h"
+#include "qmllist_p.h"
+#include "qmlengine_p.h"
+#include "qmlmetaproperty_p.h"
+
+QT_BEGIN_NAMESPACE
+
+QmlListReferencePrivate::QmlListReferencePrivate()
+: propertyType(-1), refCount(1)
+{
+}
+
+QmlListReference QmlListReferencePrivate::init(const QmlListProperty<QObject> &prop, int propType, QmlEngine *engine)
+{
+    QmlListReference rv;
+
+    if (!prop.object) return rv;
+
+    QmlEnginePrivate *p = engine?QmlEnginePrivate::get(engine):0;
+
+    int listType = p?p->listType(propType):QmlMetaType::listType(propType);
+    if (listType == -1) return rv;
+
+    rv.d = new QmlListReferencePrivate;
+    rv.d->object = prop.object;
+    rv.d->elementType = p?p->rawMetaObjectForType(listType):QmlMetaType::qmlType(listType)->baseMetaObject();
+    rv.d->property = prop;
+    rv.d->propertyType = propType;
+
+    return rv;
+}
+
+void QmlListReferencePrivate::addref()
+{
+    Q_ASSERT(refCount > 0);
+    ++refCount;
+}
+
+void QmlListReferencePrivate::release()
+{
+    Q_ASSERT(refCount > 0);
+    --refCount;
+    if (!refCount)
+        delete this;
+}
+
+QmlListReference::QmlListReference()
+: d(0)
+{
+}
+
+QmlListReference::QmlListReference(QObject *o, const char *property, QmlEngine *engine)
+: d(0)
+{
+    if (!o || !property) return;
+
+    QmlPropertyCache::Data local;
+    QmlPropertyCache::Data *data = QmlPropertyCache::property(engine, o, QLatin1String(property), local);
+
+    if (!data || !(data->flags & QmlPropertyCache::Data::IsQList)) return;
+
+    QmlEnginePrivate *p = engine?QmlEnginePrivate::get(engine):0;
+
+    int listType = p?p->listType(data->propType):QmlMetaType::listType(data->propType);
+    if (listType == -1) return;
+
+    d = new QmlListReferencePrivate;
+    d->object = o;
+    d->elementType = p?p->rawMetaObjectForType(listType):QmlMetaType::qmlType(listType)->baseMetaObject();
+    d->propertyType = data->propType;
+
+    void *args[] = { &d->property, 0 };
+    QMetaObject::metacall(o, QMetaObject::ReadProperty, data->coreIndex, args);
+}
+
+QmlListReference::QmlListReference(const QmlListReference &o)
+: d(o.d)
+{
+    if (d) d->addref();
+}
+
+QmlListReference &QmlListReference::operator=(const QmlListReference &o)
+{
+    if (o.d) o.d->addref();
+    if (d) d->release();
+    d = o.d;
+    return *this;
+}
+
+QmlListReference::~QmlListReference()
+{
+    if (d) d->release();
+}
+
+bool QmlListReference::isValid() const
+{
+    return d && d->object;
+}
+
+QObject *QmlListReference::object() const
+{
+    if (isValid()) return d->object;
+    else return 0;
+}
+
+const QMetaObject *QmlListReference::listElementType() const
+{
+    if (isValid()) return d->elementType;
+    else return 0;
+}
+
+bool QmlListReference::canAppend() const
+{
+    return (isValid() && d->property.append);
+}
+
+bool QmlListReference::canAt() const
+{
+    return (isValid() && d->property.at);
+}
+
+bool QmlListReference::canClear() const
+{
+    return (isValid() && d->property.clear);
+}
+
+bool QmlListReference::canCount() const
+{
+    return (isValid() && d->property.count);
+}
+
+bool QmlListReference::append(QObject *o) const
+{
+    if (!canAppend()) return false;
+
+    if (o && !QmlMetaPropertyPrivate::canConvert(o->metaObject(), d->elementType))
+        return false;
+
+    d->property.append(&d->property, o);
+
+    return true;
+}
+
+QObject *QmlListReference::at(int index) const
+{
+    if (!canAt()) return 0;
+
+    return d->property.at(&d->property, index);
+}
+
+bool QmlListReference::clear() const
+{
+    if (!canClear()) return false;
+
+    d->property.clear(&d->property);
+
+    return true;
+}
+
+int QmlListReference::count() const
+{
+    if (!canCount()) return 0;
+
+    return d->property.count(&d->property);
+}
+
+/*!
+\class QmlListProperty
+\brief The QmlListProperty class allows applications to explose list-like 
+properties to QML.
+
+QML has many list properties, where more than one object value can be assigned.
+The use of a list property from QML looks like this:
+
+\code
+FruitBasket {
+    fruit: [ 
+             Apple {},
+             Orange{},
+             Banana {}
+           ]
+}
+\endcode
+
+The QmlListProperty encapsulates a group of function pointers that represet the
+set of actions QML can perform on the list - adding items, retrieving items and
+clearing the list.  In the future, additional operations may be supported.  All 
+list properties must implement the append operation, but the rest are optional.
+
+To provide a list property, a C++ class must implement the operation callbacks, 
+and then return an appropriate QmlListProperty value from the property getter.
+List properties should have no setter.  In the example above, the Q_PROPERTY()
+declarative will look like this:
+
+\code
+Q_PROPERTY(QmlListProperty<Fruit> fruit READ fruit);
+\endcode
+
+QML list properties are typesafe - in this case \c {Fruit} is a QObject type that 
+\c {Apple}, \c {Orange} and \c {Banana} all derive from.
+*/
+
+/*!
+\fn QmlListProperty::QmlListProperty() 
+\internal
+*/
+
+/*!
+\fn QmlListProperty::QmlListProperty(QObject *object, QList<T *> &list)
+
+Convenience constructor for making a QmlListProperty value from an existing
+QList \a list.  The \a list reference must remain valid for as long as \a object
+exists.  \a object must be provided.
+
+Generally this constructor should not be used in production code, as a 
+writable QList violates QML's memory management rules.  However, this constructor
+can very useful while prototyping.
+*/
+
+/*!
+\fn QmlListProperty::QmlListProperty(QObject *object, void *data, AppendFunction append, 
+                                     CountFunction count = 0, AtFunction at = 0, 
+                                     ClearFunction clear = 0)
+
+Construct a QmlListProperty from a set of operation functions.  An opaque \a data handle
+may be passed which can be accessed from within the operation functions.  The list property 
+remains valid while \a object exists.
+
+The \a append operation is compulsory and must be provided, while the \a count, \a at and
+\a clear methods are optional.
+*/
+
+/*!
+\typedef QmlListProperty::AppendFunction
+
+Synonym for \c {void (*)(QmlListProperty<T> *property, T *value)}.
+
+Append the \a value to the list \a property.
+*/
+
+/*!
+\typedef QmlListProperty::CountFunction
+
+Synonym for \c {int (*)(QmlListProperty<T> *property)}.
+
+Return the number of elements in the list \a property.
+*/
+
+/*!
+\fn bool QmlListProperty::operator==(const QmlListProperty &other) const 
+
+Returns true if this QmlListProperty is equal to \a other, otherwise false.
+*/
+
+/*!
+\typedef QmlListProperty::AtFunction
+
+Synonym for \c {T *(*)(QmlListProperty<T> *property, int index)}.
+
+Return the element at position \a index in the list \a property.
+*/
+
+/*!
+\typedef QmlListProperty::ClearFunction
+
+Synonym for \c {void (*)(QmlListProperty<T> *property)}.
+
+Clear the list \a property.
+*/
+
+QT_END_NAMESPACE
diff --git a/src/declarative/qml/qmllist.h b/src/declarative/qml/qmllist.h
index 261145d..cedc35b 100644
--- a/src/declarative/qml/qmllist.h
+++ b/src/declarative/qml/qmllist.h
@@ -51,73 +51,89 @@ QT_BEGIN_NAMESPACE
 QT_MODULE(Declarative)
 
 template<typename T>
-class QmlList : private QmlPrivate::ListInterface
-{
-public:
-    virtual void append(T) = 0;
-    virtual void insert(int, T) = 0;
-    virtual void removeAt(int) = 0;
-    virtual T at(int) const = 0;
-    virtual int count() const = 0;
-    virtual void clear() = 0;
-    QmlList<T> &operator<<(T t) { append(t); return *this; }
-
-protected:
-    virtual int type() const  { return qMetaTypeId<T>(); }
-    virtual void append(void *d) { const T &v = *(T *)d; append(v); }
-    virtual void insert(int i, void *d) { const T &v = *(T *)d; insert(i, v); }
-    virtual void at(int i, void *p) const { const T &v = at(i); *((T*)p) = v; }
+struct QmlListProperty {
+    typedef void (*AppendFunction)(QmlListProperty<T> *, T*);
+    typedef int (*CountFunction)(QmlListProperty<T> *);
+    typedef T *(*AtFunction)(QmlListProperty<T> *, int);
+    typedef void (*ClearFunction)(QmlListProperty<T> *);
+
+    QmlListProperty() 
+        : object(0), data(0), append(0), count(0), at(0), clear(0), dummy1(0), dummy2(0) {}
+    QmlListProperty(QObject *o, QList<T *> &list)
+        : object(o), data(&list), append(qlist_append), count(qlist_count), at(qlist_at),
+          clear(qlist_clear), dummy1(0), dummy2(0) {}
+    QmlListProperty(QObject *o, void *d, AppendFunction a, CountFunction c = 0, AtFunction t = 0, 
+                    ClearFunction r = 0)
+        : object(o), data(d), append(a), count(c), at(t), clear(r), dummy1(0), dummy2(0) {}
+
+    bool operator==(const QmlListProperty &o) const {
+        return object == o.object &&
+               data == o.data &&
+               append == o.append &&
+               count == o.count &&
+               at == o.at &&
+               clear == o.clear;
+    }
+
+    QObject *object;
+    void *data;
+    
+    AppendFunction append;
+
+    CountFunction count;
+    AtFunction at;
+
+    ClearFunction clear;
+
+    void *dummy1;
+    void *dummy2;
+
+private:
+    static void qlist_append(QmlListProperty *p, T *v) {
+        ((QList<T *> *)p->data)->append(v); 
+    }
+    static int qlist_count(QmlListProperty *p) {
+        return ((QList<T *> *)p->data)->count();
+    }
+    static T *qlist_at(QmlListProperty *p, int idx) {
+        return ((QList<T *> *)p->data)->at(idx);
+    }
+    static void qlist_clear(QmlListProperty *p) {
+        return ((QList<T *> *)p->data)->clear();
+    }
 };
 
-template<typename T>
-class QmlConcreteList : public QList<T>, public QmlList<T>
+class QmlEngine;
+class QmlListReferencePrivate;
+class Q_DECLARATIVE_EXPORT QmlListReference
 {
 public:
-    virtual void append(T v) { QList<T>::append(v); }
-    virtual void insert(int i, T v) { QList<T>::insert(i, v); }
-    virtual void clear() { QList<T>::clear(); }
-    virtual T at(int i) const { return QList<T>::at(i); }
-    virtual void removeAt(int i) { QList<T>::removeAt(i); }
-    virtual int count() const { return QList<T>::count(); }
-};
+    QmlListReference();
+    QmlListReference(QObject *, const char *property, QmlEngine * = 0);
+    QmlListReference(const QmlListReference &);
+    QmlListReference &operator=(const QmlListReference &);
+    ~QmlListReference();
+
+    bool isValid() const;
 
-#define QML_DECLARE_LIST_PROXY(ClassName, ListType, ListName) \
-class Qml_ProxyList_ ##ListName : public QmlList<ListType> \
-{ \
-    public: \
-        virtual void removeAt(int idx) \
-        { \
-            ClassName *p = (ClassName *)((char *)this + ((char *)(ClassName *)(0x10000000) - (char *)&((ClassName *)(0x10000000))->ListName)); \
-            p->ListName ## _removeAt(idx); \
-        } \
-        virtual int count() const \
-        { \
-            ClassName *p = (ClassName *)((char *)this + ((char *)(ClassName *)(0x10000000) - (char *)&((ClassName *)(0x10000000))->ListName)); \
-            return p->ListName ## _count(); \
-        } \
-        virtual void append(ListType v) \
-        { \
-            ClassName *p = (ClassName *)((char *)this + ((char *)(ClassName *)(0x10000000) - (char *)&((ClassName *)(0x10000000))->ListName)); \
-            p->ListName ## _append(v); \
-        } \
-        virtual void insert(int idx, ListType v) \
-        { \
-            ClassName *p = (ClassName *)((char *)this + ((char *)(ClassName *)(0x10000000) - (char *)&((ClassName *)(0x10000000))->ListName)); \
-            p->ListName ## _insert(idx, v); \
-        } \
-        virtual ListType at(int idx) const \
-        { \
-            ClassName *p = (ClassName *)((char *)this + ((char *)(ClassName *)(0x10000000) - (char *)&((ClassName *)(0x10000000))->ListName)); \
-            return p->ListName ## _at(idx); \
-        } \
-        virtual void clear() \
-        { \
-            ClassName *p = (ClassName *)((char *)this + ((char *)(ClassName *)(0x10000000) - (char *)&((ClassName *)(0x10000000))->ListName)); \
-            p->ListName ## _clear(); \
-        } \
-}; \
-friend class Qml_ProxyList_ ##ListName ; \
-Qml_ProxyList_##ListName ListName;
+    QObject *object() const;
+    const QMetaObject *listElementType() const;
+
+    bool canAppend() const;
+    bool canAt() const;
+    bool canClear() const;
+    bool canCount() const;
+
+    bool append(QObject *) const;
+    QObject *at(int) const;
+    bool clear() const;
+    int count() const;
+
+private:
+    friend class QmlListReferencePrivate;
+    QmlListReferencePrivate* d;
+};
+Q_DECLARE_METATYPE(QmlListReference);
 
 QT_END_NAMESPACE
 
diff --git a/src/declarative/qml/qmllist_p.h b/src/declarative/qml/qmllist_p.h
new file mode 100644
index 0000000..4660e47
--- /dev/null
+++ b/src/declarative/qml/qmllist_p.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMLLIST_P_H
+#define QMLLIST_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qmllist.h"
+#include "qmlguard_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QmlListReferencePrivate
+{
+public:
+    QmlListReferencePrivate();
+
+    static QmlListReference init(const QmlListProperty<QObject> &, int, QmlEngine *);
+
+    QmlGuard<QObject> object;
+    const QMetaObject *elementType;
+    QmlListProperty<QObject> property;
+    int propertyType;
+
+    void addref();
+    void release();
+    int refCount;
+
+    static inline QmlListReferencePrivate *get(QmlListReference *ref) {
+        return ref->d;
+    }
+};
+
+
+QT_END_NAMESPACE
+
+#endif // QMLLIST_P_H
diff --git a/src/declarative/qml/qmllistscriptclass.cpp b/src/declarative/qml/qmllistscriptclass.cpp
index d74a9b0..bb29763 100644
--- a/src/declarative/qml/qmllistscriptclass.cpp
+++ b/src/declarative/qml/qmllistscriptclass.cpp
@@ -43,13 +43,13 @@
 
 #include "qmlengine_p.h"
 #include "qmlguard_p.h"
+#include "qmllist_p.h"
 
 QT_BEGIN_NAMESPACE
 
 struct ListData : public QScriptDeclarativeClass::Object {
     QmlGuard<QObject> object;
-    int propertyIdx;
-    QmlListScriptClass::ListCategory type;
+    QmlListProperty<QObject> property;
     int propertyType;
 };
 
@@ -66,7 +66,7 @@ QmlListScriptClass::~QmlListScriptClass()
 {
 }
 
-QScriptValue QmlListScriptClass::newList(QObject *object, int propId, ListCategory type, int propType)
+QScriptValue QmlListScriptClass::newList(QObject *object, int propId, int propType)
 {
     QScriptEngine *scriptEngine = QmlEnginePrivate::getScriptEngine(engine);
 
@@ -75,8 +75,20 @@ QScriptValue QmlListScriptClass::newList(QObject *object, int propId, ListCatego
 
     ListData *data = new ListData;
     data->object = object;
-    data->propertyIdx = propId;
-    data->type = type;
+    data->propertyType = propType;
+    void *args[] = { &data->property, 0 };
+    QMetaObject::metacall(object, QMetaObject::ReadProperty, propId, args);
+
+    return newObject(scriptEngine, this, data);
+}
+
+QScriptValue QmlListScriptClass::newList(const QmlListProperty<QObject> &prop, int propType)
+{
+    QScriptEngine *scriptEngine = QmlEnginePrivate::getScriptEngine(engine);
+
+    ListData *data = new ListData;
+    data->object = prop.object;
+    data->property = prop;
     data->propertyType = propType;
 
     return newObject(scriptEngine, this, data);
@@ -111,39 +123,14 @@ QmlListScriptClass::ScriptValue QmlListScriptClass::property(Object *obj, const
     if (!data->object) 
         return Value();
 
-    void *list = 0;
-    void *args[] = { &list, 0 };
-    QMetaObject::metacall(data->object, QMetaObject::ReadProperty, 
-                          data->propertyIdx, args);
+    quint32 count = data->property.count?data->property.count(&data->property):0;
 
-    if (!list)
+    if (name == m_lengthId.identifier)
+        return Value(scriptEngine, count);
+    else if (lastIndex < count && data->property.at)
+        return Value(scriptEngine, enginePriv->objectClass->newQObject(data->property.at(&data->property, lastIndex)));
+    else
         return Value();
-
-    if (data->type == QListPtr) {
-        const QList<QObject *> &qlist = *((QList<QObject *>*)list);
-
-        quint32 count = qlist.count();
-
-        if (name == m_lengthId.identifier)
-            return Value(scriptEngine, count);
-        else if (lastIndex < count)
-            return Value(scriptEngine, enginePriv->objectClass->newQObject(qlist.at(lastIndex)));
-        else
-            return Value();
-
-    } else {
-        Q_ASSERT(data->type == QmlListPtr);
-        const QmlList<QObject *> &qmllist = *((QmlList<QObject *>*)list);
-
-        quint32 count = qmllist.count();
-
-        if (name == m_lengthId.identifier)
-            return Value(scriptEngine, count);
-        else if (lastIndex < count) 
-            return Value(scriptEngine, enginePriv->objectClass->newQObject(qmllist.at(lastIndex)));
-        else
-            return Value();
-    }
 }
 
 QVariant QmlListScriptClass::toVariant(Object *obj, bool *ok)
@@ -155,18 +142,7 @@ QVariant QmlListScriptClass::toVariant(Object *obj, bool *ok)
         return QVariant();
     }
 
-    void *list = 0;
-    void *args[] = { &list, 0 };
-    QMetaObject::metacall(data->object, QMetaObject::ReadProperty, 
-                          data->propertyIdx, args);
-
-    if (!list) {
-        if (ok) *ok = false;
-        return QVariant();
-    }
-
-    if (ok) *ok = true;
-    return QVariant(data->propertyType, &list);
+    return QVariant::fromValue(QmlListReferencePrivate::init(data->property, data->propertyType, engine));
 }
 
 QT_END_NAMESPACE
diff --git a/src/declarative/qml/qmllistscriptclass_p.h b/src/declarative/qml/qmllistscriptclass_p.h
index 92cf17f..07b09c3 100644
--- a/src/declarative/qml/qmllistscriptclass_p.h
+++ b/src/declarative/qml/qmllistscriptclass_p.h
@@ -54,6 +54,7 @@
 //
 
 #include <private/qmlscriptclass_p.h>
+#include "qmllist.h"
 
 QT_BEGIN_NAMESPACE
 
@@ -64,8 +65,8 @@ public:
     QmlListScriptClass(QmlEngine *);
     ~QmlListScriptClass();
 
-    enum ListCategory { QListPtr, QmlListPtr };
-    QScriptValue newList(QObject *, int, ListCategory, int);
+    QScriptValue newList(QObject *, int, int);
+    QScriptValue newList(const QmlListProperty<QObject> &, int);
 
 protected:
     virtual QScriptClass::QueryFlags queryProperty(Object *, const Identifier &, 
diff --git a/src/declarative/qml/qmlmetaproperty.cpp b/src/declarative/qml/qmlmetaproperty.cpp
index d7d4a07..7c273dc 100644
--- a/src/declarative/qml/qmlmetaproperty.cpp
+++ b/src/declarative/qml/qmlmetaproperty.cpp
@@ -52,16 +52,13 @@
 #include "qmlengine_p.h"
 #include "qmldeclarativedata_p.h"
 #include "qmlstringconverters_p.h"
-
-#include <qfxperf_p_p.h>
+#include "qmllist_p.h"
 
 #include <QStringList>
 #include <QtCore/qdebug.h>
 
 #include <math.h>
 
-Q_DECLARE_METATYPE(QList<QObject *>);
-
 QT_BEGIN_NAMESPACE
 
 /*!
@@ -213,7 +210,6 @@ QmlMetaProperty::QmlMetaProperty(const QmlMetaProperty &other)
   \value InvalidProperty The property is invalid.
   \value Bindable The property is a QmlBinding.
   \value List The property is a QList pointer
-  \value QmlList The property is a QmlList pointer
   \value Object The property is a QObject derived type pointer
   \value Normal The property is none of the above.
  */
@@ -257,8 +253,6 @@ QmlMetaPropertyPrivate::propertyCategory() const
             return QmlMetaProperty::Bindable;
         else if (core.flags & QmlPropertyCache::Data::IsQObjectDerived)
             return QmlMetaProperty::Object;
-        else if (core.flags & QmlPropertyCache::Data::IsQmlList)
-            return QmlMetaProperty::QmlList;
         else if (core.flags & QmlPropertyCache::Data::IsQList)
             return QmlMetaProperty::List;
         else 
@@ -401,7 +395,7 @@ bool QmlMetaProperty::isWritable() const
 
     if (!d->object)
         return false;
-    if (category == List || category == QmlList)
+    if (category == List)
         return true;
     else if (type() & SignalProperty)
         return false;
@@ -703,6 +697,13 @@ QVariant QmlMetaPropertyPrivate::readValueProperty()
         if (!ep) delete valueType;
         return rv;
 
+    } else if(core.flags & QmlPropertyCache::Data::IsQList) {
+
+        QmlListProperty<QObject> prop;
+        void *args[] = { &prop, 0 };
+        QMetaObject::metacall(object, QMetaObject::ReadProperty, core.coreIndex, args);
+        return QVariant::fromValue(QmlListReferencePrivate::init(prop, core.propType, context?context->engine():0));
+
     } else {
 
         return object->metaObject()->property(core.coreIndex).read(object.data());
@@ -813,9 +814,7 @@ bool QmlMetaPropertyPrivate::write(QObject *object, const QmlPropertyCache::Data
     int t = property.propType;
     int vt = value.userType();
 
-    QmlEnginePrivate *enginePriv = 0;
-    if (context && context->engine())
-        enginePriv = QmlEnginePrivate::get(context->engine());
+    QmlEnginePrivate *enginePriv = QmlEnginePrivate::get(context);
 
     if (t == QVariant::Url) {
 
@@ -880,55 +879,40 @@ bool QmlMetaPropertyPrivate::write(QObject *object, const QmlPropertyCache::Data
 
     } else if (property.flags & QmlPropertyCache::Data::IsQList) {
 
-        int listType = QmlMetaType::listType(t);
-        QMetaProperty prop = object->metaObject()->property(property.coreIndex);
-
-        if (value.userType() == qMetaTypeId<QList<QObject *> >()) {
-            const QList<QObject *> &list =
-                qvariant_cast<QList<QObject *> >(value);
-            QVariant listVar = prop.read(object);
-            QmlMetaType::clear(listVar);
-            for (int ii = 0; ii < list.count(); ++ii) {
-                QVariant v = QmlMetaType::qmlType(listType)->fromObject(list.at(ii)); 
-                QmlMetaType::append(listVar, v);
-            }
-
-        } else if (vt == listType ||
-                  value.userType() == listType) {
-            QVariant listVar = prop.read(object);
-            QmlMetaType::append(listVar, value);
+        const QMetaObject *listType = 0;
+        if (enginePriv) {
+            listType = enginePriv->rawMetaObjectForType(enginePriv->listType(property.propType));
+        } else {
+            QmlType *type = QmlMetaType::qmlType(QmlMetaType::listType(property.propType));
+            if (!type) return false;
+            listType = type->baseMetaObject();
         }
+        if (!listType) return false;
 
-    } else if (property.flags & QmlPropertyCache::Data::IsQmlList) {
+        QmlListProperty<void> prop;
+        void *args[] = { &prop, 0 };
+        QMetaObject::metacall(object, QMetaObject::ReadProperty, coreIdx, args);
 
-        // XXX - optimize!
-        QMetaProperty prop = object->metaObject()->property(property.coreIndex);
-        QVariant list = prop.read(object);
-        QmlPrivate::ListInterface *li =
-            *(QmlPrivate::ListInterface **)list.constData();
-
-        int type = li->type();
-
-        if (QObject *obj = QmlMetaType::toQObject(value)) {
-            const QMetaObject *mo = rawMetaObjectForType(enginePriv, type);
-
-            const QMetaObject *objMo = obj->metaObject();
-            bool found = false;
-            while(!found && objMo) {
-                if (equal(objMo, mo))
-                    found = true;
-                else
-                    objMo = objMo->superClass();
-            }
+        if (!prop.clear) return false;
 
-            if (!found) 
-                return false;
+        prop.clear(&prop);
+
+        if (value.userType() == qMetaTypeId<QList<QObject *> >()) {
+            const QList<QObject *> &list = qvariant_cast<QList<QObject *> >(value);
 
-            // NOTE: This assumes a cast to QObject does not alter
-            // the object pointer
-            void *d = (void *)&obj;
-            li->append(d);
+            for (int ii = 0; ii < list.count(); ++ii) {
+                QObject *o = list.at(ii);
+                if (!canConvert(o->metaObject(), listType))
+                    o = 0;
+                prop.append(&prop, (void *)o);
+            }
+        } else {
+            QObject *o = enginePriv?enginePriv->toQObject(value):QmlMetaType::toQObject(value);
+            if (!canConvert(o->metaObject(), listType))
+                o = 0;
+            prop.append(&prop, (void *)o);
         }
+
     } else {
         Q_ASSERT(vt != t);
 
diff --git a/src/declarative/qml/qmlmetaproperty.h b/src/declarative/qml/qmlmetaproperty.h
index 723fc50..82266c8 100644
--- a/src/declarative/qml/qmlmetaproperty.h
+++ b/src/declarative/qml/qmlmetaproperty.h
@@ -68,7 +68,6 @@ public:
         InvalidProperty,
         Bindable,
         List,
-        QmlList,    //XXX
         Object,
         Normal
     };
diff --git a/src/declarative/qml/qmlmetatype.cpp b/src/declarative/qml/qmlmetatype.cpp
index b94a815..6db70d4 100644
--- a/src/declarative/qml/qmlmetatype.cpp
+++ b/src/declarative/qml/qmlmetatype.cpp
@@ -100,7 +100,6 @@ struct QmlMetaTypeData
 
     QBitArray objects;
     QBitArray interfaces;
-    QBitArray qmllists;
     QBitArray lists;
 };
 Q_GLOBAL_STATIC(QmlMetaTypeData, metaTypeData)
@@ -124,8 +123,8 @@ public:
     QByteArray m_name;
     int m_version_maj;
     int m_version_min;
-    int m_typeId; int m_listId; int m_qmlListId;
-    QmlPrivate::Func m_opFunc;
+    int m_typeId; int m_listId; 
+    QObject *(*m_newFunc)();
     const QMetaObject *m_baseMetaObject;
     QmlAttachedPropertiesFunc m_attachedPropertiesFunc;
     const QMetaObject *m_attachedPropertiesType;
@@ -141,32 +140,30 @@ public:
 };
 
 QmlTypePrivate::QmlTypePrivate()
-: m_isInterface(false), m_iid(0), m_typeId(0), m_listId(0), m_qmlListId(0),
-  m_opFunc(0), m_baseMetaObject(0), m_attachedPropertiesFunc(0), m_attachedPropertiesType(0),
+: m_isInterface(false), m_iid(0), m_typeId(0), m_listId(0), 
+  m_newFunc(0), m_baseMetaObject(0), m_attachedPropertiesFunc(0), m_attachedPropertiesType(0),
   m_parserStatusCast(-1), m_propertyValueSourceCast(-1), m_propertyValueInterceptorCast(-1),
   m_extFunc(0), m_extMetaObject(0), m_index(-1), m_customParser(0), m_isSetup(false)
 {
 }
 
 
-QmlType::QmlType(int type, int listType, int qmlListType,
-                 QmlPrivate::Func opFunc, const char *iid, int index)
+QmlType::QmlType(int type, int listType, const char *iid, int index)
 : d(new QmlTypePrivate)
 {
     d->m_isInterface = true;
     d->m_iid = iid;
     d->m_typeId = type;
     d->m_listId = listType;
-    d->m_qmlListId = qmlListType;
-    d->m_opFunc = opFunc;
+    d->m_newFunc = 0;
     d->m_index = index;
     d->m_isSetup = true;
     d->m_version_maj = 0;
     d->m_version_min = 0;
 }
 
-QmlType::QmlType(int type, int listType, int qmlListType,
-                 QmlPrivate::Func opFunc, const char *qmlName,
+QmlType::QmlType(int type, int listType, 
+                 QObject *(*newFunc)(), const char *qmlName,
                  int version_maj, int version_min,
                  const QMetaObject *metaObject,
                  QmlAttachedPropertiesFunc attachedPropertiesFunc,
@@ -182,8 +179,7 @@ QmlType::QmlType(int type, int listType, int qmlListType,
     d->m_version_min = version_min;
     d->m_typeId = type;
     d->m_listId = listType;
-    d->m_qmlListId = qmlListType;
-    d->m_opFunc = opFunc;
+    d->m_newFunc = newFunc;
     d->m_baseMetaObject = metaObject;
     d->m_attachedPropertiesFunc = attachedPropertiesFunc;
     d->m_attachedPropertiesType = attachedType;
@@ -283,10 +279,7 @@ QObject *QmlType::create() const
 {
     d->init();
 
-    QVariant v;
-    QObject *rv = 0;
-    d->m_opFunc(QmlPrivate::Create, 0, v, v, (void **)&rv);
-
+    QObject *rv = d->m_newFunc();
     if (rv && !d->m_metaObjects.isEmpty())
         (void *)new QmlProxyMetaObject(rv, &d->m_metaObjects);
 
@@ -313,39 +306,6 @@ int QmlType::qListTypeId() const
     return d->m_listId;
 }
 
-int QmlType::qmlListTypeId() const
-{
-    return d->m_qmlListId;
-}
-
-void QmlType::listClear(const QVariant &list)
-{
-    Q_ASSERT(list.userType() == qListTypeId());
-    QVariant arg;
-    d->m_opFunc(QmlPrivate::Clear, 0, list, arg, 0);
-}
-
-void QmlType::listAppend(const QVariant &list, const QVariant &item)
-{
-    Q_ASSERT(list.userType() == qListTypeId());
-    d->m_opFunc(QmlPrivate::Append, 0, list, item, 0);
-}
-
-QVariant QmlType::listAt(const QVariant &list, int idx)
-{
-    Q_ASSERT(list.userType() == qListTypeId());
-    QVariant rv;
-    void *ptr = (void *)&rv;
-    d->m_opFunc(QmlPrivate::Value, idx, list, QVariant(), &ptr);
-    return rv;
-}
-
-int QmlType::listCount(const QVariant &list)
-{
-    Q_ASSERT(list.userType() == qListTypeId());
-    return d->m_opFunc(QmlPrivate::Length, 0, list, QVariant(), 0);
-}
-
 const QMetaObject *QmlType::metaObject() const
 {
     d->init();
@@ -387,15 +347,6 @@ int QmlType::propertyValueInterceptorCast() const
     return d->m_propertyValueInterceptorCast;
 }
 
-QVariant QmlType::fromObject(QObject *obj) const
-{
-    QVariant rv;
-    QVariant *v_ptr = &rv;
-    QVariant vobj = QVariant::fromValue(obj);
-    d->m_opFunc(QmlPrivate::FromObject, 0, QVariant(), vobj, (void **)&v_ptr);
-    return rv;
-}
-
 const char *QmlType::interfaceIId() const
 {
     return d->m_iid;
@@ -407,7 +358,6 @@ int QmlType::index() const
 }
 
 int QmlMetaType::registerInterface(const QmlPrivate::MetaTypeIds &id,
-                                    QmlPrivate::Func listFunction,
                                     const char *iid)
 {
     QWriteLocker lock(metaTypeDataLock());
@@ -415,31 +365,26 @@ int QmlMetaType::registerInterface(const QmlPrivate::MetaTypeIds &id,
 
     int index = data->types.count();
 
-    QmlType *type = new QmlType(id.typeId, id.listId, id.qmlListId,
-                                listFunction, iid, index);
+    QmlType *type = new QmlType(id.typeId, id.listId, iid, index);
 
     data->types.append(type);
     data->idToType.insert(type->typeId(), type);
     data->idToType.insert(type->qListTypeId(), type);
-    data->idToType.insert(type->qmlListTypeId(), type);
     // XXX No insertMulti, so no multi-version interfaces?
     if (!type->qmlTypeName().isEmpty())
         data->nameToType.insert(type->qmlTypeName(), type);
 
-    if (data->interfaces.size() < id.typeId)
+    if (data->interfaces.size() <= id.typeId)
         data->interfaces.resize(id.typeId + 16);
-    if (data->qmllists.size() < id.qmlListId)
-        data->qmllists.resize(id.qmlListId + 16);
-    if (data->lists.size() < id.listId)
+    if (data->lists.size() <= id.listId)
         data->lists.resize(id.listId + 16);
     data->interfaces.setBit(id.typeId, true);
-    data->qmllists.setBit(id.qmlListId, true);
     data->lists.setBit(id.listId, true);
 
     return index;
 }
 
-int QmlMetaType::registerType(const QmlPrivate::MetaTypeIds &id, QmlPrivate::Func func,
+int QmlMetaType::registerType(const QmlPrivate::MetaTypeIds &id, QObject *(*func)(),
         const char *uri, int version_maj, int version_min, const char *cname,
         const QMetaObject *mo, QmlAttachedPropertiesFunc attach, const QMetaObject *attachMo,
         int pStatus, int object, int valueSource, int valueInterceptor, QmlPrivate::CreateFunc extFunc, const QMetaObject *extmo, QmlCustomParser *parser)
@@ -464,14 +409,13 @@ int QmlMetaType::registerType(const QmlPrivate::MetaTypeIds &id, QmlPrivate::Fun
         name += '/';
     name += cname;
 
-    QmlType *type = new QmlType(id.typeId, id.listId, id.qmlListId,
+    QmlType *type = new QmlType(id.typeId, id.listId, 
                                 func, name, version_maj, version_min, mo, attach, attachMo, pStatus,
                                 valueSource, valueInterceptor, extFunc, extmo, index, parser);
 
     data->types.append(type);
     data->idToType.insert(type->typeId(), type);
     data->idToType.insert(type->qListTypeId(), type);
-    data->idToType.insert(type->qmlListTypeId(), type);
 
     if (!type->qmlTypeName().isEmpty())
         data->nameToType.insertMulti(type->qmlTypeName(), type);
@@ -480,12 +424,9 @@ int QmlMetaType::registerType(const QmlPrivate::MetaTypeIds &id, QmlPrivate::Fun
 
     if (data->objects.size() <= id.typeId)
         data->objects.resize(id.typeId + 16);
-    if (data->qmllists.size() <= id.qmlListId)
-        data->qmllists.resize(id.qmlListId + 16);
     if (data->lists.size() <= id.listId)
         data->lists.resize(id.listId + 16);
     data->objects.setBit(id.typeId, true);
-    data->qmllists.setBit(id.qmlListId, true);
     data->lists.setBit(id.listId, true);
 
     return index;
@@ -527,51 +468,6 @@ int QmlMetaType::listType(int id)
         return 0;
 }
 
-/*
-    Returns the item type for a qml list of type \a id.
- */
-int QmlMetaType::qmlListType(int id)
-{
-    QReadLocker lock(metaTypeDataLock());
-    QmlMetaTypeData *data = metaTypeData();
-    QmlType *type = data->idToType.value(id);
-    if (type && type->qmlListTypeId() == id)
-        return type->typeId();
-    else
-        return 0;
-}
-
-bool QmlMetaType::clear(const QVariant &list)
-{
-    int userType = list.userType();
-    QReadLocker lock(metaTypeDataLock());
-    QmlMetaTypeData *data = metaTypeData();
-    QmlType *type = data->idToType.value(userType);
-    lock.unlock();
-    if (type && type->qListTypeId() == userType) {
-        type->listClear(list);
-        return true;
-    } else {
-        return false;
-    }
-}
-
-bool QmlMetaType::append(const QVariant &list, const QVariant &item)
-{
-    int userType = list.userType();
-    QReadLocker lock(metaTypeDataLock());
-    QmlMetaTypeData *data = metaTypeData();
-    QmlType *type = data->idToType.value(userType);
-    lock.unlock();
-    if (type && type->qListTypeId() == userType &&
-       item.userType() == type->typeId()) {
-        type->listAppend(list, item);
-        return true;
-    } else {
-        return false;
-    }
-}
-
 int QmlMetaType::attachedPropertiesFuncId(const QMetaObject *mo)
 {
     QReadLocker lock(metaTypeDataLock());
@@ -656,8 +552,6 @@ QmlMetaType::TypeCategory QmlMetaType::typeCategory(int userType)
     QmlMetaTypeData *data = metaTypeData();
     if (userType < data->objects.size() && data->objects.testBit(userType))
         return Object;
-    else if (userType < data->qmllists.size() && data->qmllists.testBit(userType))
-        return QmlList;
     else if (userType < data->lists.size() && data->lists.testBit(userType))
         return List;
     else
@@ -683,13 +577,6 @@ const char *QmlMetaType::interfaceIId(int userType)
         return 0;
 }
 
-bool QmlMetaType::isQmlList(int userType)
-{
-    QReadLocker lock(metaTypeDataLock());
-    QmlMetaTypeData *data = metaTypeData();
-    return userType >= 0 && userType < data->qmllists.size() && data->qmllists.testBit(userType);
-}
-
 bool QmlMetaType::isList(int userType)
 {
     QReadLocker lock(metaTypeDataLock());
@@ -697,44 +584,6 @@ bool QmlMetaType::isList(int userType)
     return userType >= 0 && userType < data->lists.size() && data->lists.testBit(userType);
 }
 
-bool QmlMetaType::isList(const QVariant &v)
-{
-    return (v.type() == QVariant::UserType && isList(v.userType()));
-}
-
-int QmlMetaType::listCount(const QVariant &v)
-{
-    int userType = v.userType();
-
-    QReadLocker lock(metaTypeDataLock());
-    QmlMetaTypeData *data = metaTypeData();
-    QmlType *type = data->idToType.value(userType);
-    lock.unlock();
-
-    if (type && type->qListTypeId() == userType)
-        return type->listCount(v);
-    else
-        return 0;
-}
-
-QVariant QmlMetaType::listAt(const QVariant &v, int idx)
-{
-    if (idx < 0)
-        return QVariant();
-
-    int userType = v.userType();
-
-    QReadLocker lock(metaTypeDataLock());
-    QmlMetaTypeData *data = metaTypeData();
-    QmlType *type = data->idToType.value(userType);
-    lock.unlock();
-
-    if (type && type->qListTypeId() == userType)
-        return type->listAt(v, idx);
-    else
-        return QVariant();
-}
-
 /*!
     A custom string convertor allows you to specify a function pointer that
     returns a variant of \a type. For example, if you have written your own icon
diff --git a/src/declarative/qml/qmlmetatype.h b/src/declarative/qml/qmlmetatype.h
index 3d082f8..98d04c1 100644
--- a/src/declarative/qml/qmlmetatype.h
+++ b/src/declarative/qml/qmlmetatype.h
@@ -46,6 +46,7 @@
 #include "qmlparserstatus.h"
 #include "qmlpropertyvaluesource.h"
 #include "qmlpropertyvalueinterceptor.h"
+#include "qmllist.h"
 
 #include <QtCore/qglobal.h>
 #include <QtCore/qvariant.h>
@@ -62,8 +63,8 @@ class QmlCustomParser;
 class Q_DECLARATIVE_EXPORT QmlMetaType
 {
 public:
-    static int registerType(const QmlPrivate::MetaTypeIds &, QmlPrivate::Func, const char *, int vmaj, int vmin, const char *qmlName, const QMetaObject *, QmlAttachedPropertiesFunc, const QMetaObject *, int pStatus, int object, int valueSource, int valueInterceptor, QmlPrivate::CreateFunc extFunc, const QMetaObject *extmo, QmlCustomParser *);
-    static int registerInterface(const QmlPrivate::MetaTypeIds &, QmlPrivate::Func, const char *);
+    static int registerType(const QmlPrivate::MetaTypeIds &, QObject *(*)(), const char *, int vmaj, int vmin, const char *qmlName, const QMetaObject *, QmlAttachedPropertiesFunc, const QMetaObject *, int pStatus, int object, int valueSource, int valueInterceptor, QmlPrivate::CreateFunc extFunc, const QMetaObject *extmo, QmlCustomParser *);
+    static int registerInterface(const QmlPrivate::MetaTypeIds &, const char *);
 
     static bool copy(int type, void *data, const void *copy = 0);
 
@@ -83,22 +84,15 @@ public:
     static QObject *toQObject(const QVariant &, bool *ok = 0);
 
     static int listType(int);
-    static bool clear(const QVariant &);
-    static bool append(const QVariant &, const QVariant &);
     static int attachedPropertiesFuncId(const QMetaObject *);
     static QmlAttachedPropertiesFunc attachedPropertiesFuncById(int);
 
-    enum TypeCategory { Unknown, Object, List, QmlList };
+    enum TypeCategory { Unknown, Object, List };
     static TypeCategory typeCategory(int);
         
     static bool isInterface(int);
     static const char *interfaceIId(int);
     static bool isList(int);
-    static bool isList(const QVariant &);
-    static bool isQmlList(int);
-    static int qmlListType(int);
-    static int listCount(const QVariant &);
-    static QVariant listAt(const QVariant &, int);
 
     typedef QVariant (*StringConverter)(const QString &);
     static void registerCustomStringConverter(int, StringConverter);
@@ -123,12 +117,6 @@ public:
     bool isInterface() const;
     int typeId() const;
     int qListTypeId() const;
-    int qmlListTypeId() const;
-
-    void listClear(const QVariant &);
-    void listAppend(const QVariant &, const QVariant &);
-    QVariant listAt(const QVariant &, int);
-    int listCount(const QVariant &);
 
     const QMetaObject *metaObject() const;
     const QMetaObject *baseMetaObject() const;
@@ -147,8 +135,8 @@ private:
     friend class QmlMetaType;
     friend class QmlTypePrivate;
     friend struct QmlMetaTypeData;
-    QmlType(int, int, int, QmlPrivate::Func, const char *, int);
-    QmlType(int, int, int, QmlPrivate::Func, const char *, int, int, const QMetaObject *, QmlAttachedPropertiesFunc, const QMetaObject *, int, int, int, QmlPrivate::CreateFunc, const QMetaObject *, int, QmlCustomParser *);
+    QmlType(int, int, const char *, int);
+    QmlType(int, int, QObject *(*)(), const char *, int, int, const QMetaObject *, QmlAttachedPropertiesFunc, const QMetaObject *, int, int, int, QmlPrivate::CreateFunc, const QMetaObject *, int, QmlCustomParser *);
     ~QmlType();
 
     QmlTypePrivate *d;
@@ -160,11 +148,10 @@ int qmlRegisterType(const char *typeName)
     QByteArray name(typeName);
     QmlPrivate::MetaTypeIds ids = {
         qRegisterMetaType<T *>(QByteArray(name + '*').constData()),
-        qRegisterMetaType<T *>(QByteArray("QList<" + name + "*>*").constData()),
-        qRegisterMetaType<T *>(QByteArray("QmlList<" + name + "*>*").constData())
+        qRegisterMetaType<QmlListProperty<T> >(QByteArray("QmlListProperty<" + name + ">").constData()),
     };
 
-    return QmlMetaType::registerType(ids, QmlPrivate::list_nocreate_op<T>, 0, 0, 0, 0,
+    return QmlMetaType::registerType(ids, 0, 0, 0, 0, 0,
             &T::staticMetaObject,
             QmlPrivate::attachedPropertiesFunc<T>(),
             QmlPrivate::attachedPropertiesMetaObject<T>(),
@@ -181,11 +168,10 @@ int qmlRegisterType(const char *uri, int version_maj, int version_min, const cha
     QByteArray name(typeName);
     QmlPrivate::MetaTypeIds ids = {
         qRegisterMetaType<T *>(QByteArray(name + '*').constData()),
-        qRegisterMetaType<T *>(QByteArray("QList<" + name + "*>*").constData()),
-        qRegisterMetaType<T *>(QByteArray("QmlList<" + name + "*>*").constData())
+        qRegisterMetaType<QmlListProperty<T> >(QByteArray("QmlListProperty<" + name + ">").constData()),
     };
 
-    return QmlMetaType::registerType(ids, QmlPrivate::list_op<T>,
+    return QmlMetaType::registerType(ids, QmlPrivate::create<T>, 
             uri, version_maj, version_min, qmlName, 
             &T::staticMetaObject,
             QmlPrivate::attachedPropertiesFunc<T>(),
@@ -203,8 +189,7 @@ int qmlRegisterExtendedType(const char *typeName)
     QByteArray name(typeName);
     QmlPrivate::MetaTypeIds ids = {
         qRegisterMetaType<T *>(QByteArray(name + '*').constData()),
-        qRegisterMetaType<T *>(QByteArray("QList<" + name + "*>*").constData()),
-        qRegisterMetaType<T *>(QByteArray("QmlList<" + name + "*>*").constData())
+        qRegisterMetaType<QmlListProperty<T> >(QByteArray("QmlListProperty<" + name + ">").constData()),
     };
 
     QmlAttachedPropertiesFunc attached = 
@@ -216,7 +201,7 @@ int qmlRegisterExtendedType(const char *typeName)
         attachedMo = QmlPrivate::attachedPropertiesMetaObject<T>();
     }
 
-    return QmlMetaType::registerType(ids, QmlPrivate::list_nocreate_op<T>, 0, 0, 0, 0,
+    return QmlMetaType::registerType(ids, 0, 0, 0, 0, 0,
             &T::staticMetaObject, attached, attachedMo,
             QmlPrivate::StaticCastSelector<T,QmlParserStatus>::cast(), 
             QmlPrivate::StaticCastSelector<T,QObject>::cast(),
@@ -231,8 +216,7 @@ int qmlRegisterExtendedType(const char *uri, int version_maj, int version_min, c
     QByteArray name(typeName);
     QmlPrivate::MetaTypeIds ids = {
         qRegisterMetaType<T *>(QByteArray(name + '*').constData()),
-        qRegisterMetaType<T *>(QByteArray("QList<" + name + "*>*").constData()),
-        qRegisterMetaType<T *>(QByteArray("QmlList<" + name + "*>*").constData())
+        qRegisterMetaType<QmlListProperty<T> >(QByteArray("QmlListProperty<" + name + ">").constData()),
     };
 
     QmlAttachedPropertiesFunc attached = 
@@ -244,7 +228,7 @@ int qmlRegisterExtendedType(const char *uri, int version_maj, int version_min, c
         attachedMo = QmlPrivate::attachedPropertiesMetaObject<T>();
     }
 
-    return QmlMetaType::registerType(ids, QmlPrivate::list_op<T>, 
+    return QmlMetaType::registerType(ids, QmlPrivate::create<T>, 
             uri, version_maj, version_min, qmlName, 
             &T::staticMetaObject,
             attached, attachedMo,
@@ -262,13 +246,10 @@ int qmlRegisterInterface(const char *typeName)
     QByteArray name(typeName);
     QmlPrivate::MetaTypeIds ids = {
         qRegisterMetaType<T *>(QByteArray(name + '*').constData()),
-        qRegisterMetaType<T *>(QByteArray("QList<" + name + "*>*").constData()),
-        qRegisterMetaType<T *>(QByteArray("QmlList<" + name + "*>*").constData())
+        qRegisterMetaType<QmlListProperty<T> >(QByteArray("QmlListProperty<" + name + ">").constData()),
     };
 
-    return QmlMetaType::registerInterface(ids, 
-            QmlPrivate::list_interface_op<T>, 
-            qobject_interface_iid<T *>());
+    return QmlMetaType::registerInterface(ids, qobject_interface_iid<T *>());
 }
 
 template<typename T>
@@ -277,11 +258,10 @@ int qmlRegisterCustomType(const char *uri, int version_maj, int version_min, con
     QByteArray name(typeName);
     QmlPrivate::MetaTypeIds ids = {
         qRegisterMetaType<T *>(QByteArray(name + '*').constData()),
-        qRegisterMetaType<T *>(QByteArray("QList<" + name + "*>*").constData()),
-        qRegisterMetaType<T *>(QByteArray("QmlList<" + name + "*>*").constData())
+        qRegisterMetaType<QmlListProperty<T> >(QByteArray("QmlListProperty<" + name + ">").constData()),
     };
 
-    return QmlMetaType::registerType(ids, QmlPrivate::list_op<T>,
+    return QmlMetaType::registerType(ids, QmlPrivate::create<T>, 
             uri, version_maj, version_min, qmlName, 
             &T::staticMetaObject,
             QmlPrivate::attachedPropertiesFunc<T>(),
diff --git a/src/declarative/qml/qmlobjectscriptclass.cpp b/src/declarative/qml/qmlobjectscriptclass.cpp
index 76d1837..15ece1d 100644
--- a/src/declarative/qml/qmlobjectscriptclass.cpp
+++ b/src/declarative/qml/qmlobjectscriptclass.cpp
@@ -239,9 +239,7 @@ QmlObjectScriptClass::property(QObject *obj, const Identifier &name)
         }
 
         if (lastData->flags & QmlPropertyCache::Data::IsQList) {
-            return Value(scriptEngine, enginePriv->listClass->newList(obj, lastData->coreIndex, QmlListScriptClass::QListPtr, lastData->propType));
-        } else if (lastData->flags & QmlPropertyCache::Data::IsQmlList) {
-            return Value(scriptEngine, enginePriv->listClass->newList(obj, lastData->coreIndex, QmlListScriptClass::QmlListPtr, lastData->propType));
+            return Value(scriptEngine, enginePriv->listClass->newList(obj, lastData->coreIndex, lastData->propType));
         } else if (lastData->flags & QmlPropertyCache::Data::IsQObjectDerived) {
             QObject *rv = 0;
             void *args[] = { &rv, 0 };
diff --git a/src/declarative/qml/qmlprivate.h b/src/declarative/qml/qmlprivate.h
index e087788..e5ea07f 100644
--- a/src/declarative/qml/qmlprivate.h
+++ b/src/declarative/qml/qmlprivate.h
@@ -72,39 +72,8 @@ public:
 
 namespace QmlPrivate
 {
-    class ListInterface
-    {
-    public:
-        virtual ~ListInterface() {}
-        virtual int type() const = 0;
-        virtual void append(void *) = 0;
-        virtual void insert(int, void *) = 0;
-        virtual void removeAt(int) = 0;
-        virtual void at(int, void *) const = 0;
-        virtual int count() const = 0;
-        virtual void clear() = 0;
-    };
-
-    enum ListOp { Append, Set, Insert, Prepend, Length, FromObject, 
-                  Object, Create, Value, Clear };
-
     template<typename T>
-    int list_op(ListOp op, int val, 
-                const QVariant &vlist, 
-                const QVariant &value, 
-                void **out);
-
-    template<typename T>
-    int list_nocreate_op(ListOp op, int val, 
-                         const QVariant &vlist, 
-                         const QVariant &value, 
-                         void **out);
-
-    template<typename T>
-    int list_interface_op(ListOp op, int val, 
-                          const QVariant &vlist, 
-                          const QVariant &value, 
-                          void **out);
+    QObject *create() { return new T; }
 
     template<class From, class To, int N>
     struct StaticCastSelectorClass
@@ -201,9 +170,7 @@ namespace QmlPrivate
     struct MetaTypeIds {
         int typeId;
         int listId;
-        int qmlListId;
     };
-    typedef int (*Func)(QmlPrivate::ListOp, int, const QVariant &, const QVariant &, void **);
     typedef QObject *(*CreateFunc)(QObject *);
 
     template<typename T>
@@ -237,148 +204,6 @@ namespace QmlPrivate
     };
 }
 
-template<typename T>
-int QmlPrivate::list_op(QmlPrivate::ListOp op, int val, 
-                        const QVariant &vlist, 
-                        const QVariant &value, 
-                        void **out) 
-{ 
-    if (op == QmlPrivate::Create) { 
-        QObject *obj = static_cast<QObject *>(new T);
-        *((QObject **)out) = obj; 
-        return 0; 
-    } 
-    QList<T *> *list = vlist.value<QList<T *> *>(); 
-    switch(op) { 
-    case QmlPrivate::Append: 
-        list->append(value.value<T *>()); 
-        break; 
-    case QmlPrivate::Set: 
-        (*list)[val] = value.value<T *>(); 
-        break; 
-    case QmlPrivate::Insert: 
-        list->insert(val, value.value<T *>()); 
-        break; 
-    case QmlPrivate::Prepend: 
-        list->prepend(value.value<T *>()); 
-        break; 
-    case QmlPrivate::Length: 
-        return list->count(); 
-        break; 
-    case QmlPrivate::Clear: 
-        list->clear(); 
-        return 0; 
-        break; 
-    case QmlPrivate::Create: 
-        break; 
-    case QmlPrivate::Object: 
-        *out =  static_cast<QObject *>(value.value<T *>()); 
-        break; 
-    case QmlPrivate::FromObject: 
-        { 
-            QObject *fromObj = value.value<QObject *>(); 
-            T *me = qobject_cast<T *>(fromObj); 
-            if (me) { 
-                *((QVariant *)*out) = QVariant::fromValue(me); 
-            } 
-        } 
-        break; 
-    case QmlPrivate::Value: 
-        if (list->count() <= val) *((QVariant *)*out) = QVariant();
-        else *((QVariant *)*out) = QVariant::fromValue(list->at(val)); 
-        break; 
-    } 
-    return 0; 
-} 
-
-template<typename T>
-int QmlPrivate::list_nocreate_op(QmlPrivate::ListOp op, int val, 
-                                 const QVariant &vlist, 
-                                 const QVariant &value, 
-                                 void **out) 
-{ 
-    QList<T *> *list = vlist.value<QList<T *> *>(); 
-    switch(op) { 
-    case QmlPrivate::Append: 
-        list->append(value.value<T *>()); 
-        break; 
-    case QmlPrivate::Set: 
-        (*list)[val] = value.value<T *>(); 
-        break; 
-    case QmlPrivate::Insert: 
-        list->insert(val, value.value<T *>()); 
-        break; 
-    case QmlPrivate::Prepend: 
-        list->prepend(value.value<T *>()); 
-        break; 
-    case QmlPrivate::Length: 
-        return list->count(); 
-        break; 
-    case QmlPrivate::Clear: 
-        list->clear(); 
-        return 0; 
-        break; 
-    case QmlPrivate::Create: 
-        break; 
-    case QmlPrivate::Object: 
-        *out =  static_cast<QObject *>(value.value<T *>()); 
-        break; 
-    case QmlPrivate::FromObject: 
-        { 
-            QObject *fromObj = value.value<QObject *>(); 
-            T *me = qobject_cast<T *>(fromObj); 
-            if (me) { 
-                *((QVariant *)*out) = QVariant::fromValue(me); 
-            } 
-        } 
-        break; 
-    case QmlPrivate::Value: 
-        *((QVariant *)*out) = QVariant::fromValue(list->at(val)); 
-        break; 
-    } 
-    return 0; 
-} 
-
-template<typename T>
-int QmlPrivate::list_interface_op(QmlPrivate::ListOp op, int val, 
-                                  const QVariant &vlist, 
-                                  const QVariant &value, 
-                                  void **out) 
-{ 
-    QList<T *> *list = vlist.value<QList<T *> *>(); 
-    switch(op) { 
-    case QmlPrivate::Append: 
-        list->append(value.value<T *>()); 
-        break; 
-    case QmlPrivate::Set: 
-        (*list)[val] = value.value<T *>(); 
-        break; 
-    case QmlPrivate::Insert: 
-        list->insert(val, value.value<T *>()); 
-        break; 
-    case QmlPrivate::Prepend: 
-        list->prepend(value.value<T *>()); 
-        break; 
-    case QmlPrivate::Length: 
-        return list->count(); 
-        break; 
-    case QmlPrivate::Clear: 
-        list->clear(); 
-        return 0; 
-        break; 
-    case QmlPrivate::Create: 
-        break; 
-    case QmlPrivate::Object: 
-        break; 
-    case QmlPrivate::FromObject: 
-        break; 
-    case QmlPrivate::Value: 
-        *((QVariant *)*out) = QVariant::fromValue(list->at(val)); 
-        break; 
-    } 
-    return 0; 
-} 
-
 QT_END_NAMESPACE
 
 QT_END_HEADER
diff --git a/src/declarative/qml/qmlpropertycache.cpp b/src/declarative/qml/qmlpropertycache.cpp
index e567fd2..a3e655b 100644
--- a/src/declarative/qml/qmlpropertycache.cpp
+++ b/src/declarative/qml/qmlpropertycache.cpp
@@ -77,8 +77,6 @@ void QmlPropertyCache::Data::load(const QMetaProperty &p, QmlEngine *engine)
             flags |= Data::IsQObjectDerived;
         else if (cat == QmlMetaType::List)
             flags |= Data::IsQList;
-        else if (cat == QmlMetaType::QmlList)
-            flags |= Data::IsQmlList;
     }
 }
 
diff --git a/src/declarative/qml/qmlpropertycache_p.h b/src/declarative/qml/qmlpropertycache_p.h
index 34b648d..18eea80 100644
--- a/src/declarative/qml/qmlpropertycache_p.h
+++ b/src/declarative/qml/qmlpropertycache_p.h
@@ -86,7 +86,6 @@ public:
                     IsFunction        = 0x00000008,
                     IsQObjectDerived  = 0x00000010,
                     IsEnumType        = 0x00000020,
-                    IsQmlList         = 0x00000040,
                     IsQList           = 0x00000080,
                     IsQmlBinding      = 0x00000100,
                     IsQScriptValue    = 0x00000200,
diff --git a/src/declarative/qml/qmlvme.cpp b/src/declarative/qml/qmlvme.cpp
index 39de062..8655809 100644
--- a/src/declarative/qml/qmlvme.cpp
+++ b/src/declarative/qml/qmlvme.cpp
@@ -91,15 +91,13 @@ QmlVME::QmlVME()
 
 struct ListInstance
 {
-    ListInstance() {}
-    ListInstance(QList<void *> *q, int t)
-        : type(t), qListInterface(q), qmlListInterface(0) {}
-    ListInstance(QmlPrivate::ListInterface *q, int t)
-        : type(t), qListInterface(0), qmlListInterface(q) {}
+    ListInstance() 
+        : type(0) {}
+    ListInstance(int t) 
+        : type(t) {}
 
     int type;
-    QList<void *> *qListInterface;
-    QmlPrivate::ListInterface *qmlListInterface;
+    QmlListProperty<void> qListProperty;
 };
 
 QObject *QmlVME::run(QmlContext *ctxt, QmlCompiledData *comp, 
@@ -654,22 +652,12 @@ QObject *QmlVME::run(QmlVMEStack<QObject *> &stack, QmlContext *ctxt,
             }
             break;
 
-        case QmlInstruction::StoreObjectQmlList:
-            {
-                QObject *assign = stack.pop();
-                const ListInstance &list = qliststack.top();
-
-                void *d = (void *)&assign;
-                list.qmlListInterface->append(d);
-            }
-            break;
-
         case QmlInstruction::StoreObjectQList:
             {
                 QObject *assign = stack.pop();
 
                 const ListInstance &list = qliststack.top();
-                list.qListInterface->append((void *)assign);
+                list.qListProperty.append((QmlListProperty<void>*)&list.qListProperty, assign);
             }
             break;
 
@@ -690,12 +678,7 @@ QObject *QmlVME::run(QmlVMEStack<QObject *> &stack, QmlContext *ctxt,
                     VME_EXCEPTION(QCoreApplication::translate("QmlVME","Cannot assign object to list"));
 
 
-                if (list.qmlListInterface) {
-                    void *d = (void *)&ptr;
-                    list.qmlListInterface->append(d);
-                } else {
-                    list.qListInterface->append(ptr);
-                }
+                list.qListProperty.append((QmlListProperty<void>*)&list.qListProperty, ptr);
             }
             break;
 
@@ -750,39 +733,16 @@ QObject *QmlVME::run(QmlVMEStack<QObject *> &stack, QmlContext *ctxt,
             }
             break;
 
-        case QmlInstruction::FetchQmlList:
-            {
-                QObject *target = stack.top();
-
-                void *a[1];
-                // We know that QmlList<*> can be converted to 
-                // QmlPrivate::ListInterface
-                QmlPrivate::ListInterface *list = 0;
-                a[0] = &list;
-                QMetaObject::metacall(target, QMetaObject::ReadProperty, 
-                                      instr.fetchQmlList.property, a);
-                if (!list) 
-                    VME_EXCEPTION(QCoreApplication::translate("QmlVME","Cannot assign to null list"));
-
-                qliststack.push(ListInstance(list, instr.fetchQmlList.type));
-            }
-            break;
-
         case QmlInstruction::FetchQList:
             {
                 QObject *target = stack.top();
 
+                qliststack.push(ListInstance(instr.fetchQmlList.type));
+
                 void *a[1];
-                // We know that QList<T *>* can be converted to 
-                // QList<void *>*
-                QList<void *> *list = 0;
-                a[0] = &list;
+                a[0] = (void *)&(qliststack.top().qListProperty);
                 QMetaObject::metacall(target, QMetaObject::ReadProperty, 
                                       instr.fetchQmlList.property, a);
-                if (!list) 
-                    VME_EXCEPTION(QCoreApplication::translate("QmlVME","Cannot assign to null list"));
-
-                qliststack.push(ListInstance(list, instr.fetchQmlList.type));
             }
             break;
 
diff --git a/src/declarative/qml/qmlvmemetaobject.cpp b/src/declarative/qml/qmlvmemetaobject.cpp
index 3858138..4886680 100644
--- a/src/declarative/qml/qmlvmemetaobject.cpp
+++ b/src/declarative/qml/qmlvmemetaobject.cpp
@@ -77,13 +77,14 @@ QmlVMEMetaObject::QmlVMEMetaObject(QObject *obj,
     data = new QVariant[metaData->propertyCount];
     aConnected.resize(metaData->aliasCount);
 
-    int list_type = qMetaTypeId<QmlList<QObject*>* >();
+    int list_type = qMetaTypeId<QmlListProperty<QObject> >();
     // ### Optimize
     for (int ii = 0; ii < metaData->propertyCount; ++ii) {
         int t = (metaData->propertyData() + ii)->propertyType;
         if (t == list_type) {
-            listProperties.append(new List(this, ii));
-            data[ii] = QVariant::fromValue((QmlList<QObject *>*)listProperties.last());
+            listProperties.append(new List(methodOffset + ii));
+            data[ii] = QVariant::fromValue(QmlListProperty<QObject>(obj, listProperties.last(), list_append,
+                                                                    list_count, list_at, list_clear));
         } else if (t != -1) {
             data[ii] = QVariant((QVariant::Type)t);
         }
@@ -182,8 +183,9 @@ int QmlVMEMetaObject::metaCall(QMetaObject::Call c, int _id, void **a)
                         default:
                             break;
                         }
-                        if (t == qMetaTypeId<QmlList<QObject*>* >()) {
-                            *reinterpret_cast<QmlList<QObject *> **>(a[0]) = data[id].value<QmlList<QObject*>*>();
+                        if (t == qMetaTypeId<QmlListProperty<QObject> >()) {
+                            *reinterpret_cast<QmlListProperty<QObject> *>(a[0]) = 
+                                data[id].value<QmlListProperty<QObject> >();
                         }
 
                     } else if (c == QMetaObject::WriteProperty) {
@@ -318,6 +320,30 @@ void QmlVMEMetaObject::listChanged(int id)
     activate(object, methodOffset + id, 0);
 }
 
+void QmlVMEMetaObject::list_append(QmlListProperty<QObject> *prop, QObject *o)
+{
+    List *list = static_cast<List *>(prop->data);
+    list->append(o);
+    QMetaObject::activate(prop->object, list->notifyIndex, 0);
+}
+
+int QmlVMEMetaObject::list_count(QmlListProperty<QObject> *prop)
+{
+    return static_cast<List *>(prop->data)->count();
+}
+
+QObject *QmlVMEMetaObject::list_at(QmlListProperty<QObject> *prop, int index)
+{
+    return static_cast<List *>(prop->data)->at(index);
+}
+
+void QmlVMEMetaObject::list_clear(QmlListProperty<QObject> *prop)
+{
+    List *list = static_cast<List *>(prop->data);
+    list->clear();
+    QMetaObject::activate(prop->object, list->notifyIndex, 0);
+}
+
 void QmlVMEMetaObject::registerInterceptor(int index, int valueIndex, QmlPropertyValueInterceptor *interceptor)
 {
     if (aInterceptors.isEmpty())
diff --git a/src/declarative/qml/qmlvmemetaobject_p.h b/src/declarative/qml/qmlvmemetaobject_p.h
index 7fa46fd..3eb776e 100644
--- a/src/declarative/qml/qmlvmemetaobject_p.h
+++ b/src/declarative/qml/qmlvmemetaobject_p.h
@@ -138,33 +138,18 @@ private:
     QAbstractDynamicMetaObject *parent;
 
     void listChanged(int);
-    class List : public QmlConcreteList<QObject*>
+    class List : public QList<QObject*>
     {
     public:
-        List(QmlVMEMetaObject *p, int propIdx) 
-            : parent(p), parentProperty(propIdx) { }
-
-        virtual void append(QObject *v) { 
-            QmlConcreteList<QObject*>::append(v); 
-            parent->listChanged(parentProperty);
-        }
-        virtual void insert(int i, QObject *v) { 
-            QmlConcreteList<QObject*>::insert(i, v); 
-            parent->listChanged(parentProperty);
-        }
-        virtual void clear() { 
-            QmlConcreteList<QObject*>::clear();
-            parent->listChanged(parentProperty);
-        }
-        virtual void removeAt(int i) { 
-            QmlConcreteList<QObject*>::removeAt(i);
-            parent->listChanged(parentProperty);
-        }
-    private:
-        QmlVMEMetaObject *parent;
-        int parentProperty;
+        List(int lpi) : notifyIndex(lpi) {}
+        int notifyIndex;
     };
     QList<List *> listProperties;
+
+    static void list_append(QmlListProperty<QObject> *, QObject *);
+    static int list_count(QmlListProperty<QObject> *);
+    static QObject *list_at(QmlListProperty<QObject> *, int);
+    static void list_clear(QmlListProperty<QObject> *);
 };
 
 QT_END_NAMESPACE
diff --git a/src/declarative/util/qmlanimation.cpp b/src/declarative/util/qmlanimation.cpp
index d7ddfce..c044f97 100644
--- a/src/declarative/util/qmlanimation.cpp
+++ b/src/declarative/util/qmlanimation.cpp
@@ -937,10 +937,10 @@ void QmlPropertyAction::setProperties(const QString &p)
     emit propertiesChanged(p);
 }
 
-QList<QObject *> *QmlPropertyAction::targets()
+QmlListProperty<QObject> QmlPropertyAction::targets()
 {
     Q_D(QmlPropertyAction);
-    return &d->targets;
+    return QmlListProperty<QObject>(this, d->targets);
 }
 
 /*!
@@ -948,10 +948,10 @@ QList<QObject *> *QmlPropertyAction::targets()
     This property holds the objects not to be affected by this animation.
     \sa targets
 */
-QList<QObject *> *QmlPropertyAction::exclude()
+QmlListProperty<QObject> QmlPropertyAction::exclude()
 {
     Q_D(QmlPropertyAction);
-    return &d->exclude;
+    return QmlListProperty<QObject>(this, d->exclude);
 }
 
 /*!
@@ -1577,14 +1577,36 @@ QmlAnimationGroup::QmlAnimationGroup(QObject *parent)
 {
 }
 
+void QmlAnimationGroupPrivate::append_animation(QmlListProperty<QmlAbstractAnimation> *list, QmlAbstractAnimation *a)
+{
+    QmlAnimationGroup *q = qobject_cast<QmlAnimationGroup *>(list->object);
+    if (q) {
+        q->d_func()->animations.append(a);
+        a->setGroup(q);
+    }
+}
+
+void QmlAnimationGroupPrivate::clear_animation(QmlListProperty<QmlAbstractAnimation> *list)
+{
+    QmlAnimationGroup *q = qobject_cast<QmlAnimationGroup *>(list->object);
+    if (q) {
+        for (int i = 0; i < q->d_func()->animations.count(); ++i)
+            q->d_func()->animations.at(i)->setGroup(0);
+        q->d_func()->animations.clear();
+    }
+}
+
 QmlAnimationGroup::~QmlAnimationGroup()
 {
 }
 
-QmlList<QmlAbstractAnimation *> *QmlAnimationGroup::animations()
+QmlListProperty<QmlAbstractAnimation> QmlAnimationGroup::animations()
 {
     Q_D(QmlAnimationGroup);
-    return &d->animations;
+    QmlListProperty<QmlAbstractAnimation> list(this, d->animations);
+    list.append = &QmlAnimationGroupPrivate::append_animation;
+    list.clear = &QmlAnimationGroupPrivate::clear_animation;
+    return list;
 }
 
 /*!
@@ -2226,10 +2248,10 @@ void QmlPropertyAnimation::setProperties(const QString &prop)
 
     \sa exclude
 */
-QList<QObject *> *QmlPropertyAnimation::targets()
+QmlListProperty<QObject> QmlPropertyAnimation::targets()
 {
     Q_D(QmlPropertyAnimation);
-    return &d->targets;
+    return QmlListProperty<QObject>(this, d->targets);
 }
 
 /*!
@@ -2237,10 +2259,10 @@ QList<QObject *> *QmlPropertyAnimation::targets()
     This property holds the items not to be affected by this animation.
     \sa targets
 */
-QList<QObject *> *QmlPropertyAnimation::exclude()
+QmlListProperty<QObject> QmlPropertyAnimation::exclude()
 {
     Q_D(QmlPropertyAnimation);
-    return &d->exclude;
+    return QmlListProperty<QObject>(this, d->exclude);
 }
 
 QAbstractAnimation *QmlPropertyAnimation::qtAnimation()
diff --git a/src/declarative/util/qmlanimation_p.h b/src/declarative/util/qmlanimation_p.h
index 50eb577..623ad8d 100644
--- a/src/declarative/util/qmlanimation_p.h
+++ b/src/declarative/util/qmlanimation_p.h
@@ -190,8 +190,8 @@ class QmlPropertyAction : public QmlAbstractAnimation
     Q_PROPERTY(QObject *target READ target WRITE setTarget NOTIFY targetChanged)
     Q_PROPERTY(QString property READ property WRITE setProperty NOTIFY targetChanged)
     Q_PROPERTY(QString properties READ properties WRITE setProperties NOTIFY propertiesChanged)
-    Q_PROPERTY(QList<QObject *>* targets READ targets)
-    Q_PROPERTY(QList<QObject *>* exclude READ exclude)
+    Q_PROPERTY(QmlListProperty<QObject> targets READ targets)
+    Q_PROPERTY(QmlListProperty<QObject> exclude READ exclude)
     Q_PROPERTY(QVariant value READ value WRITE setValue NOTIFY valueChanged)
 
 public:
@@ -207,8 +207,8 @@ public:
     QString properties() const;
     void setProperties(const QString &);
 
-    QList<QObject *> *targets();
-    QList<QObject *> *exclude();
+    QmlListProperty<QObject> targets();
+    QmlListProperty<QObject> exclude();
 
     QVariant value() const;
     void setValue(const QVariant &);
@@ -265,8 +265,8 @@ class Q_AUTOTEST_EXPORT QmlPropertyAnimation : public QmlAbstractAnimation
     Q_PROPERTY(QObject *target READ target WRITE setTarget NOTIFY targetChanged)
     Q_PROPERTY(QString property READ property WRITE setProperty NOTIFY targetChanged)
     Q_PROPERTY(QString properties READ properties WRITE setProperties NOTIFY propertiesChanged)
-    Q_PROPERTY(QList<QObject *>* targets READ targets)
-    Q_PROPERTY(QList<QObject *>* exclude READ exclude)
+    Q_PROPERTY(QmlListProperty<QObject> targets READ targets)
+    Q_PROPERTY(QmlListProperty<QObject> exclude READ exclude)
 
 public:
     QmlPropertyAnimation(QObject *parent=0);
@@ -293,8 +293,8 @@ public:
     QString properties() const;
     void setProperties(const QString &);
 
-    QList<QObject *> *targets();
-    QList<QObject *> *exclude();
+    QmlListProperty<QObject> targets();
+    QmlListProperty<QObject> exclude();
 
 protected:
     QmlPropertyAnimation(QmlPropertyAnimationPrivate &dd, QObject *parent);
@@ -404,13 +404,13 @@ class QmlAnimationGroup : public QmlAbstractAnimation
     Q_DECLARE_PRIVATE(QmlAnimationGroup)
 
     Q_CLASSINFO("DefaultProperty", "animations")
-    Q_PROPERTY(QmlList<QmlAbstractAnimation *> *animations READ animations)
+    Q_PROPERTY(QmlListProperty<QmlAbstractAnimation> animations READ animations)
 
 public:
     QmlAnimationGroup(QObject *parent);
     virtual ~QmlAnimationGroup();
 
-    QmlList<QmlAbstractAnimation *>* animations();
+    QmlListProperty<QmlAbstractAnimation> animations();
     friend class QmlAbstractAnimation;
 };
 
diff --git a/src/declarative/util/qmlanimation_p_p.h b/src/declarative/util/qmlanimation_p_p.h
index b2ce297..056ce82 100644
--- a/src/declarative/util/qmlanimation_p_p.h
+++ b/src/declarative/util/qmlanimation_p_p.h
@@ -304,37 +304,13 @@ class QmlAnimationGroupPrivate : public QmlAbstractAnimationPrivate
     Q_DECLARE_PUBLIC(QmlAnimationGroup)
 public:
     QmlAnimationGroupPrivate()
-    : QmlAbstractAnimationPrivate(), animations(this), ag(0) {}
+    : QmlAbstractAnimationPrivate(), ag(0) {}
 
-    struct AnimationList : public QmlConcreteList<QmlAbstractAnimation *>
-    {
-        AnimationList(QmlAnimationGroupPrivate *p)
-        : anim(p) {}
-        virtual void append(QmlAbstractAnimation *a) {
-            QmlConcreteList<QmlAbstractAnimation *>::append(a);
-            a->setGroup(anim->q_func());
-        }
-        virtual void clear()
-        {
-            for (int i = 0; i < count(); ++i)
-                at(i)->setGroup(0);
-            QmlConcreteList<QmlAbstractAnimation *>::clear();
-        }
-        virtual void removeAt(int i)
-        {
-            at(i)->setGroup(0);
-            QmlConcreteList<QmlAbstractAnimation *>::removeAt(i);
-        }
-        virtual void insert(int i, QmlAbstractAnimation *a)
-        {
-            QmlConcreteList<QmlAbstractAnimation *>::insert(i, a);
-            a->setGroup(anim->q_func());
-        }
-
-        QmlAnimationGroupPrivate *anim;
-    };
-
-    AnimationList animations;
+    static void append_animation(QmlListProperty<QmlAbstractAnimation> *list, QmlAbstractAnimation *role);
+    static void clear_animation(QmlListProperty<QmlAbstractAnimation> *list);
+    static void removeAt_animation(QmlListProperty<QmlAbstractAnimation> *list, int i);
+    static void insert_animation(QmlListProperty<QmlAbstractAnimation> *list, int i, QmlAbstractAnimation *role);
+    QList<QmlAbstractAnimation *> animations;
     QAnimationGroup *ag;
 };
 
diff --git a/src/declarative/util/qmllistaccessor.cpp b/src/declarative/util/qmllistaccessor.cpp
index c1b9247..abdb626 100644
--- a/src/declarative/util/qmllistaccessor.cpp
+++ b/src/declarative/util/qmllistaccessor.cpp
@@ -84,11 +84,8 @@ void QmlListAccessor::setList(const QVariant &v, QmlEngine *engine)
         QObject *data = enginePrivate?enginePrivate->toQObject(v):QmlMetaType::toQObject(v);
         d = QVariant::fromValue(data);
         m_type = Instance;
-    } else if ((!enginePrivate && QmlMetaType::isQmlList(d.userType())) ||
-               (enginePrivate && enginePrivate->isQmlList(d.userType()))) {
-        m_type = QmlList;
-    } else if (QmlMetaType::isList(d.userType())) {
-        m_type = QListPtr;
+    } else if (d.userType() == qMetaTypeId<QmlListReference>()) {
+        m_type = ListProperty;
     } else {
         m_type = Instance;
     }
@@ -101,16 +98,8 @@ int QmlListAccessor::count() const
         return qvariant_cast<QStringList>(d).count();
     case VariantList:
         return qvariant_cast<QVariantList>(d).count();
-    case QmlList:
-        {
-            QmlPrivate::ListInterface *li = *(QmlPrivate::ListInterface **)d.constData();
-            return li->count();
-        }
-    case QListPtr:
-        {
-            QList<void *> *li = *(QList<void *> **)d.constData();
-            return li->count();
-        }
+    case ListProperty:
+        return ((QmlListReference *)d.constData())->count();
     case Instance:
         return 1;
     case Integer:
@@ -129,19 +118,8 @@ QVariant QmlListAccessor::at(int idx) const
         return QVariant::fromValue(qvariant_cast<QStringList>(d).at(idx));
     case VariantList:
         return qvariant_cast<QVariantList>(d).at(idx);
-    case QmlList:
-        {
-            QmlPrivate::ListInterface *li = *(QmlPrivate::ListInterface **)d.constData();
-            void *ptr[1];
-            li->at(idx, ptr);
-            return QVariant::fromValue((QObject*)ptr[0]);
-        }
-    case QListPtr:
-        {
-            QList<void *> *li = *(QList<void *> **)d.constData();
-            void *ptr = li->at(idx);
-            return QVariant::fromValue((QObject*)ptr);
-        }
+    case ListProperty:
+        return QVariant::fromValue(((QmlListReference *)d.constData())->at(idx));
     case Instance:
         return d;
     case Integer:
@@ -152,106 +130,6 @@ QVariant QmlListAccessor::at(int idx) const
     }
 }
 
-bool QmlListAccessor::append(const QVariant &value)
-{
-    switch(m_type) {
-    case QmlList:
-        {
-            QmlPrivate::ListInterface *li = *(QmlPrivate::ListInterface **)d.constData();
-            li->append(const_cast<void *>(value.constData()));  //XXX Typesafety
-            return true;
-        }
-    case QListPtr:
-        {
-            QList<void *> *li = *(QList<void *> **)d.constData();
-            li->append(*reinterpret_cast<void **>(const_cast<void *>(value.constData())));  //XXX Typesafety
-            return true;
-        }
-    case StringList:
-    case VariantList:
-    case Invalid:
-    case Instance:
-    case Integer:
-    default:
-        return false;
-    }
-}
-
-bool QmlListAccessor::insert(int index, const QVariant &value)
-{
-    switch(m_type) {
-    case QmlList:
-        {
-            QmlPrivate::ListInterface *li = *(QmlPrivate::ListInterface **)d.constData();
-            li->insert(index, const_cast<void *>(value.constData()));   //XXX Typesafety
-            return true;
-        }
-    case QListPtr:
-        {
-            QList<void *> *li = *(QList<void *>**)d.constData();
-            li->insert(index, *reinterpret_cast<void **>(const_cast<void *>(value.constData())));  //XXX Typesafety
-            return true;
-        }
-    case StringList:
-    case VariantList:
-    case Invalid:
-    case Instance:
-    case Integer:
-    default:
-        return false;
-    }
-}
-
-bool QmlListAccessor::removeAt(int index)
-{
-    switch(m_type) {
-    case QmlList:
-        {
-            QmlPrivate::ListInterface *li = *(QmlPrivate::ListInterface **)d.constData();
-            li->removeAt(index);
-            return true;
-        }
-    case QListPtr:
-        {
-            QList<void *> *li = *(QList<void *>**)d.constData();
-            li->removeAt(index);
-            return true;
-        }
-    case StringList:
-    case VariantList:
-    case Invalid:
-    case Instance:
-    case Integer:
-    default:
-        return false;
-    }
-}
-
-bool QmlListAccessor::clear()
-{
-    switch(m_type) {
-    case QmlList:
-        {
-            QmlPrivate::ListInterface *li = *(QmlPrivate::ListInterface **)d.constData();
-            li->clear();
-            return true;
-        }
-    case QListPtr:
-        {
-            QList<void *> *li = *(QList<void *>**)d.constData();
-            li->clear();
-            return true;
-        }
-    case StringList:
-    case VariantList:
-    case Invalid:
-    case Instance:
-    case Integer:
-    default:
-        return false;
-    }
-}
-
 bool QmlListAccessor::isValid() const
 {
     return m_type != Invalid;
diff --git a/src/declarative/util/qmllistaccessor_p.h b/src/declarative/util/qmllistaccessor_p.h
index 8a0b06c..611eebb 100644
--- a/src/declarative/util/qmllistaccessor_p.h
+++ b/src/declarative/util/qmllistaccessor_p.h
@@ -65,12 +65,7 @@ public:
     int count() const;
     QVariant at(int) const;
 
-    bool append(const QVariant &);
-    bool insert(int, const QVariant &);
-    bool removeAt(int);
-    bool clear();
-
-    enum Type { Invalid, StringList, VariantList, QmlList, QListPtr, Instance, Integer };
+    enum Type { Invalid, StringList, VariantList, ListProperty, Instance, Integer };
     Type type() const { return m_type; }
 
 private:
diff --git a/src/declarative/util/qmlpackage.cpp b/src/declarative/util/qmlpackage.cpp
index 115f2fd..82f776f 100644
--- a/src/declarative/util/qmlpackage.cpp
+++ b/src/declarative/util/qmlpackage.cpp
@@ -51,28 +51,33 @@ class QmlPackagePrivate : public QObjectPrivate
 public:
     QmlPackagePrivate() {}
 
-    class DataList;
     struct DataGuard : public QmlGuard<QObject>
     {
-        DataGuard(QObject *obj, DataList *l) : list(l) { (QmlGuard<QObject>&)*this = obj; }
-        DataList *list;
+        DataGuard(QObject *obj, QList<DataGuard> *l) : list(l) { (QmlGuard<QObject>&)*this = obj; }
+        QList<DataGuard> *list;
         void objectDestroyed(QObject *) {
             // we assume priv will always be destroyed after objectDestroyed calls
             list->removeOne(*this);
         }
     };
 
-    class DataList : public QList<DataGuard>, public QmlList<QObject*>
-    {
-    public:
-        virtual void append(QObject* v) { QList<DataGuard>::append(DataGuard(v, this)); }
-        virtual void insert(int i, QObject* v) { QList<DataGuard>::insert(i, DataGuard(v, this)); }
-        virtual void clear() { QList<DataGuard>::clear(); }
-        virtual QObject* at(int i) const { return QList<DataGuard>::at(i); }
-        virtual void removeAt(int i) { QList<DataGuard>::removeAt(i); }
-        virtual int count() const { return QList<DataGuard>::count(); }
-    };
-    DataList dataList;
+    QList<DataGuard> dataList;
+    static void data_append(QmlListProperty<QObject> *prop, QObject *o) {
+        QList<DataGuard> *list = static_cast<QList<DataGuard> *>(prop->data);
+        list->append(DataGuard(o, list));
+    }
+    static void data_clear(QmlListProperty<QObject> *prop) {
+        QList<DataGuard> *list = static_cast<QList<DataGuard> *>(prop->data);
+        list->clear();
+    }
+    static QObject *data_at(QmlListProperty<QObject> *prop, int index) {
+        QList<DataGuard> *list = static_cast<QList<DataGuard> *>(prop->data);
+        return list->at(index);
+    }
+    static int data_count(QmlListProperty<QObject> *prop) {
+        QList<DataGuard> *list = static_cast<QList<DataGuard> *>(prop->data);
+        return list->count();
+    }
 };
 
 class QmlPackageAttached : public QObject
@@ -128,10 +133,13 @@ QmlPackage::~QmlPackage()
     }
 }
 
-QmlList<QObject *> *QmlPackage::data()
+QmlListProperty<QObject> QmlPackage::data()
 {
     Q_D(QmlPackage);
-    return &d->dataList;
+    return QmlListProperty<QObject>(this, &d->dataList, QmlPackagePrivate::data_append, 
+                                                        QmlPackagePrivate::data_count, 
+                                                        QmlPackagePrivate::data_at, 
+                                                        QmlPackagePrivate::data_clear);
 }
 
 bool QmlPackage::hasPart(const QString &name)
diff --git a/src/declarative/util/qmlpackage_p.h b/src/declarative/util/qmlpackage_p.h
index 2538bb9..29b6bbe 100644
--- a/src/declarative/util/qmlpackage_p.h
+++ b/src/declarative/util/qmlpackage_p.h
@@ -64,13 +64,13 @@ class QmlPackage : public QObject
     Q_DECLARE_PRIVATE(QmlPackage)
 
     Q_CLASSINFO("DefaultProperty", "data")
-    Q_PROPERTY(QmlList<QObject *> *data READ data SCRIPTABLE false)
+    Q_PROPERTY(QmlListProperty<QObject> data READ data SCRIPTABLE false)
 
 public:
     QmlPackage(QObject *parent=0);
     virtual ~QmlPackage();
 
-    QmlList<QObject *> *data();
+    QmlListProperty<QObject> data();
 
     QObject *part(const QString & = QString());
     bool hasPart(const QString &);
diff --git a/src/declarative/util/qmlstate.cpp b/src/declarative/util/qmlstate.cpp
index 7ecbd79..4462b1f 100644
--- a/src/declarative/util/qmlstate.cpp
+++ b/src/declarative/util/qmlstate.cpp
@@ -242,16 +242,30 @@ void QmlState::setExtends(const QString &extends)
     extends another state, then the changes are applied against the state being
     extended.
 */
-QmlList<QmlStateOperation *> *QmlState::changes()
+QmlListProperty<QmlStateOperation> QmlState::changes()
 {
     Q_D(QmlState);
-    return &d->operations;
+    return QmlListProperty<QmlStateOperation>(this, &d->operations, QmlStatePrivate::operations_append,
+                                              QmlStatePrivate::operations_count, QmlStatePrivate::operations_at,
+                                              QmlStatePrivate::operations_clear);
+}
+
+int QmlState::operationCount() const
+{
+    Q_D(const QmlState);
+    return d->operations.count();
+}
+
+QmlStateOperation *QmlState::operationAt(int index) const
+{
+    Q_D(const QmlState);
+    return d->operations.at(index);
 }
 
 QmlState &QmlState::operator<<(QmlStateOperation *op)
 {
     Q_D(QmlState);
-    d->operations.append(op);
+    d->operations.append(QmlStatePrivate::OperationGuard(op, &d->operations));
     return *this;
 }
 
diff --git a/src/declarative/util/qmlstate_p.h b/src/declarative/util/qmlstate_p.h
index 785a175..2c92387 100644
--- a/src/declarative/util/qmlstate_p.h
+++ b/src/declarative/util/qmlstate_p.h
@@ -131,7 +131,7 @@ class Q_DECLARATIVE_EXPORT QmlState : public QObject
     Q_PROPERTY(QString name READ name WRITE setName)
     Q_PROPERTY(QmlBinding *when READ when WRITE setWhen)
     Q_PROPERTY(QString extend READ extends WRITE setExtends)
-    Q_PROPERTY(QmlList<QmlStateOperation *>* changes READ changes)
+    Q_PROPERTY(QmlListProperty<QmlStateOperation> changes READ changes)
     Q_CLASSINFO("DefaultProperty", "changes")
     Q_CLASSINFO("DeferredPropertyNames", "changes")
 
@@ -151,7 +151,10 @@ public:
     QString extends() const;
     void setExtends(const QString &);
 
-    QmlList<QmlStateOperation *> *changes();
+    QmlListProperty<QmlStateOperation> changes();
+    int operationCount() const;
+    QmlStateOperation *operationAt(int) const;
+
     QmlState &operator<<(QmlStateOperation *);
 
     void apply(QmlStateGroup *, QmlTransition *, QmlState *revert);
diff --git a/src/declarative/util/qmlstate_p_p.h b/src/declarative/util/qmlstate_p_p.h
index c389846..d138e4e 100644
--- a/src/declarative/util/qmlstate_p_p.h
+++ b/src/declarative/util/qmlstate_p_p.h
@@ -107,28 +107,33 @@ public:
     QString name;
     QmlBinding *when;
 
-    class OperationList;
     struct OperationGuard : public QmlGuard<QmlStateOperation>
     {
-        OperationGuard(QObject *obj, OperationList *l) : list(l) { (QmlGuard<QObject>&)*this = obj; }
-        OperationList *list;
+        OperationGuard(QObject *obj, QList<OperationGuard> *l) : list(l) { (QmlGuard<QObject>&)*this = obj; }
+        QList<OperationGuard> *list;
         void objectDestroyed(QmlStateOperation *) {
             // we assume priv will always be destroyed after objectDestroyed calls
             list->removeOne(*this);
         }
     };
+    QList<OperationGuard> operations;
 
-    class OperationList : public QList<OperationGuard>, public QmlList<QmlStateOperation*>
-    {
-    public:
-        virtual void append(QmlStateOperation* v) { QList<OperationGuard>::append(OperationGuard(v, this)); }
-        virtual void insert(int i, QmlStateOperation* v) { QList<OperationGuard>::insert(i, OperationGuard(v, this)); }
-        virtual void clear() { QList<OperationGuard>::clear(); }
-        virtual QmlStateOperation* at(int i) const { return QList<OperationGuard>::at(i); }
-        virtual void removeAt(int i) { QList<OperationGuard>::removeAt(i); }
-        virtual int count() const { return QList<OperationGuard>::count(); }
-    };
-    OperationList operations;
+    static void operations_append(QmlListProperty<QmlStateOperation> *prop, QmlStateOperation *op) {
+        QList<OperationGuard> *list = static_cast<QList<OperationGuard> *>(prop->data);
+        list->append(OperationGuard(op, list));
+    }
+    static void operations_clear(QmlListProperty<QmlStateOperation> *prop) {
+        QList<OperationGuard> *list = static_cast<QList<OperationGuard> *>(prop->data);
+        list->clear();
+    }
+    static int operations_count(QmlListProperty<QmlStateOperation> *prop) {
+        QList<OperationGuard> *list = static_cast<QList<OperationGuard> *>(prop->data);
+        return list->count();
+    }
+    static QmlStateOperation *operations_at(QmlListProperty<QmlStateOperation> *prop, int index) {
+        QList<OperationGuard> *list = static_cast<QList<OperationGuard> *>(prop->data);
+        return list->at(index);
+    }
 
     QmlTransitionManager transitionManager;
 
diff --git a/src/declarative/util/qmlstategroup.cpp b/src/declarative/util/qmlstategroup.cpp
index d289e17..4ad77c8 100644
--- a/src/declarative/util/qmlstategroup.cpp
+++ b/src/declarative/util/qmlstategroup.cpp
@@ -60,26 +60,19 @@ class QmlStateGroupPrivate : public QObjectPrivate
     Q_DECLARE_PUBLIC(QmlStateGroup)
 public:
     QmlStateGroupPrivate(QmlStateGroup *p)
-    : nullState(0), states(p), componentComplete(true),
+    : nullState(0), componentComplete(true),
       ignoreTrans(false), applyingState(false) {}
 
     QString currentState;
     QmlState *nullState;
 
-    struct StateList : public QmlConcreteList<QmlState *>
-    {
-        StateList(QmlStateGroup *g)
-            :group(g) {}
-        void append(QmlState *s) {
-            QmlConcreteList<QmlState *>::append(s);
-            if (s) s->setStateGroup(group);
-        }
-    private:
-        QmlStateGroup *group;
-    };
-    StateList states;
+    static void append_state(QmlListProperty<QmlState> *list, QmlState *state);
+    static int count_state(QmlListProperty<QmlState> *list);
+    static QmlState *at_state(QmlListProperty<QmlState> *list, int index);
+
+    QList<QmlState *> states;
+    QList<QmlTransition *> transitions;
 
-    QmlConcreteList<QmlTransition *> transitions;
     bool componentComplete;
     bool ignoreTrans;
     bool applyingState;
@@ -151,10 +144,34 @@ QList<QmlState *> QmlStateGroup::states() const
 
   \sa {qmlstate}{States}
 */
-QmlList<QmlState *>* QmlStateGroup::statesProperty()
+QmlListProperty<QmlState> QmlStateGroup::statesProperty()
 {
     Q_D(QmlStateGroup);
-    return &(d->states);
+    return QmlListProperty<QmlState>(this, &d->states, &QmlStateGroupPrivate::append_state,
+                                                       &QmlStateGroupPrivate::count_state,
+                                                       &QmlStateGroupPrivate::at_state);
+}
+
+void QmlStateGroupPrivate::append_state(QmlListProperty<QmlState> *list, QmlState *state)
+{
+    QmlStateGroup *_this = static_cast<QmlStateGroup *>(list->object);
+    if (state) {
+        _this->d_func()->states.append(state);
+        state->setStateGroup(_this);
+    }
+
+}
+
+int QmlStateGroupPrivate::count_state(QmlListProperty<QmlState> *list)
+{
+    QmlStateGroup *_this = static_cast<QmlStateGroup *>(list->object);
+    return _this->d_func()->states.count();
+}
+
+QmlState *QmlStateGroupPrivate::at_state(QmlListProperty<QmlState> *list, int index)
+{
+    QmlStateGroup *_this = static_cast<QmlStateGroup *>(list->object);
+    return _this->d_func()->states.at(index);
 }
 
 /*!
@@ -173,10 +190,10 @@ QmlList<QmlState *>* QmlStateGroup::statesProperty()
 
   \sa {state-transitions}{Transitions}
 */
-QmlList<QmlTransition *>* QmlStateGroup::transitionsProperty()
+QmlListProperty<QmlTransition> QmlStateGroup::transitionsProperty()
 {
     Q_D(QmlStateGroup);
-    return &(d->transitions);
+    return QmlListProperty<QmlTransition>(this, d->transitions);
 }
 
 /*!
diff --git a/src/declarative/util/qmlstategroup_p.h b/src/declarative/util/qmlstategroup_p.h
index 48b9c66..d39ca03 100644
--- a/src/declarative/util/qmlstategroup_p.h
+++ b/src/declarative/util/qmlstategroup_p.h
@@ -58,8 +58,8 @@ class Q_DECLARATIVE_EXPORT QmlStateGroup : public QObject, public QmlParserStatu
     Q_DECLARE_PRIVATE(QmlStateGroup)
 
     Q_PROPERTY(QString state READ state WRITE setState NOTIFY stateChanged)
-    Q_PROPERTY(QmlList<QmlState *>* states READ statesProperty DESIGNABLE false)
-    Q_PROPERTY(QmlList<QmlTransition *>* transitions READ transitionsProperty DESIGNABLE false)
+    Q_PROPERTY(QmlListProperty<QmlState> states READ statesProperty DESIGNABLE false)
+    Q_PROPERTY(QmlListProperty<QmlTransition> transitions READ transitionsProperty DESIGNABLE false)
 
 public:
     QmlStateGroup(QObject * = 0);
@@ -68,10 +68,10 @@ public:
     QString state() const;
     void setState(const QString &);
 
-    QmlList<QmlState *>* statesProperty();
+    QmlListProperty<QmlState> statesProperty();
     QList<QmlState *> states() const;
 
-    QmlList<QmlTransition *>* transitionsProperty();
+    QmlListProperty<QmlTransition> transitionsProperty();
 
     QmlState *findState(const QString &name) const;
 
diff --git a/src/declarative/util/qmltransition.cpp b/src/declarative/util/qmltransition.cpp
index e4e53d6..e90fc20 100644
--- a/src/declarative/util/qmltransition.cpp
+++ b/src/declarative/util/qmltransition.cpp
@@ -82,10 +82,10 @@ class QmlTransitionPrivate : public QObjectPrivate
 {
     Q_DECLARE_PUBLIC(QmlTransition)
 public:
-    QmlTransitionPrivate() : fromState(QLatin1String("*")), toState(QLatin1String("*"))
-    , reversed(false), reversible(false), endState(0)
+    QmlTransitionPrivate() 
+    : fromState(QLatin1String("*")), toState(QLatin1String("*")), 
+      reversed(false), reversible(false), endState(0)
     {
-        animations.parent = this;
         group.trans = this;
     }
 
@@ -100,23 +100,15 @@ public:
     {
         endState->complete();
     }
-
-    class AnimationList : public QmlConcreteList<QmlAbstractAnimation *>
-    {
-    public:
-        AnimationList() : parent(0) {}
-        virtual void append(QmlAbstractAnimation *a);
-        virtual void clear() {  QmlConcreteList<QmlAbstractAnimation *>::clear(); } //###
-
-        QmlTransitionPrivate *parent;
-    };
-    AnimationList animations;
+    static void append_animation(QmlListProperty<QmlAbstractAnimation> *list, QmlAbstractAnimation *a);
+    QList<QmlAbstractAnimation *> animations;
 };
 
-void QmlTransitionPrivate::AnimationList::append(QmlAbstractAnimation *a)
+void QmlTransitionPrivate::append_animation(QmlListProperty<QmlAbstractAnimation> *list, QmlAbstractAnimation *a)
 {
-    QmlConcreteList<QmlAbstractAnimation *>::append(a);
-    parent->group.addAnimation(a->qtAnimation());
+    QmlTransition *q = static_cast<QmlTransition *>(list->object);
+    q->d_func()->animations.append(a);
+    q->d_func()->group.addAnimation(a->qtAnimation());
     a->setDisableUserControl();
 }
 
@@ -245,10 +237,10 @@ void QmlTransition::setToState(const QString &t)
     and assign that to animations the animations property.
     \default
 */
-QmlList<QmlAbstractAnimation *>* QmlTransition::animations()
+QmlListProperty<QmlAbstractAnimation> QmlTransition::animations()
 {
     Q_D(QmlTransition);
-    return &d->animations;
+    return QmlListProperty<QmlAbstractAnimation>(this, &d->animations, QmlTransitionPrivate::append_animation);
 }
 
 QT_END_NAMESPACE
diff --git a/src/declarative/util/qmltransition_p.h b/src/declarative/util/qmltransition_p.h
index 5a989bc..ea02a33 100644
--- a/src/declarative/util/qmltransition_p.h
+++ b/src/declarative/util/qmltransition_p.h
@@ -65,7 +65,7 @@ class Q_DECLARATIVE_EXPORT QmlTransition : public QObject
     Q_PROPERTY(QString from READ fromState WRITE setFromState)
     Q_PROPERTY(QString to READ toState WRITE setToState)
     Q_PROPERTY(bool reversible READ reversible WRITE setReversible)
-    Q_PROPERTY(QmlList<QmlAbstractAnimation *>* animations READ animations)
+    Q_PROPERTY(QmlListProperty<QmlAbstractAnimation> animations READ animations)
     Q_CLASSINFO("DefaultProperty", "animations")
     Q_CLASSINFO("DeferredPropertyNames", "animations")
 
@@ -82,7 +82,7 @@ public:
     bool reversible() const;
     void setReversible(bool);
 
-    QmlList<QmlAbstractAnimation *>* animations();
+    QmlListProperty<QmlAbstractAnimation> animations();
 
     void prepare(QmlStateOperation::ActionList &actions,
                  QList<QmlMetaProperty> &after,
diff --git a/src/declarative/util/qmlxmllistmodel.cpp b/src/declarative/util/qmlxmllistmodel.cpp
index 0e939bf..e631cd9 100644
--- a/src/declarative/util/qmlxmllistmodel.cpp
+++ b/src/declarative/util/qmlxmllistmodel.cpp
@@ -130,19 +130,6 @@ QML_DECLARE_TYPE(QmlXmlListModelRole)
 QT_BEGIN_NAMESPACE
 
 
-class QmlXmlListModelPrivate;
-struct QmlXmlRoleList : public QmlConcreteList<QmlXmlListModelRole *>
-{
-    QmlXmlRoleList(QmlXmlListModelPrivate *p)
-        : model(p) {}
-    virtual void append(QmlXmlListModelRole *role);
-    virtual void clear();
-    virtual void removeAt(int i);
-    virtual void insert(int i, QmlXmlListModelRole *role);
-
-    QmlXmlListModelPrivate *model;
-};
-
 class QmlXmlQuery : public QThread
 {
     Q_OBJECT
@@ -164,7 +151,7 @@ public:
         m_abort = true;
     }
 
-    int doQuery(QString query, QString namespaces, QByteArray data, QmlXmlRoleList *roleObjects) {
+    int doQuery(QString query, QString namespaces, QByteArray data, QList<QmlXmlListModelRole *> *roleObjects) {
         QMutexLocker locker(&m_mutex);
         m_modelData.clear();
         m_size = 0;
@@ -229,7 +216,7 @@ private:
     QString m_prefix;
     int m_size;
     int m_queryId;
-    const QmlXmlRoleList *m_roleObjects;
+    const QList<QmlXmlListModelRole *> *m_roleObjects;
     QList<QList<QVariant> > m_modelData;
 };
 
@@ -347,7 +334,7 @@ public:
     QmlXmlListModelPrivate()
         : isComponentComplete(true), size(-1), highestRole(Qt::UserRole)
         , reply(0), status(QmlXmlListModel::Null), progress(0.0)
-        , queryId(-1), roleObjects(this) {}
+        , queryId(-1), roleObjects() {}
 
     bool isComponentComplete;
     QUrl src;
@@ -363,42 +350,39 @@ public:
     qreal progress;
     QmlXmlQuery qmlXmlQuery;
     int queryId;
-    QmlXmlRoleList roleObjects;
+    QList<QmlXmlListModelRole *> roleObjects;
+    static void append_role(QmlListProperty<QmlXmlListModelRole> *list, QmlXmlListModelRole *role);
+    static void clear_role(QmlListProperty<QmlXmlListModelRole> *list);
+    static void removeAt_role(QmlListProperty<QmlXmlListModelRole> *list, int i);
+    static void insert_role(QmlListProperty<QmlXmlListModelRole> *list, int i, QmlXmlListModelRole *role);
     QList<QList<QVariant> > data;
 };
 
 
-void QmlXmlRoleList::append(QmlXmlListModelRole *role)
+void QmlXmlListModelPrivate::append_role(QmlListProperty<QmlXmlListModelRole> *list, QmlXmlListModelRole *role)
 {
-    insert(size(), role);
+    QmlXmlListModel *_this = qobject_cast<QmlXmlListModel *>(list->object);
+    if (_this) {
+        int i = _this->d_func()->roleObjects.count();
+        _this->d_func()->roleObjects.append(role);
+        if (_this->d_func()->roleNames.contains(role->name())) {
+            qmlInfo(role) << QObject::tr("\"%1\" duplicates a previous role name and will be disabled.").arg(role->name());
+            return;
+        }
+        _this->d_func()->roles.insert(i, _this->d_func()->highestRole);
+        _this->d_func()->roleNames.insert(i, role->name());
+        ++_this->d_func()->highestRole;
+    }
 }
 
-//### clear, removeAt, and insert need to invalidate any cached data (in data table) as well
+//### clear needs to invalidate any cached data (in data table) as well
 //    (and the model should emit the appropriate signals)
-void QmlXmlRoleList::clear()
-{
-    model->roles.clear();
-    model->roleNames.clear();
-    QmlConcreteList<QmlXmlListModelRole *>::clear();
-}
-
-void QmlXmlRoleList::removeAt(int i)
+void QmlXmlListModelPrivate::clear_role(QmlListProperty<QmlXmlListModelRole> *list)
 {
-    model->roles.removeAt(i);
-    model->roleNames.removeAt(i);
-    QmlConcreteList<QmlXmlListModelRole *>::removeAt(i);
-}
-
-void QmlXmlRoleList::insert(int i, QmlXmlListModelRole *role)
-{
-    QmlConcreteList<QmlXmlListModelRole *>::insert(i, role);
-    if (model->roleNames.contains(role->name())) {
-        qmlInfo(role) << QCoreApplication::translate("QmlXmlRoleList", "\"%1\" duplicates a previous role name and will be disabled.").arg(role->name());
-        return;
-    }
-    model->roles.insert(i, model->highestRole);
-    model->roleNames.insert(i, role->name());
-    ++model->highestRole;
+    QmlXmlListModel *_this = static_cast<QmlXmlListModel *>(list->object);
+    _this->d_func()->roles.clear();
+    _this->d_func()->roleNames.clear();
+    _this->d_func()->roleObjects.clear();
 }
 
 /*!
@@ -446,10 +430,13 @@ QmlXmlListModel::~QmlXmlListModel()
 
     The roles to make available for this model.
 */
-QmlList<QmlXmlListModelRole *> *QmlXmlListModel::roleObjects()
+QmlListProperty<QmlXmlListModelRole> QmlXmlListModel::roleObjects()
 {
     Q_D(QmlXmlListModel);
-    return &d->roleObjects;
+    QmlListProperty<QmlXmlListModelRole> list(this, d->roleObjects);
+    list.append = &QmlXmlListModelPrivate::append_role;
+    list.clear = &QmlXmlListModelPrivate::clear_role;
+    return list;
 }
 
 QHash<int,QVariant> QmlXmlListModel::data(int index, const QList<int> &roles) const
diff --git a/src/declarative/util/qmlxmllistmodel_p.h b/src/declarative/util/qmlxmllistmodel_p.h
index 51d942d..a6627e2 100644
--- a/src/declarative/util/qmlxmllistmodel_p.h
+++ b/src/declarative/util/qmlxmllistmodel_p.h
@@ -70,7 +70,7 @@ class Q_DECLARATIVE_EXPORT QmlXmlListModel : public QListModelInterface, public
     Q_PROPERTY(QString xml READ xml WRITE setXml)
     Q_PROPERTY(QString query READ query WRITE setQuery)
     Q_PROPERTY(QString namespaceDeclarations READ namespaceDeclarations WRITE setNamespaceDeclarations)
-    Q_PROPERTY(QmlList<QmlXmlListModelRole *> *roles READ roleObjects)
+    Q_PROPERTY(QmlListProperty<QmlXmlListModelRole> roles READ roleObjects)
     Q_PROPERTY(int count READ count NOTIFY countChanged)
     Q_CLASSINFO("DefaultProperty", "roles")
 
@@ -84,7 +84,7 @@ public:
     virtual QList<int> roles() const;
     virtual QString toString(int role) const;
 
-    QmlList<QmlXmlListModelRole *> *roleObjects();
+    QmlListProperty<QmlXmlListModelRole> roleObjects();
 
     QUrl source() const;
     void setSource(const QUrl&);
diff --git a/src/declarative/widgets/graphicslayouts.cpp b/src/declarative/widgets/graphicslayouts.cpp
index a8b5f70..62e941a 100644
--- a/src/declarative/widgets/graphicslayouts.cpp
+++ b/src/declarative/widgets/graphicslayouts.cpp
@@ -109,7 +109,7 @@ QSizeF QGraphicsLinearLayoutStretchItemObject::sizeHint(Qt::SizeHint which, cons
 
 
 QGraphicsLinearLayoutObject::QGraphicsLinearLayoutObject(QObject *parent)
-: QObject(parent), _children(this)
+: QObject(parent)
 {
 }
 
@@ -246,7 +246,7 @@ private:
 
 
 QGraphicsGridLayoutObject::QGraphicsGridLayoutObject(QObject *parent)
-: QObject(parent), _children(this)
+: QObject(parent)
 {
 }
 
diff --git a/src/declarative/widgets/graphicslayouts_p.h b/src/declarative/widgets/graphicslayouts_p.h
index 030be90..3076af1 100644
--- a/src/declarative/widgets/graphicslayouts_p.h
+++ b/src/declarative/widgets/graphicslayouts_p.h
@@ -69,7 +69,7 @@ class QGraphicsLinearLayoutObject : public QObject, public QGraphicsLinearLayout
     Q_OBJECT
     Q_INTERFACES(QGraphicsLayout QGraphicsLayoutItem)
 
-    Q_PROPERTY(QmlList<QGraphicsLayoutItem *> *children READ children)
+    Q_PROPERTY(QmlListProperty<QGraphicsLayoutItem> children READ children)
     Q_PROPERTY(Qt::Orientation orientation READ orientation WRITE setOrientation)
     Q_PROPERTY(qreal spacing READ spacing WRITE setSpacing)
     Q_CLASSINFO("DefaultProperty", "children")
@@ -77,7 +77,7 @@ public:
     QGraphicsLinearLayoutObject(QObject * = 0);
     ~QGraphicsLinearLayoutObject();
 
-    QmlList<QGraphicsLayoutItem *> *children() { return &_children; }
+    QmlListProperty<QGraphicsLayoutItem> children() { return QmlListProperty<QGraphicsLayoutItem>(this, 0, children_append, children_count, children_at, children_clear); }
 
     static LinearLayoutAttached *qmlAttachedProperties(QObject *);
 
@@ -91,27 +91,21 @@ private:
     void insertLayoutItem(int, QGraphicsLayoutItem *);
     static QHash<QGraphicsLayoutItem*, LinearLayoutAttached*> attachedProperties;
 
-    class ChildList : public QmlList<QGraphicsLayoutItem *>
-    {
-    public:
-        ChildList(QGraphicsLinearLayoutObject *o)
-            : obj(o) {}
-
-        virtual void append(QGraphicsLayoutItem *item)
-        {
-            insert(-1, item);
-        }
-        virtual void clear() { obj->clearChildren(); }
-        virtual int count() const { return obj->count(); }
-        virtual void removeAt(int i) { obj->removeAt(i); }
-        virtual QGraphicsLayoutItem *at(int i) const { return obj->itemAt(i); }
-        virtual void insert(int i, QGraphicsLayoutItem *item) { obj->insertLayoutItem(i, item); }
-
-    private:
-        QGraphicsLinearLayoutObject *obj;
-    };
-
-    ChildList _children;
+    static void children_append(QmlListProperty<QGraphicsLayoutItem> *prop, QGraphicsLayoutItem *item) {
+        static_cast<QGraphicsLinearLayoutObject*>(prop->object)->insertLayoutItem(-1, item);
+    }
+
+    static void children_clear(QmlListProperty<QGraphicsLayoutItem> *prop) {
+        static_cast<QGraphicsLinearLayoutObject*>(prop->object)->clearChildren();
+    }
+
+    static int children_count(QmlListProperty<QGraphicsLayoutItem> *prop) {
+        return static_cast<QGraphicsLinearLayoutObject*>(prop->object)->count();
+    }
+
+    static QGraphicsLayoutItem *children_at(QmlListProperty<QGraphicsLayoutItem> *prop, int index) {
+        return static_cast<QGraphicsLinearLayoutObject*>(prop->object)->itemAt(index);
+    }
 };
 
 class GridLayoutAttached;
@@ -120,7 +114,7 @@ class QGraphicsGridLayoutObject : public QObject, public QGraphicsGridLayout
     Q_OBJECT
     Q_INTERFACES(QGraphicsLayout QGraphicsLayoutItem)
 
-    Q_PROPERTY(QmlList<QGraphicsLayoutItem *> *children READ children)
+    Q_PROPERTY(QmlListProperty<QGraphicsLayoutItem> children READ children)
     Q_PROPERTY(qreal spacing READ spacing WRITE setSpacing)
     Q_PROPERTY(qreal verticalSpacing READ verticalSpacing WRITE setVerticalSpacing)
     Q_PROPERTY(qreal horizontalSpacing READ horizontalSpacing WRITE setHorizontalSpacing)
@@ -129,7 +123,7 @@ public:
     QGraphicsGridLayoutObject(QObject * = 0);
     ~QGraphicsGridLayoutObject();
 
-    QmlList<QGraphicsLayoutItem *> *children() { return &_children; }
+    QmlListProperty<QGraphicsLayoutItem> children() { return QmlListProperty<QGraphicsLayoutItem>(this, 0, children_append, children_count, children_at, children_clear); }
 
     qreal spacing() const;
 
@@ -142,30 +136,21 @@ private:
     void addLayoutItem(QGraphicsLayoutItem *);
     static QHash<QGraphicsLayoutItem*, GridLayoutAttached*> attachedProperties;
 
-    class ChildList : public QmlList<QGraphicsLayoutItem *>
-    {
-    public:
-        ChildList(QGraphicsGridLayoutObject *o)
-            : obj(o) {}
-
-        virtual void append(QGraphicsLayoutItem *o)
-        {
-            obj->addLayoutItem(o);
-        }
-        virtual void clear() { obj->clearChildren(); }
-        virtual int count() const { return obj->count(); }
-        virtual void removeAt(int i) { obj->removeAt(i); }
-        virtual QGraphicsLayoutItem *at(int i) const { return obj->itemAt(i); }
-        //### GridLayout doesn't have an insert, so for now we treat it as an append.
-        //    this is obviously potenitally dangerous -- perhaps should be a concrete
-        //    list with no relation to layout index, etc at all.
-        virtual void insert(int, QGraphicsLayoutItem *item) { append(item); }
-
-    private:
-        QGraphicsGridLayoutObject *obj;
-    };
-
-    ChildList _children;
+    static void children_append(QmlListProperty<QGraphicsLayoutItem> *prop, QGraphicsLayoutItem *item) {
+        static_cast<QGraphicsGridLayoutObject*>(prop->object)->addLayoutItem(item);
+    }
+
+    static void children_clear(QmlListProperty<QGraphicsLayoutItem> *prop) {
+        static_cast<QGraphicsGridLayoutObject*>(prop->object)->clearChildren();
+    }
+
+    static int children_count(QmlListProperty<QGraphicsLayoutItem> *prop) {
+        return static_cast<QGraphicsGridLayoutObject*>(prop->object)->count();
+    }
+
+    static QGraphicsLayoutItem *children_at(QmlListProperty<QGraphicsLayoutItem> *prop, int index) {
+        return static_cast<QGraphicsGridLayoutObject*>(prop->object)->itemAt(index);
+    }
 };
 
 QT_END_NAMESPACE
diff --git a/src/declarative/widgets/graphicswidgets.cpp b/src/declarative/widgets/graphicswidgets.cpp
index 5c7f093..bb4dc74 100644
--- a/src/declarative/widgets/graphicswidgets.cpp
+++ b/src/declarative/widgets/graphicswidgets.cpp
@@ -63,63 +63,31 @@ class QGraphicsSceneDeclarativeUI : public QObject
 {
     Q_OBJECT
 
-    Q_PROPERTY(QmlList<QObject *> *children READ children)
+    Q_PROPERTY(QmlListProperty<QObject> children READ children)
     Q_CLASSINFO("DefaultProperty", "children")
 public:
-    QGraphicsSceneDeclarativeUI(QObject *other) : QObject(other), _children(other) {}
+    QGraphicsSceneDeclarativeUI(QObject *other) : QObject(other) {}
 
-    QmlList<QObject *> *children() { return &_children; }
+    QmlListProperty<QObject> children() { return QmlListProperty<QObject>(this->parent(), 0, children_append); }
 
 private:
-    class Children : public QmlConcreteList<QObject *>
-    {
-    public:
-        Children(QObject *scene) : q(scene) {}
-        virtual void append(QObject *o)
-        {
-            insert(-1, o);
-        }
-        virtual void clear()
-        {
-            for (int i = 0; i < count(); ++i)
-                if (QGraphicsObject *go = qobject_cast<QGraphicsObject *>(at(i)))
-                    static_cast<QGraphicsScene *>(q)->removeItem(go);
-            QmlConcreteList<QObject *>::clear();
-        }
-        virtual void removeAt(int i)
-        {
-            if (QGraphicsObject *go = qobject_cast<QGraphicsObject *>(at(i)))
-                static_cast<QGraphicsScene *>(q)->removeItem(go);
-            QmlConcreteList<QObject *>::removeAt(i);
-        }
-        virtual void insert(int i, QObject *o)
-        {
-            QmlConcreteList<QObject *>::insert(i, o);
-            if (QGraphicsObject *go = qobject_cast<QGraphicsObject *>(o))
-                static_cast<QGraphicsScene *>(q)->addItem(go);
-            //else if (QWidget *w = qobject_cast<QWidget *>(o))
-            //    static_cast<QGraphicsScene *>(q)->addWidget(w);
-        }
-    private:
-        QObject *q;
-    };
-    Children _children;
+    static void children_append(QmlListProperty<QObject> *prop, QObject *o) {
+        if (QGraphicsObject *go = qobject_cast<QGraphicsObject *>(o))
+            static_cast<QGraphicsScene *>(prop->object)->addItem(go);
+    }
 };
 
 class QGraphicsWidgetDeclarativeUI : public QObject
 {
     Q_OBJECT
 
-    Q_PROPERTY(QmlList<QObject *> *data READ data)
-    Q_PROPERTY(QmlList<QGraphicsItem *> *children READ children)
+    Q_PROPERTY(QmlListProperty<QGraphicsItem> children READ children)
     Q_PROPERTY(QGraphicsLayout *layout READ layout WRITE setLayout)
     Q_CLASSINFO("DefaultProperty", "children")
 public:
-    QGraphicsWidgetDeclarativeUI(QObject *other) : QObject(other), _widgets(this) {}
-
-    QmlList<QObject *> *data() { return &_data; }
+    QGraphicsWidgetDeclarativeUI(QObject *other) : QObject(other) {}
 
-    QmlList<QGraphicsItem *> *children() { return &_widgets; }
+    QmlListProperty<QGraphicsItem> children() { return QmlListProperty<QGraphicsItem>(this, 0, children_append); }
 
     QGraphicsLayout *layout() const { return static_cast<QGraphicsWidget *>(parent())->layout(); }
     void setLayout(QGraphicsLayout *lo)
@@ -128,28 +96,14 @@ public:
     }
 
 private:
-    friend class WidgetList;
     void setItemParent(QGraphicsItem *wid)
     {
         wid->setParentItem(static_cast<QGraphicsWidget *>(parent()));
     }
 
-    class WidgetList : public QmlConcreteList<QGraphicsItem *>
-    {
-    public:
-        WidgetList(QGraphicsWidgetDeclarativeUI *o)
-            : obj(o) {}
-
-        virtual void append(QGraphicsItem *w)  { QmlConcreteList<QGraphicsItem *>::append(w); obj->setItemParent(w); }
-        virtual void clear() { QmlConcreteList<QGraphicsItem *>::clear(); } //###
-        virtual void removeAt(int i) { QmlConcreteList<QGraphicsItem *>::removeAt(i); }     //###
-        virtual void insert(int i, QGraphicsItem *item) { QmlConcreteList<QGraphicsItem *>::insert(i, item); obj->setItemParent(item); }
-
-    private:
-        QGraphicsWidgetDeclarativeUI *obj;
-    };
-    WidgetList _widgets;
-    QmlConcreteList<QObject *> _data;
+    static void children_append(QmlListProperty<QGraphicsItem> *prop, QGraphicsItem *i) {
+        static_cast<QGraphicsWidgetDeclarativeUI*>(prop->object)->setItemParent(i);
+    }
 };
 
 QML_DEFINE_EXTENDED_TYPE(Qt,4,6,QGraphicsView,QGraphicsView,QGraphicsViewDeclarativeUI)