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

7 files changed, 443 insertions, 47 deletions

diff --git a/src/declarative/qml/qdeclarativevmemetaobject.cpp b/src/declarative/qml/qdeclarativevmemetaobject.cpp
index f9c99ee..7a08a2c 100644
--- a/src/declarative/qml/qdeclarativevmemetaobject.cpp
+++ b/src/declarative/qml/qdeclarativevmemetaobject.cpp
@@ -47,19 +47,316 @@
 #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 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 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::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 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 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 +371,17 @@ QDeclarativeVMEMetaObject::QDeclarativeVMEMetaObject(QObject *obj,
     propOffset = QAbstractDynamicMetaObject::propertyOffset();
     methodOffset = QAbstractDynamicMetaObject::methodOffset();
 
-    data = new QVariant[metaData->propertyCount];
+    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);
-        }
+            data[ii].setValue(listProperties.count() - 1);
+        } 
     }
 }
 
@@ -145,11 +439,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 +450,83 @@ 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> >()) {
                             *reinterpret_cast<QDeclarativeListProperty<QObject> *>(a[0]) = 
-                                data[id].value<QDeclarativeListProperty<QObject> >();
+                                QDeclarativeListProperty<QObject>(object, (void *)&listProperties.at(data[id].asInt()), 
+                                                                  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 +650,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 +720,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..4718fa7 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);
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..70ecf95 100644
--- a/src/declarative/util/qdeclarativeopenmetaobject.cpp
+++ b/src/declarative/util/qdeclarativeopenmetaobject.cpp
@@ -225,6 +225,7 @@ int QDeclarativeOpenMetaObject::metaCall(QMetaObject::Call c, int id, void **a)
             if (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..d3e1d7c 100644
--- a/src/declarative/util/qdeclarativepropertymap.cpp
+++ b/src/declarative/util/qdeclarativepropertymap.cpp
@@ -55,7 +55,7 @@ public:
     QDeclarativePropertyMapMetaObject(QDeclarativePropertyMap *obj, QDeclarativePropertyMapPrivate *objPriv);
 
 protected:
-    virtual void propertyWrite(int index);
+    virtual void propertyWritten(int index);
 
 private:
     QDeclarativePropertyMap *map;
@@ -68,13 +68,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 +83,14 @@ 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));
 }
 
 /*!
     \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.
@@ -268,9 +268,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)