Merge branch '4.7' of scm.dev.nokia.troll.no:qt/qt-qml into 4.7

13 files changed, 527 insertions, 73 deletions

diff --git a/src/declarative/qml/qdeclarativecompiler.cpp b/src/declarative/qml/qdeclarativecompiler.cpp
index a9d90f3..f1a673f 100644
--- a/src/declarative/qml/qdeclarativecompiler.cpp
+++ b/src/declarative/qml/qdeclarativecompiler.cpp
@@ -2428,10 +2428,18 @@ bool QDeclarativeCompiler::buildDynamicMeta(QDeclarativeParser::Object *obj, Dyn
             propertyType = QVariant::Color;
             type = "QColor";
             break;
+        case Object::DynamicProperty::Time:
+            propertyType = QVariant::Time;
+            type = "QTime";
+            break;
         case Object::DynamicProperty::Date:
             propertyType = QVariant::Date;
             type = "QDate";
             break;
+        case Object::DynamicProperty::DateTime:
+            propertyType = QVariant::DateTime;
+            type = "QDateTime";
+            break;
         }
 
         ((QDeclarativeVMEMetaData *)dynamicData.data())->propertyCount++;
diff --git a/src/declarative/qml/qdeclarativeengine.cpp b/src/declarative/qml/qdeclarativeengine.cpp
index dea5a40..5335b8c 100644
--- a/src/declarative/qml/qdeclarativeengine.cpp
+++ b/src/declarative/qml/qdeclarativeengine.cpp
@@ -1306,13 +1306,14 @@ QScriptValue QDeclarativeEnginePrivate::tint(QScriptContext *ctxt, QScriptEngine
 QScriptValue QDeclarativeEnginePrivate::scriptValueFromVariant(const QVariant &val)
 {
     if (val.userType() == qMetaTypeId<QDeclarativeListReference>()) {
-        QDeclarativeListReferencePrivate *p = QDeclarativeListReferencePrivate::get((QDeclarativeListReference*)val.constData());
+        QDeclarativeListReferencePrivate *p = 
+            QDeclarativeListReferencePrivate::get((QDeclarativeListReference*)val.constData());
         if (p->object) {
             return listClass->newList(p->property, p->propertyType);
         } else {
             return scriptEngine.nullValue();
         }
-    }
+    } 
 
     bool objOk;
     QObject *obj = QDeclarativeMetaType::toQObject(val, &objOk);
@@ -1809,25 +1810,39 @@ QUrl QDeclarativeEnginePrivate::Imports::baseUrl() const
   Adds \a path as a directory where installed QML components are
   defined in a URL-based directory structure.
 
-  For example, if you add \c /opt/MyApp/lib/imports and then load QML
-  that imports \c com.mycompany.Feature, then QDeclarativeEngine will look
+  \sa importPathList()
+*/
+void QDeclarativeEngine::addImportPath(const QString& path)
+{
+    if (qmlImportTrace())
+        qDebug() << "QDeclarativeEngine::addImportPath" << path;
+    Q_D(QDeclarativeEngine);
+    d->fileImportPath.prepend(path);
+}
+
+
+/*!
+  Returns the list of directories with the engine searches for
+  installed modules.
+
+  For example, if \c /opt/MyApp/lib/imports is in the path, then QML that
+  imports \c com.mycompany.Feature will cause the QDeclarativeEngine to look
   in \c /opt/MyApp/lib/imports/com/mycompany/Feature/ for the components
-  provided by that module. A \c qmldir file is required for definiting the
+  provided by that module. A \c qmldir file is required for defining the
   type version mapping and possibly declarative extensions plugins.
 
-  The engine searches in the base directory of the qml file, then
-  the paths added via addImportPath(), then in the directory containing the
+  In addition to this list,
+  the engine searches in the directory containing the
   application executable (QCoreApplication::applicationDirPath()),
   then the paths specified in the \c QML_IMPORT_PATH environment variable, then the
   builtin \c ImportsPath from QLibraryInfo.
 
+  \sa addImportPath()
 */
-void QDeclarativeEngine::addImportPath(const QString& path)
+QStringList QDeclarativeEngine::importPathList() const
 {
-    if (qmlImportTrace())
-        qDebug() << "QDeclarativeEngine::addImportPath" << path;
-    Q_D(QDeclarativeEngine);
-    d->fileImportPath.prepend(path);
+    Q_D(const QDeclarativeEngine);
+    return d->fileImportPath;
 }
 
 /*!
diff --git a/src/declarative/qml/qdeclarativeengine.h b/src/declarative/qml/qdeclarativeengine.h
index 19e81b6..a24962e 100644
--- a/src/declarative/qml/qdeclarativeengine.h
+++ b/src/declarative/qml/qdeclarativeengine.h
@@ -78,6 +78,7 @@ public:
     void clearComponentCache();
 
     void addImportPath(const QString& dir);
+    QStringList importPathList() const;
     bool importExtension(const QString &fileName, const QString &uri);
 
     void setNetworkAccessManagerFactory(QDeclarativeNetworkAccessManagerFactory *);
diff --git a/src/declarative/qml/qdeclarativeparser_p.h b/src/declarative/qml/qdeclarativeparser_p.h
index 476b027..f432024 100644
--- a/src/declarative/qml/qdeclarativeparser_p.h
+++ b/src/declarative/qml/qdeclarativeparser_p.h
@@ -203,7 +203,7 @@ namespace QDeclarativeParser
             DynamicProperty();
             DynamicProperty(const DynamicProperty &);
 
-            enum Type { Variant, Int, Bool, Real, String, Url, Color, Date, Alias, Custom, CustomList };
+            enum Type { Variant, Int, Bool, Real, String, Url, Color, Time, Date, DateTime, Alias, Custom, CustomList };
 
             bool isDefaultProperty;
             Type type;
diff --git a/src/declarative/qml/qdeclarativescriptparser.cpp b/src/declarative/qml/qdeclarativescriptparser.cpp
index 49bd3b7..9fff294 100644
--- a/src/declarative/qml/qdeclarativescriptparser.cpp
+++ b/src/declarative/qml/qdeclarativescriptparser.cpp
@@ -528,9 +528,14 @@ bool ProcessAST::visit(AST::UiPublicMember *node)
         { "string", Object::DynamicProperty::String, "QString" },
         { "url", Object::DynamicProperty::Url, "QUrl" },
         { "color", Object::DynamicProperty::Color, "QColor" },
-        { "date", Object::DynamicProperty::Date, "QDate" },
-        { "var", Object::DynamicProperty::Variant, "QVariant" },
-        { "variant", Object::DynamicProperty::Variant, "QVariant" }
+        // Internally QTime, QDate and QDateTime are all supported.
+        // To be more consistent with JavaScript we expose only
+        // QDateTime as it matches closely with the Date JS type.
+        // We also call it "date" to match.
+        // { "time", Object::DynamicProperty::Time, "QTime" },
+        // { "date", Object::DynamicProperty::Date, "QDate" },
+        { "date", Object::DynamicProperty::DateTime, "QDateTime" },
+        { "var", Object::DynamicProperty::Variant, "QVariant" }
     };
     const int propTypeNameToTypesCount = sizeof(propTypeNameToTypes) /
                                          sizeof(propTypeNameToTypes[0]);
diff --git a/src/declarative/qml/qdeclarativevmemetaobject.cpp b/src/declarative/qml/qdeclarativevmemetaobject.cpp
index f9c99ee..9a7bdd6 100644
--- a/src/declarative/qml/qdeclarativevmemetaobject.cpp
+++ b/src/declarative/qml/qdeclarativevmemetaobject.cpp
@@ -47,19 +47,340 @@
 #include "qdeclarativeexpression_p.h"
 #include "qdeclarativecontext_p.h"
 
-#include <QColor>
-#include <QDate>
-#include <QtCore/qlist.h>
-#include <QtCore/qdebug.h>
+Q_DECLARE_METATYPE(QScriptValue);
 
 QT_BEGIN_NAMESPACE
 
+class QDeclarativeVMEVariant
+{
+public:
+    inline QDeclarativeVMEVariant();
+    inline ~QDeclarativeVMEVariant();
+
+    inline const void *dataPtr() const;
+    inline void *dataPtr();
+    inline int dataType() const;
+
+    inline QObject *asQObject();
+    inline const QVariant &asQVariant();
+    inline int asInt();
+    inline bool asBool();
+    inline double asDouble();
+    inline const QString &asQString();
+    inline const QUrl &asQUrl();
+    inline const QColor &asQColor();
+    inline const QTime &asQTime();
+    inline const QDate &asQDate();
+    inline const QDateTime &asQDateTime();
+    inline const QScriptValue &asQScriptValue();
+
+    inline void setValue(QObject *);
+    inline void setValue(const QVariant &);
+    inline void setValue(int);
+    inline void setValue(bool);
+    inline void setValue(double);
+    inline void setValue(const QString &);
+    inline void setValue(const QUrl &);
+    inline void setValue(const QColor &);
+    inline void setValue(const QTime &);
+    inline void setValue(const QDate &);
+    inline void setValue(const QDateTime &);
+    inline void setValue(const QScriptValue &);
+
+private:
+    int type;
+    void *data[4]; // Large enough to hold all types
+
+    inline void cleanup();
+};
+
+QDeclarativeVMEVariant::QDeclarativeVMEVariant()
+: type(QVariant::Invalid)
+{
+}
+
+QDeclarativeVMEVariant::~QDeclarativeVMEVariant()
+{
+    cleanup();
+}
+
+void QDeclarativeVMEVariant::cleanup()
+{
+    if (type == QVariant::Invalid) {
+    } else if (type == QMetaType::QObjectStar ||
+               type == QMetaType::Int ||
+               type == QMetaType::Bool ||
+               type == QMetaType::Double) {
+        type = QVariant::Invalid;
+    } else if (type == QMetaType::QString) {
+        ((QString *)dataPtr())->~QString();
+        type = QVariant::Invalid;
+    } else if (type == QMetaType::QUrl) {
+        ((QUrl *)dataPtr())->~QUrl();
+        type = QVariant::Invalid;
+    } else if (type == QMetaType::QColor) {
+        ((QColor *)dataPtr())->~QColor();
+        type = QVariant::Invalid;
+    } else if (type == QMetaType::QTime) {
+        ((QTime *)dataPtr())->~QTime();
+        type = QVariant::Invalid;
+    } else if (type == QMetaType::QDate) {
+        ((QDate *)dataPtr())->~QDate();
+        type = QVariant::Invalid;
+    } else if (type == QMetaType::QDateTime) {
+        ((QDateTime *)dataPtr())->~QDateTime();
+        type = QVariant::Invalid;
+    } else if (type == qMetaTypeId<QVariant>()) {
+        ((QVariant *)dataPtr())->~QVariant();
+        type = QVariant::Invalid;
+    } else if (type == qMetaTypeId<QScriptValue>()) {
+        ((QScriptValue *)dataPtr())->~QScriptValue();
+        type = QVariant::Invalid;
+    }
+
+}
+
+int QDeclarativeVMEVariant::dataType() const
+{
+    return type;
+}
+
+const void *QDeclarativeVMEVariant::dataPtr() const
+{
+    return &data;
+}
+
+void *QDeclarativeVMEVariant::dataPtr() 
+{
+    return &data;
+}
+
+QObject *QDeclarativeVMEVariant::asQObject() 
+{
+    if (type != QMetaType::QObjectStar) 
+        setValue((QObject *)0);
+
+    return *(QObject **)(dataPtr());
+}
+
+const QVariant &QDeclarativeVMEVariant::asQVariant() 
+{
+    if (type != QMetaType::QVariant)
+        setValue(QVariant());
+
+    return *(QVariant *)(dataPtr());
+}
+
+int QDeclarativeVMEVariant::asInt() 
+{
+    if (type != QMetaType::Int)
+        setValue(int(0));
+
+    return *(int *)(dataPtr());
+}
+
+bool QDeclarativeVMEVariant::asBool() 
+{
+    if (type != QMetaType::Bool)
+        setValue(bool(false));
+
+    return *(bool *)(dataPtr());
+}
+
+double QDeclarativeVMEVariant::asDouble() 
+{
+    if (type != QMetaType::Double)
+        setValue(double(0));
+
+    return *(double *)(dataPtr());
+}
+
+const QString &QDeclarativeVMEVariant::asQString() 
+{
+    if (type != QMetaType::QString)
+        setValue(QString());
+
+    return *(QString *)(dataPtr());
+}
+
+const QUrl &QDeclarativeVMEVariant::asQUrl() 
+{
+    if (type != QMetaType::QUrl)
+        setValue(QUrl());
+
+    return *(QUrl *)(dataPtr());
+}
+
+const QColor &QDeclarativeVMEVariant::asQColor() 
+{
+    if (type != QMetaType::QColor)
+        setValue(QColor());
+
+    return *(QColor *)(dataPtr());
+}
+
+const QTime &QDeclarativeVMEVariant::asQTime() 
+{
+    if (type != QMetaType::QTime)
+        setValue(QTime());
+
+    return *(QTime *)(dataPtr());
+}
+
+const QDate &QDeclarativeVMEVariant::asQDate() 
+{
+    if (type != QMetaType::QDate)
+        setValue(QDate());
+
+    return *(QDate *)(dataPtr());
+}
+
+const QDateTime &QDeclarativeVMEVariant::asQDateTime() 
+{
+    if (type != QMetaType::QDateTime)
+        setValue(QDateTime());
+
+    return *(QDateTime *)(dataPtr());
+}
+
+const QScriptValue &QDeclarativeVMEVariant::asQScriptValue() 
+{
+    if (type != qMetaTypeId<QScriptValue>())
+        setValue(QScriptValue());
+
+    return *(QScriptValue *)(dataPtr());
+}
+
+void QDeclarativeVMEVariant::setValue(QObject *v)
+{
+    if (type != QMetaType::QObjectStar) {
+        cleanup();
+        type = QMetaType::QObjectStar;
+    }
+    *(QObject **)(dataPtr()) = v;
+}
+
+void QDeclarativeVMEVariant::setValue(const QVariant &v)
+{
+    if (type != qMetaTypeId<QVariant>()) {
+        cleanup();
+        type = qMetaTypeId<QVariant>();
+        new (dataPtr()) QVariant(v);
+    } else {
+        *(QVariant *)(dataPtr()) = v;
+    }
+}
+
+void QDeclarativeVMEVariant::setValue(int v)
+{
+    if (type != QMetaType::Int) {
+        cleanup();
+        type = QMetaType::Int;
+    }
+    *(int *)(dataPtr()) = v;
+}
+
+void QDeclarativeVMEVariant::setValue(bool v)
+{
+    if (type != QMetaType::Bool) {
+        cleanup();
+        type = QMetaType::Bool;
+    }
+    *(bool *)(dataPtr()) = v;
+}
+
+void QDeclarativeVMEVariant::setValue(double v)
+{
+    if (type != QMetaType::Double) {
+        cleanup();
+        type = QMetaType::Double;
+    }
+    *(double *)(dataPtr()) = v;
+}
+
+void QDeclarativeVMEVariant::setValue(const QString &v)
+{
+    if (type != QMetaType::QString) {
+        cleanup();
+        type = QMetaType::QString;
+        new (dataPtr()) QString(v);
+    } else {
+        *(QString *)(dataPtr()) = v;
+    }
+}
+
+void QDeclarativeVMEVariant::setValue(const QUrl &v)
+{
+    if (type != QMetaType::QUrl) {
+        cleanup();
+        type = QMetaType::QUrl;
+        new (dataPtr()) QUrl(v);
+    } else {
+        *(QUrl *)(dataPtr()) = v;
+    }
+}
+
+void QDeclarativeVMEVariant::setValue(const QColor &v)
+{
+    if (type != QMetaType::QColor) {
+        cleanup();
+        type = QMetaType::QColor;
+        new (dataPtr()) QColor(v);
+    } else {
+        *(QColor *)(dataPtr()) = v;
+    }
+}
+
+void QDeclarativeVMEVariant::setValue(const QTime &v)
+{
+    if (type != QMetaType::QTime) {
+        cleanup();
+        type = QMetaType::QTime;
+        new (dataPtr()) QTime(v);
+    } else {
+        *(QTime *)(dataPtr()) = v;
+    }
+}
+
+void QDeclarativeVMEVariant::setValue(const QDate &v)
+{
+    if (type != QMetaType::QDate) {
+        cleanup();
+        type = QMetaType::QDate;
+        new (dataPtr()) QDate(v);
+    } else {
+        *(QDate *)(dataPtr()) = v;
+    }
+}
+
+void QDeclarativeVMEVariant::setValue(const QDateTime &v)
+{
+    if (type != QMetaType::QDateTime) {
+        cleanup();
+        type = QMetaType::QDateTime;
+        new (dataPtr()) QDateTime(v);
+    } else {
+        *(QDateTime *)(dataPtr()) = v;
+    }
+}
+
+void QDeclarativeVMEVariant::setValue(const QScriptValue &v)
+{
+    if (type != qMetaTypeId<QScriptValue>()) {
+        cleanup();
+        type = qMetaTypeId<QScriptValue>();
+        new (dataPtr()) QScriptValue(v);
+    } else {
+        *(QScriptValue *)(dataPtr()) = v;
+    }
+}
+
 QDeclarativeVMEMetaObject::QDeclarativeVMEMetaObject(QObject *obj,
                                                      const QMetaObject *other, 
                                                      const QDeclarativeVMEMetaData *meta,
                                                      QDeclarativeCompiledData *cdata)
 : object(obj), compiledData(cdata), ctxt(QDeclarativeDeclarativeData::get(obj)->outerContext), 
-  metaData(meta), methods(0), parent(0)
+  metaData(meta), data(0), methods(0), parent(0)
 {
     compiledData->addref();
 
@@ -74,20 +395,18 @@ QDeclarativeVMEMetaObject::QDeclarativeVMEMetaObject(QObject *obj,
     propOffset = QAbstractDynamicMetaObject::propertyOffset();
     methodOffset = QAbstractDynamicMetaObject::methodOffset();
 
-    data = new QVariant[metaData->propertyCount];
-    aConnected.resize(metaData->aliasCount);
+    data = new QDeclarativeVMEVariant[metaData->propertyCount];
 
+    aConnected.resize(metaData->aliasCount);
     int list_type = qMetaTypeId<QDeclarativeListProperty<QObject> >();
+
     // ### Optimize
     for (int ii = 0; ii < metaData->propertyCount; ++ii) {
         int t = (metaData->propertyData() + ii)->propertyType;
         if (t == list_type) {
-            listProperties.append(new List(methodOffset + ii));
-            data[ii] = QVariant::fromValue(QDeclarativeListProperty<QObject>(obj, listProperties.last(), list_append,
-                                                                    list_count, list_at, list_clear));
-        } else if (t != -1) {
-            data[ii] = QVariant((QVariant::Type)t);
-        }
+            listProperties.append(List(methodOffset + ii));
+            data[ii].setValue(listProperties.count() - 1);
+        } 
     }
 }
 
@@ -95,7 +414,6 @@ QDeclarativeVMEMetaObject::~QDeclarativeVMEMetaObject()
 {
     compiledData->release();
     delete parent;
-    qDeleteAll(listProperties);
     delete [] data;
     delete [] methods;
 }
@@ -145,11 +463,10 @@ int QDeclarativeVMEMetaObject::metaCall(QMetaObject::Call c, int _id, void **a)
                 if (t == -1) {
 
                     if (c == QMetaObject::ReadProperty) {
-                        *reinterpret_cast<QVariant *>(a[0]) = data[id];
+                        *reinterpret_cast<QVariant *>(a[0]) = readVarPropertyAsVariant(id);
                     } else if (c == QMetaObject::WriteProperty) {
-                        needActivate = 
-                            (data[id] != *reinterpret_cast<QVariant *>(a[0]));
-                        data[id] = *reinterpret_cast<QVariant *>(a[0]);
+                        needActivate = (data[id].asQVariant() != *reinterpret_cast<QVariant *>(a[0]));
+                        data[id].setValue(*reinterpret_cast<QVariant *>(a[0]));
                     }
 
                 } else {
@@ -157,42 +474,86 @@ int QDeclarativeVMEMetaObject::metaCall(QMetaObject::Call c, int _id, void **a)
                     if (c == QMetaObject::ReadProperty) {
                         switch(t) {
                         case QVariant::Int:
-                            *reinterpret_cast<int *>(a[0]) = data[id].toInt();
+                            *reinterpret_cast<int *>(a[0]) = data[id].asInt();
                             break;
                         case QVariant::Bool:
-                            *reinterpret_cast<bool *>(a[0]) = data[id].toBool();
+                            *reinterpret_cast<bool *>(a[0]) = data[id].asBool();
                             break;
                         case QVariant::Double:
-                            *reinterpret_cast<double *>(a[0]) = data[id].toDouble();
+                            *reinterpret_cast<double *>(a[0]) = data[id].asDouble();
                             break;
                         case QVariant::String:
-                            *reinterpret_cast<QString *>(a[0]) = data[id].toString();
+                            *reinterpret_cast<QString *>(a[0]) = data[id].asQString();
                             break;
                         case QVariant::Url:
-                            *reinterpret_cast<QUrl *>(a[0]) = data[id].toUrl();
+                            *reinterpret_cast<QUrl *>(a[0]) = data[id].asQUrl();
                             break;
                         case QVariant::Color:
-                            *reinterpret_cast<QColor *>(a[0]) = data[id].value<QColor>();
+                            *reinterpret_cast<QColor *>(a[0]) = data[id].asQColor();
                             break;
                         case QVariant::Date:
-                            *reinterpret_cast<QDate *>(a[0]) = data[id].toDate();
+                            *reinterpret_cast<QDate *>(a[0]) = data[id].asQDate();
+                            break;
+                        case QVariant::DateTime:
+                            *reinterpret_cast<QDateTime *>(a[0]) = data[id].asQDateTime();
                             break;
                         case QMetaType::QObjectStar:
-                            *reinterpret_cast<QObject **>(a[0]) = data[id].value<QObject*>();
+                            *reinterpret_cast<QObject **>(a[0]) = data[id].asQObject();
                             break;
                         default:
                             break;
                         }
                         if (t == qMetaTypeId<QDeclarativeListProperty<QObject> >()) {
+                            int listIndex = data[id].asInt();
+                            const List *list = &listProperties.at(listIndex);
                             *reinterpret_cast<QDeclarativeListProperty<QObject> *>(a[0]) = 
-                                data[id].value<QDeclarativeListProperty<QObject> >();
+                                QDeclarativeListProperty<QObject>(object, (void *)list,
+                                                                  list_append, list_count, list_at, 
+                                                                  list_clear);
                         }
 
                     } else if (c == QMetaObject::WriteProperty) {
 
-                        QVariant value = QVariant((QVariant::Type)data[id].type(), a[0]); 
-                        needActivate = (data[id] != value);
-                        data[id] = value;
+                        switch(t) {
+                        case QVariant::Int:
+                            needActivate = *reinterpret_cast<int *>(a[0]) != data[id].asInt();
+                            data[id].setValue(*reinterpret_cast<int *>(a[0]));
+                            break;
+                        case QVariant::Bool:
+                            needActivate = *reinterpret_cast<bool *>(a[0]) != data[id].asBool();
+                            data[id].setValue(*reinterpret_cast<bool *>(a[0]));
+                            break;
+                        case QVariant::Double:
+                            needActivate = *reinterpret_cast<double *>(a[0]) != data[id].asDouble();
+                            data[id].setValue(*reinterpret_cast<double *>(a[0]));
+                            break;
+                        case QVariant::String:
+                            needActivate = *reinterpret_cast<QString *>(a[0]) != data[id].asQString();
+                            data[id].setValue(*reinterpret_cast<QString *>(a[0]));
+                            break;
+                        case QVariant::Url:
+                            needActivate = *reinterpret_cast<QUrl *>(a[0]) != data[id].asQUrl();
+                            data[id].setValue(*reinterpret_cast<QUrl *>(a[0]));
+                            break;
+                        case QVariant::Color:
+                            needActivate = *reinterpret_cast<QColor *>(a[0]) != data[id].asQColor();
+                            data[id].setValue(*reinterpret_cast<QColor *>(a[0]));
+                            break;
+                        case QVariant::Date:
+                            needActivate = *reinterpret_cast<QDate *>(a[0]) != data[id].asQDate();
+                            data[id].setValue(*reinterpret_cast<QDate *>(a[0]));
+                            break;
+                        case QVariant::DateTime:
+                            needActivate = *reinterpret_cast<QDateTime *>(a[0]) != data[id].asQDateTime();
+                            data[id].setValue(*reinterpret_cast<QDateTime *>(a[0]));
+                            break;
+                        case QMetaType::QObjectStar:
+                            needActivate = *reinterpret_cast<QObject **>(a[0]) != data[id].asQObject();
+                            data[id].setValue(*reinterpret_cast<QObject **>(a[0]));
+                            break;
+                        default:
+                            break;
+                        }
                     }
 
                 }
@@ -316,6 +677,28 @@ QScriptValue QDeclarativeVMEMetaObject::method(int index)
     return methods[index];
 }
 
+QScriptValue QDeclarativeVMEMetaObject::readVarProperty(int id)
+{
+    if (data[id].dataType() == qMetaTypeId<QScriptValue>())
+        return data[id].asQScriptValue();
+    else
+        return QDeclarativeEnginePrivate::get(ctxt->engine)->scriptValueFromVariant(data[id].asQVariant());
+}
+
+QVariant QDeclarativeVMEMetaObject::readVarPropertyAsVariant(int id)
+{
+    if (data[id].dataType() == qMetaTypeId<QScriptValue>())
+        return QDeclarativeEnginePrivate::get(ctxt->engine)->scriptValueToVariant(data[id].asQScriptValue());
+    else
+        return data[id].asQVariant();
+}
+
+void QDeclarativeVMEMetaObject::writeVarProperty(int id, const QScriptValue &value)
+{
+    data[id].setValue(value);
+    activate(object, methodOffset + id, 0);
+}
+
 void QDeclarativeVMEMetaObject::listChanged(int id)
 {
     activate(object, methodOffset + id, 0);
@@ -364,4 +747,22 @@ QScriptValue QDeclarativeVMEMetaObject::vmeMethod(int index)
     return method(index - methodOffset - plainSignals);
 }
 
+QScriptValue QDeclarativeVMEMetaObject::vmeProperty(int index)
+{
+    if (index < propOffset) {
+        Q_ASSERT(parent);
+        return static_cast<QDeclarativeVMEMetaObject *>(parent)->vmeProperty(index);
+    }
+    return readVarProperty(index - propOffset);
+}
+
+void QDeclarativeVMEMetaObject::setVMEProperty(int index, const QScriptValue &v)
+{
+    if (index < propOffset) {
+        Q_ASSERT(parent);
+        static_cast<QDeclarativeVMEMetaObject *>(parent)->setVMEProperty(index, v);
+    }
+    return writeVarProperty(index - propOffset, v);
+}
+
 QT_END_NAMESPACE
diff --git a/src/declarative/qml/qdeclarativevmemetaobject_p.h b/src/declarative/qml/qdeclarativevmemetaobject_p.h
index e11f6fa..839f0cd 100644
--- a/src/declarative/qml/qdeclarativevmemetaobject_p.h
+++ b/src/declarative/qml/qdeclarativevmemetaobject_p.h
@@ -58,6 +58,10 @@
 #include <QtCore/QMetaObject>
 #include <QtCore/QBitArray>
 #include <QtCore/QPair>
+#include <QtGui/QColor>
+#include <QtCore/QDate>
+#include <QtCore/qlist.h>
+#include <QtCore/qdebug.h>
 
 #include <private/qobject_p.h>
 
@@ -106,6 +110,7 @@ struct QDeclarativeVMEMetaData
     }
 };
 
+class QDeclarativeVMEVariant;
 class QDeclarativeRefCount;
 class QDeclarativeVMEMetaObject : public QAbstractDynamicMetaObject
 {
@@ -116,6 +121,9 @@ public:
 
     void registerInterceptor(int index, int valueIndex, QDeclarativePropertyValueInterceptor *interceptor);
     QScriptValue vmeMethod(int index);
+    QScriptValue vmeProperty(int index);
+    void setVMEProperty(int index, const QScriptValue &);
+
 protected:
     virtual int metaCall(QMetaObject::Call _c, int _id, void **_a);
 
@@ -128,7 +136,8 @@ private:
     int propOffset;
     int methodOffset;
 
-    QVariant *data;
+    QDeclarativeVMEVariant *data;
+
     QBitArray aConnected;
     QBitArray aInterceptors;
     QHash<int, QPair<int, QDeclarativePropertyValueInterceptor*> > interceptors;
@@ -136,6 +145,10 @@ private:
     QScriptValue *methods;
     QScriptValue method(int);
 
+    QScriptValue readVarProperty(int);
+    QVariant readVarPropertyAsVariant(int);
+    void writeVarProperty(int, const QScriptValue &);
+
     QAbstractDynamicMetaObject *parent;
 
     void listChanged(int);
@@ -145,7 +158,7 @@ private:
         List(int lpi) : notifyIndex(lpi) {}
         int notifyIndex;
     };
-    QList<List *> listProperties;
+    QList<List> listProperties;
 
     static void list_append(QDeclarativeListProperty<QObject> *, QObject *);
     static int list_count(QDeclarativeListProperty<QObject> *);
diff --git a/src/declarative/util/qdeclarativelistmodel.cpp b/src/declarative/util/qdeclarativelistmodel.cpp
index 3904458..1a28176 100644
--- a/src/declarative/util/qdeclarativelistmodel.cpp
+++ b/src/declarative/util/qdeclarativelistmodel.cpp
@@ -1250,14 +1250,9 @@ ModelNode::ModelNode()
 
 ModelNode::~ModelNode()
 {
-    ModelNode *node;
-
-    QList<ModelNode *> nodeValues = properties.values();
-    for (int ii = 0; ii < nodeValues.count(); ++ii) {
-        node = nodeValues[ii];
-        if (node) { delete node; node = 0; }
-    }
+    qDeleteAll(properties.values());
 
+    ModelNode *node;
     for (int ii = 0; ii < values.count(); ++ii) {
         node = qvariant_cast<ModelNode *>(values.at(ii));
         if (node) { delete node; node = 0; }
@@ -1279,7 +1274,9 @@ void ModelNode::setObjectValue(const QScriptValue& valuemap) {
         } else {
             value->values << v.toVariant();
         }
-        properties.insert(it.name(),value);
+        if (properties.contains(it.name()))
+            delete properties[it.name()];
+        properties.insert(it.name(), value);
     }
 }
 
diff --git a/src/declarative/util/qdeclarativeopenmetaobject.cpp b/src/declarative/util/qdeclarativeopenmetaobject.cpp
index 8c23354..6611885 100644
--- a/src/declarative/util/qdeclarativeopenmetaobject.cpp
+++ b/src/declarative/util/qdeclarativeopenmetaobject.cpp
@@ -222,9 +222,10 @@ int QDeclarativeOpenMetaObject::metaCall(QMetaObject::Call c, int id, void **a)
             propertyRead(propId);
             *reinterpret_cast<QVariant *>(a[0]) = d->getData(propId);
         } else if (c == QMetaObject::WriteProperty) {
-            if (d->data[propId].first != *reinterpret_cast<QVariant *>(a[0]))  {
+            if (propId <= d->data.count() || d->data[propId].first != *reinterpret_cast<QVariant *>(a[0]))  {
                 propertyWrite(propId);
                 d->writeData(propId, *reinterpret_cast<QVariant *>(a[0]));
+                propertyWritten(propId);
                 activate(d->object, d->type->d->signalOffset + propId, 0);
             }
         } 
@@ -270,6 +271,11 @@ QVariant &QDeclarativeOpenMetaObject::operator[](const QByteArray &name)
     return d->getData(*iter);
 }
 
+QVariant &QDeclarativeOpenMetaObject::operator[](int id)
+{
+    return d->getData(id);
+}
+
 void QDeclarativeOpenMetaObject::setValue(const QByteArray &name, const QVariant &val)
 {
     QHash<QByteArray, int>::ConstIterator iter = d->type->d->names.find(name);
@@ -326,6 +332,10 @@ void QDeclarativeOpenMetaObject::propertyWrite(int)
 {
 }
 
+void QDeclarativeOpenMetaObject::propertyWritten(int)
+{
+}
+
 void QDeclarativeOpenMetaObject::propertyCreated(int, QMetaPropertyBuilder &)
 {
 }
diff --git a/src/declarative/util/qdeclarativeopenmetaobject_p.h b/src/declarative/util/qdeclarativeopenmetaobject_p.h
index ec5ac17..9bb4c34 100644
--- a/src/declarative/util/qdeclarativeopenmetaobject_p.h
+++ b/src/declarative/util/qdeclarativeopenmetaobject_p.h
@@ -90,6 +90,7 @@ public:
     QVariant value(int) const;
     void setValue(int, const QVariant &);
     QVariant &operator[](const QByteArray &);
+    QVariant &operator[](int);
 
     int count() const;
     QByteArray name(int) const;
@@ -109,6 +110,7 @@ protected:
 
     virtual void propertyRead(int);
     virtual void propertyWrite(int);
+    virtual void propertyWritten(int);
     virtual void propertyCreated(int, QMetaPropertyBuilder &);
 
     QAbstractDynamicMetaObject *parent() const;
diff --git a/src/declarative/util/qdeclarativepropertymap.cpp b/src/declarative/util/qdeclarativepropertymap.cpp
index fcea515..0bdd91b 100644
--- a/src/declarative/util/qdeclarativepropertymap.cpp
+++ b/src/declarative/util/qdeclarativepropertymap.cpp
@@ -41,6 +41,7 @@
 
 #include "qdeclarativepropertymap.h"
 
+#include <private/qmetaobjectbuilder_p.h>
 #include "qdeclarativeopenmetaobject_p.h"
 
 #include <QDebug>
@@ -55,7 +56,8 @@ public:
     QDeclarativePropertyMapMetaObject(QDeclarativePropertyMap *obj, QDeclarativePropertyMapPrivate *objPriv);
 
 protected:
-    virtual void propertyWrite(int index);
+    virtual void propertyWritten(int index);
+    virtual void propertyCreated(int, QMetaPropertyBuilder &);
 
 private:
     QDeclarativePropertyMap *map;
@@ -68,13 +70,13 @@ class QDeclarativePropertyMapPrivate : public QObjectPrivate
 public:
     QDeclarativePropertyMapMetaObject *mo;
     QStringList keys;
-    void emitChanged(const QString &key);
+    void emitChanged(const QString &key, const QVariant &value);
 };
 
-void QDeclarativePropertyMapPrivate::emitChanged(const QString &key)
+void QDeclarativePropertyMapPrivate::emitChanged(const QString &key, const QVariant &value)
 {
     Q_Q(QDeclarativePropertyMap);
-    emit q->valueChanged(key);
+    emit q->valueChanged(key, value);
 }
 
 QDeclarativePropertyMapMetaObject::QDeclarativePropertyMapMetaObject(QDeclarativePropertyMap *obj, QDeclarativePropertyMapPrivate *objPriv) : QDeclarativeOpenMetaObject(obj)
@@ -83,14 +85,19 @@ QDeclarativePropertyMapMetaObject::QDeclarativePropertyMapMetaObject(QDeclarativ
     priv = objPriv;
 }
 
-void QDeclarativePropertyMapMetaObject::propertyWrite(int index)
+void QDeclarativePropertyMapMetaObject::propertyWritten(int index)
 {
-    priv->emitChanged(QString::fromUtf8(name(index)));
+    priv->emitChanged(QString::fromUtf8(name(index)), operator[](index));
+}
+
+void QDeclarativePropertyMapMetaObject::propertyCreated(int, QMetaPropertyBuilder &b)
+{
+    priv->keys.append(QString::fromUtf8(b.name()));
 }
 
 /*!
     \class QDeclarativePropertyMap
-  \since 4.7
+    \since 4.7
     \brief The QDeclarativePropertyMap class allows you to set key-value pairs that can be used in bindings.
 
     QDeclarativePropertyMap provides a convenient way to expose domain data to the UI layer.
@@ -172,8 +179,6 @@ QVariant QDeclarativePropertyMap::value(const QString &key) const
 void QDeclarativePropertyMap::insert(const QString &key, const QVariant &value)
 {
     Q_D(QDeclarativePropertyMap);
-    if (!d->keys.contains(key))
-        d->keys.append(key);
     d->mo->setValue(key.toUtf8(), value);
 }
 
@@ -249,10 +254,8 @@ QVariant &QDeclarativePropertyMap::operator[](const QString &key)
     //### optimize
     Q_D(QDeclarativePropertyMap);
     QByteArray utf8key = key.toUtf8();
-    if (!d->keys.contains(key)) {
-        d->keys.append(key);
+    if (!d->keys.contains(key))
         d->mo->setValue(utf8key, QVariant());   //force creation -- needed below
-    }
 
     return (*(d->mo))[utf8key];
 }
@@ -268,9 +271,9 @@ const QVariant QDeclarativePropertyMap::operator[](const QString &key) const
 }
 
 /*!
-    \fn void QDeclarativePropertyMap::valueChanged(const QString &key)
+    \fn void QDeclarativePropertyMap::valueChanged(const QString &key, const QVariant &value)
     This signal is emitted whenever one of the values in the map is changed. \a key
-    is the key corresponding to the value that was changed.
+    is the key corresponding to the \a value that was changed.
 
     \note valueChanged() is \bold NOT emitted when changes are made by calling insert()
     or clear() - it is only emitted when a value is updated from QML.
diff --git a/src/declarative/util/qdeclarativepropertymap.h b/src/declarative/util/qdeclarativepropertymap.h
index 513089f..e0b7ce3 100644
--- a/src/declarative/util/qdeclarativepropertymap.h
+++ b/src/declarative/util/qdeclarativepropertymap.h
@@ -76,7 +76,7 @@ public:
     const QVariant operator[](const QString &key) const;
 
 Q_SIGNALS:
-    void valueChanged(const QString &key);
+    void valueChanged(const QString &key, const QVariant &value);
 
 private:
     Q_DECLARE_PRIVATE(QDeclarativePropertyMap)
diff --git a/src/declarative/util/qdeclarativeview.cpp b/src/declarative/util/qdeclarativeview.cpp
index 8e65151..138fe3c 100644
--- a/src/declarative/util/qdeclarativeview.cpp
+++ b/src/declarative/util/qdeclarativeview.cpp
@@ -289,7 +289,6 @@ QDeclarativeView::~QDeclarativeView()
 void QDeclarativeView::setSource(const QUrl& url)
 {
     d->source = url;
-    d->engine.setBaseUrl(url);
     d->execute();
 }