Migrate gui dependencies from QtQml to QtQuick.

Ensure that users of declarative that have no need for functionality
provided by the Qt Gui module do not have to link against it.

Any use of QtGui functionality is delegated to providers that can
be installed by another library; QtQuick adds default providers
for this functionality when linked against QtQml.

Task-number: QTBUG-24559
Change-Id: I5e6a58a4198732dc2f8f52f71abfa1152b871aa7
Reviewed-by: Martin Jones <martin.jones@nokia.com>

39 files changed, 2334 insertions, 1242 deletions

diff --git a/src/qml/qml.pro b/src/qml/qml.pro
index 0bbfc9ff74..acafb9f6a3 100644
--- a/src/qml/qml.pro
+++ b/src/qml/qml.pro
@@ -6,7 +6,7 @@ QPRO_PWD   = $$PWD
 CONFIG += module
 MODULE_PRI += ../../modules/qt_qml.pri
 
-QT = core-private gui gui-private network v8-private
+QT = core-private network v8-private
 
 DEFINES   += QT_BUILD_QML_LIB QT_NO_URL_CAST_FROM_STRING QT_NO_INTEGER_EVENT_COORDINATES
 
diff --git a/src/qml/qml/qml.pri b/src/qml/qml/qml.pri
index 5d26197b1c..fadfc9d833 100644
--- a/src/qml/qml/qml.pri
+++ b/src/qml/qml/qml.pri
@@ -1,5 +1,4 @@
 SOURCES += \
-    $$PWD/qquickapplication.cpp \
     $$PWD/qqmlinstruction.cpp \
     $$PWD/qquicklistmodel.cpp \
     $$PWD/qquicklistmodelworkeragent.cpp \
@@ -51,6 +50,7 @@ SOURCES += \
     $$PWD/qqmljavascriptexpression.cpp \
     $$PWD/qqmlabstractbinding.cpp \
     $$PWD/qqmlvaluetypeproxybinding.cpp \
+    $$PWD/qqmlglobal.cpp \
 
 HEADERS += \
     $$PWD/qqmlglobal_p.h \
@@ -61,7 +61,6 @@ HEADERS += \
     $$PWD/qqmlopenmetaobject_p.h \
     $$PWD/qqmlvmemetaobject_p.h \
     $$PWD/qqml.h \
-    $$PWD/qquickapplication_p.h \
     $$PWD/qqmlbinding_p.h \
     $$PWD/qqmlproperty.h \
     $$PWD/qqmlcomponent.h \
diff --git a/src/qml/qml/qqmlcompiler.cpp b/src/qml/qml/qqmlcompiler.cpp
index 51343b64d5..c3b8152ce1 100644
--- a/src/qml/qml/qqmlcompiler.cpp
+++ b/src/qml/qml/qqmlcompiler.cpp
@@ -63,7 +63,6 @@
 #include "qqmlbinding_p.h"
 #include <private/qv4compiler_p.h>
 
-#include <QColor>
 #include <QDebug>
 #include <QPointF>
 #include <QSizeF>
@@ -350,16 +349,16 @@ bool QQmlCompiler::testLiteralAssignment(QQmlScript::Property *prop,
             break;
         case QVariant::Vector3D:
             {
-            bool ok;
-            QQmlStringConverters::vector3DFromString(value.asString(), &ok);
-            if (!ok) COMPILE_EXCEPTION(v, tr("Invalid property assignment: 3D vector expected"));
+            QQmlInstruction::instr_storeVector3D::QVector3D v3;
+            if (!QQmlStringConverters::createFromString(QMetaType::QVector3D, value.asString(), &v3, sizeof(v3)))
+                COMPILE_EXCEPTION(v, tr("Invalid property assignment: 3D vector expected"));
             }
             break;
         case QVariant::Vector4D:
             {
-            bool ok;
-            QQmlStringConverters::vector4DFromString(value.asString(), &ok);
-            if (!ok) COMPILE_EXCEPTION(v, tr("Invalid property assignment: 4D vector expected"));
+            QQmlInstruction::instr_storeVector4D::QVector4D v4;
+            if (!QQmlStringConverters::createFromString(QMetaType::QVector4D, value.asString(), &v4, sizeof(v4)))
+                COMPILE_EXCEPTION(v, tr("Invalid property assignment: 4D vector expected"));
             }
             break;
         default:
@@ -564,9 +563,8 @@ void QQmlCompiler::genLiteralAssignment(QQmlScript::Property *prop,
         case QVariant::Color:
             {
             Instruction::StoreColor instr;
-            QColor c = QQmlStringConverters::colorFromString(v->value.asString());
             instr.propertyIndex = prop->index;
-            instr.value = c.rgba();
+            instr.value = QQmlStringConverters::rgbaFromString(v->value.asString());
             output->addInstruction(instr);
             }
             break;
@@ -685,25 +683,16 @@ void QQmlCompiler::genLiteralAssignment(QQmlScript::Property *prop,
         case QVariant::Vector3D:
             {
             Instruction::StoreVector3D instr;
-            bool ok;
-            QVector3D vector = QQmlStringConverters::vector3DFromString(v->value.asString(), &ok);
             instr.propertyIndex = prop->index;
-            instr.vector.xp = vector.x();
-            instr.vector.yp = vector.y();
-            instr.vector.zp = vector.z();
+            QQmlStringConverters::createFromString(QMetaType::QVector3D, v->value.asString(), &instr.vector, sizeof(instr.vector));
             output->addInstruction(instr);
             }
             break;
     case QVariant::Vector4D:
             {
             Instruction::StoreVector4D instr;
-            bool ok;
-            QVector4D vector = QQmlStringConverters::vector4DFromString(v->value.asString(), &ok);
             instr.propertyIndex = prop->index;
-            instr.vector.xp = vector.x();
-            instr.vector.yp = vector.y();
-            instr.vector.zp = vector.z();
-            instr.vector.wp = vector.w();
+            QQmlStringConverters::createFromString(QMetaType::QVector4D, v->value.asString(), &instr.vector, sizeof(instr.vector));
             output->addInstruction(instr);
             }
             break;
diff --git a/src/qml/qml/qqmlengine.cpp b/src/qml/qml/qqmlengine.cpp
index 16cd1ecde6..b1fcadd9b2 100644
--- a/src/qml/qml/qqmlengine.cpp
+++ b/src/qml/qml/qqmlengine.cpp
@@ -65,7 +65,6 @@
 #include "qqmltypenamecache_p.h"
 #include "qqmlnotifier_p.h"
 #include <private/qqmlprofilerservice_p.h>
-#include <private/qquickapplication_p.h>
 #include <private/qv8debugservice_p.h>
 #include <private/qdebugmessageservice_p.h>
 #include "qqmlincubator.h"
@@ -174,7 +173,6 @@ void QQmlEnginePrivate::registerBaseTypes(const char *uri, int versionMajor, int
 void QQmlEnginePrivate::defineModule()
 {
     registerBaseTypes("QtQuick", 2, 0);
-    qmlRegisterUncreatableType<QQuickApplication>("QtQuick",2,0,"Application", QQuickApplication::tr("Application is an abstract class"));
     qmlRegisterUncreatableType<QQmlLocale>("QtQuick",2,0,"Locale",QQmlEngine::tr("Locale cannot be instantiated.  Use Qt.locale()"));
 }
 
diff --git a/src/qml/qml/qqmlglobal.cpp b/src/qml/qml/qqmlglobal.cpp
new file mode 100644
index 0000000000..1f8de4fae8
--- /dev/null
+++ b/src/qml/qml/qqmlglobal.cpp
@@ -0,0 +1,336 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qqmlglobal_p.h>
+
+#include <QtCore/qvariant.h>
+#include <QtCore/qstringlist.h>
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+QQmlValueTypeProvider::QQmlValueTypeProvider()
+    : next(0)
+{
+}
+
+QQmlValueType *QQmlValueTypeProvider::createValueType(int type)
+{
+    QQmlValueType *value = 0;
+
+    QQmlValueTypeProvider *p = this;
+    do {
+        if (p->create(type, value))
+            return value;
+    } while ((p = p->next));
+
+    return 0;
+}
+
+bool QQmlValueTypeProvider::initValueType(int type, void *data, size_t n)
+{
+    Q_ASSERT(data);
+
+    QQmlValueTypeProvider *p = this;
+    do {
+        if (p->init(type, data, n))
+            return true;
+    } while ((p = p->next));
+
+    return false;
+}
+
+bool QQmlValueTypeProvider::destroyValueType(int type, void *data, size_t n)
+{
+    Q_ASSERT(data);
+
+    QQmlValueTypeProvider *p = this;
+    do {
+        if (p->destroy(type, data, n))
+            return true;
+    } while ((p = p->next));
+
+    return false;
+}
+
+bool QQmlValueTypeProvider::copyValueType(int type, const void *src, void *dst, size_t n)
+{
+    Q_ASSERT(src);
+    Q_ASSERT(dst);
+
+    QQmlValueTypeProvider *p = this;
+    do {
+        if (p->copy(type, src, dst, n))
+            return true;
+    } while ((p = p->next));
+
+    return false;
+}
+
+QVariant QQmlValueTypeProvider::createValueType(int type, int argc, const void *argv[])
+{
+    QVariant v;
+
+    QQmlValueTypeProvider *p = this;
+    do {
+        if (p->create(type, argc, argv, &v))
+            return v;
+    } while ((p = p->next));
+
+    return QVariant();
+}
+
+bool QQmlValueTypeProvider::createValueFromString(int type, const QString &s, void *data, size_t n)
+{
+    Q_ASSERT(data);
+
+    QQmlValueTypeProvider *p = this;
+    do {
+        if (p->createFromString(type, s, data, n))
+            return true;
+    } while ((p = p->next));
+
+    return false;
+}
+
+bool QQmlValueTypeProvider::createStringFromValue(int type, const void *data, QString *s)
+{
+    Q_ASSERT(data);
+    Q_ASSERT(s);
+
+    QQmlValueTypeProvider *p = this;
+    do {
+        if (p->createStringFrom(type, data, s))
+            return true;
+    } while ((p = p->next));
+
+    return false;
+}
+
+QVariant QQmlValueTypeProvider::createVariantFromString(const QString &s)
+{
+    QVariant v;
+
+    QQmlValueTypeProvider *p = this;
+    do {
+        if (p->variantFromString(s, &v))
+            return v;
+    } while ((p = p->next));
+
+    // Return a variant containing the string itself
+    return QVariant(s);
+}
+
+QVariant QQmlValueTypeProvider::createVariantFromString(int type, const QString &s, bool *ok)
+{
+    QVariant v;
+
+    QQmlValueTypeProvider *p = this;
+    do {
+        if (p->variantFromString(type, s, &v)) {
+            if (ok) *ok = true;
+            return v;
+        }
+    } while ((p = p->next));
+
+    if (ok) *ok = false;
+    return QVariant();
+}
+
+bool QQmlValueTypeProvider::storeValueType(int type, const void *src, void *dst, size_t n)
+{
+    Q_ASSERT(src);
+    Q_ASSERT(dst);
+
+    QQmlValueTypeProvider *p = this;
+    do {
+        if (p->store(type, src, dst, n))
+            return true;
+    } while ((p = p->next));
+
+    return false;
+}
+
+bool QQmlValueTypeProvider::readValueType(int srcType, const void *src, int dstType, void *dst)
+{
+    Q_ASSERT(src);
+    Q_ASSERT(dst);
+
+    QQmlValueTypeProvider *p = this;
+    do {
+        if (p->read(srcType, src, dstType, dst))
+            return true;
+    } while ((p = p->next));
+
+    return false;
+}
+
+bool QQmlValueTypeProvider::writeValueType(int type, const void *src, void *dst, size_t n)
+{
+    Q_ASSERT(src);
+    Q_ASSERT(dst);
+
+    QQmlValueTypeProvider *p = this;
+    do {
+        if (p->write(type, src, dst, n))
+            return true;
+    } while ((p = p->next));
+
+    return false;
+}
+
+bool QQmlValueTypeProvider::create(int, QQmlValueType *&) { return false; }
+bool QQmlValueTypeProvider::init(int, void *, size_t) { return false; }
+bool QQmlValueTypeProvider::destroy(int, void *, size_t) { return false; }
+bool QQmlValueTypeProvider::copy(int, const void *, void *, size_t) { return false; }
+bool QQmlValueTypeProvider::create(int, int, const void *[], QVariant *) { return false; }
+bool QQmlValueTypeProvider::createFromString(int, const QString &, void *, size_t) { return false; }
+bool QQmlValueTypeProvider::createStringFrom(int, const void *, QString *) { return false; }
+bool QQmlValueTypeProvider::variantFromString(const QString &, QVariant *) { return false; }
+bool QQmlValueTypeProvider::variantFromString(int, const QString &, QVariant *) { return false; }
+bool QQmlValueTypeProvider::store(int, const void *, void *, size_t) { return false; }
+bool QQmlValueTypeProvider::read(int, const void *, int, void *) { return false; }
+bool QQmlValueTypeProvider::write(int, const void *, void *, size_t) { return false; }
+
+static QQmlValueTypeProvider *valueTypeProvider = 0;
+
+static QQmlValueTypeProvider **getValueTypeProvider(void)
+{
+    if (valueTypeProvider == 0) {
+        static QQmlValueTypeProvider nullValueTypeProvider;
+        valueTypeProvider = &nullValueTypeProvider;
+    }
+
+    return &valueTypeProvider;
+}
+
+Q_QML_PRIVATE_EXPORT void QQml_addValueTypeProvider(QQmlValueTypeProvider *newProvider)
+{
+    static QQmlValueTypeProvider **providerPtr = getValueTypeProvider();
+    newProvider->next = *providerPtr;
+    *providerPtr = newProvider;
+}
+
+Q_AUTOTEST_EXPORT QQmlValueTypeProvider *QQml_valueTypeProvider(void)
+{
+    if (valueTypeProvider == 0) {
+        qWarning() << "Warning: QQml_valueTypeProvider: no value type provider has been set!";
+    }
+
+    static QQmlValueTypeProvider **providerPtr = getValueTypeProvider();
+    return *providerPtr;
+}
+
+
+QVariant QQmlColorProvider::colorFromString(const QString &, bool *ok) { if (ok) *ok = false; return QVariant(); }
+unsigned QQmlColorProvider::rgbaFromString(const QString &, bool *ok) { if (ok) *ok = false; return 0; }
+QVariant QQmlColorProvider::fromRgbF(double, double, double, double) { return QVariant(); }
+QVariant QQmlColorProvider::fromHslF(double, double, double, double) { return QVariant(); }
+QVariant QQmlColorProvider::lighter(const QVariant &, qreal) { return QVariant(); }
+QVariant QQmlColorProvider::darker(const QVariant &, qreal) { return QVariant(); }
+QVariant QQmlColorProvider::tint(const QVariant &, const QVariant &) { return QVariant(); }
+
+static QQmlColorProvider *colorProvider = 0;
+
+Q_QML_PRIVATE_EXPORT QQmlColorProvider *QQml_setColorProvider(QQmlColorProvider *newProvider)
+{
+    QQmlColorProvider *old = colorProvider;
+    colorProvider = newProvider;
+    return old;
+}
+
+static QQmlColorProvider **getColorProvider(void)
+{
+    if (colorProvider == 0) {
+        qWarning() << "Warning: QQml_colorProvider: no color provider has been set!";
+        static QQmlColorProvider nullColorProvider;
+        colorProvider = &nullColorProvider;
+    }
+
+    return &colorProvider;
+}
+
+Q_AUTOTEST_EXPORT QQmlColorProvider *QQml_colorProvider(void)
+{
+    static QQmlColorProvider **providerPtr = getColorProvider();
+    return *providerPtr;
+}
+
+
+QObject *QQmlGuiProvider::application(QObject *) { return 0; }
+QStringList QQmlGuiProvider::fontFamilies() { return QStringList(); }
+bool QQmlGuiProvider::openUrlExternally(QUrl &) { return false; }
+
+QObject *QQmlGuiProvider::inputMethod()
+{
+    // We don't have any input method code by default
+    QObject *o = new QObject();
+    o->setObjectName(QString::fromAscii("No inputMethod available"));
+    return o;
+}
+
+static QQmlGuiProvider *guiProvider = 0;
+
+Q_QML_PRIVATE_EXPORT QQmlGuiProvider *QQml_setGuiProvider(QQmlGuiProvider *newProvider)
+{
+    QQmlGuiProvider *old = guiProvider;
+    guiProvider = newProvider;
+    return old;
+}
+
+static QQmlGuiProvider **getGuiProvider(void)
+{
+    if (guiProvider == 0) {
+        qWarning() << "Warning: QQml_guiProvider: no GUI provider has been set!";
+        static QQmlGuiProvider nullGuiProvider;
+        guiProvider = &nullGuiProvider;
+    }
+
+    return &guiProvider;
+}
+
+Q_AUTOTEST_EXPORT QQmlGuiProvider *QQml_guiProvider(void)
+{
+    static QQmlGuiProvider **providerPtr = getGuiProvider();
+    return *providerPtr;
+}
+
+QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlglobal_p.h b/src/qml/qml/qqmlglobal_p.h
index c41b823e60..2356b2d122 100644
--- a/src/qml/qml/qqmlglobal_p.h
+++ b/src/qml/qml/qqmlglobal_p.h
@@ -42,7 +42,7 @@
 #ifndef QQMLGLOBAL_H
 #define QQMLGLOBAL_H
 
-#include <QtCore/qglobal.h>
+#include <private/qtqmlglobal_p.h>
 #include <QtCore/QObject>
 
 QT_BEGIN_HEADER
@@ -122,6 +122,87 @@ inline void QQml_setParent_noEvent(QObject *object, QObject *parent)
     static_cast<QQmlGraphics_DerivedObject *>(object)->setParent_noEvent(parent);
 }
 
+
+class QQmlValueType;
+
+class Q_QML_PRIVATE_EXPORT QQmlValueTypeProvider
+{
+public:
+    QQmlValueTypeProvider();
+
+    QQmlValueType *createValueType(int);
+
+    bool initValueType(int, void *, size_t);
+    bool destroyValueType(int, void *, size_t);
+    bool copyValueType(int, const void *, void *, size_t);
+
+    QVariant createValueType(int, int, const void *[]);
+    bool createValueFromString(int, const QString &, void *, size_t);
+    bool createStringFromValue(int, const void *, QString *);
+
+    QVariant createVariantFromString(const QString &);
+    QVariant createVariantFromString(int, const QString &, bool *);
+
+    bool storeValueType(int, const void *, void *, size_t);
+    bool readValueType(int, const void *, int, void *);
+    bool writeValueType(int, const void *, void *, size_t);
+
+private:
+    virtual bool create(int, QQmlValueType *&);
+
+    virtual bool init(int, void *, size_t);
+    virtual bool destroy(int, void *, size_t);
+    virtual bool copy(int, const void *, void *, size_t);
+
+    virtual bool create(int, int, const void *[], QVariant *);
+    virtual bool createFromString(int, const QString &, void *, size_t);
+    virtual bool createStringFrom(int, const void *, QString *);
+
+    virtual bool variantFromString(const QString &, QVariant *);
+    virtual bool variantFromString(int, const QString &, QVariant *);
+
+    virtual bool store(int, const void *, void *, size_t);
+    virtual bool read(int, const void *, int, void *);
+    virtual bool write(int, const void *, void *, size_t);
+
+    friend Q_QML_PRIVATE_EXPORT void QQml_addValueTypeProvider(QQmlValueTypeProvider *);
+
+    QQmlValueTypeProvider *next;
+};
+
+Q_QML_PRIVATE_EXPORT void QQml_addValueTypeProvider(QQmlValueTypeProvider *);
+Q_AUTOTEST_EXPORT QQmlValueTypeProvider *QQml_valueTypeProvider();
+
+
+class Q_QML_PRIVATE_EXPORT QQmlColorProvider
+{
+public:
+    virtual QVariant colorFromString(const QString &, bool *);
+    virtual unsigned rgbaFromString(const QString &, bool *);
+
+    virtual QVariant fromRgbF(double, double, double, double);
+    virtual QVariant fromHslF(double, double, double, double);
+    virtual QVariant lighter(const QVariant &, qreal);
+    virtual QVariant darker(const QVariant &, qreal);
+    virtual QVariant tint(const QVariant &, const QVariant &);
+};
+
+Q_QML_PRIVATE_EXPORT QQmlColorProvider *QQml_setColorProvider(QQmlColorProvider *);
+Q_AUTOTEST_EXPORT QQmlColorProvider *QQml_colorProvider();
+
+
+class Q_QML_PRIVATE_EXPORT QQmlGuiProvider
+{
+public:
+    virtual QObject *application(QObject *parent);
+    virtual QObject *inputMethod();
+    virtual QStringList fontFamilies();
+    virtual bool openUrlExternally(QUrl &);
+};
+
+Q_QML_PRIVATE_EXPORT QQmlGuiProvider *QQml_setGuiProvider(QQmlGuiProvider *);
+Q_AUTOTEST_EXPORT QQmlGuiProvider *QQml_guiProvider();
+
 QT_END_NAMESPACE
 
 QT_END_HEADER
diff --git a/src/qml/qml/qqmlstringconverters.cpp b/src/qml/qml/qqmlstringconverters.cpp
index 2c7f6c9f6e..473097fab0 100644
--- a/src/qml/qml/qqmlstringconverters.cpp
+++ b/src/qml/qml/qqmlstringconverters.cpp
@@ -40,10 +40,9 @@
 ****************************************************************************/
 
 #include "qqmlstringconverters_p.h"
+#include <private/qqmlglobal_p.h>
+#include <private/qqmlinstruction_p.h>
 
-#include <QtGui/qcolor.h>
-#include <QtGui/qvector3d.h>
-#include <QtGui/qvector4d.h>
 #include <QtCore/qpoint.h>
 #include <QtCore/qrect.h>
 #include <QtCore/qsize.h>
@@ -52,52 +51,20 @@
 
 QT_BEGIN_NAMESPACE
 
-static uchar fromHex(const uchar c, const uchar c2)
-{
-    uchar rv = 0;
-    if (c >= '0' && c <= '9')
-        rv += (c - '0') * 16;
-    else if (c >= 'A' && c <= 'F')
-        rv += (c - 'A' + 10) * 16;
-    else if (c >= 'a' && c <= 'f')
-        rv += (c - 'a' + 10) * 16;
-
-    if (c2 >= '0' && c2 <= '9')
-        rv += (c2 - '0');
-    else if (c2 >= 'A' && c2 <= 'F')
-        rv += (c2 - 'A' + 10);
-    else if (c2 >= 'a' && c2 <= 'f')
-        rv += (c2 - 'a' + 10);
-
-    return rv;
-}
-
-static uchar fromHex(const QString &s, int idx)
-{
-    uchar c = s.at(idx).toAscii();
-    uchar c2 = s.at(idx + 1).toAscii();
-    return fromHex(c, c2);
-}
-
 QVariant QQmlStringConverters::variantFromString(const QString &s)
 {
     if (s.isEmpty())
         return QVariant(s);
+
     bool ok = false;
     QRectF r = rectFFromString(s, &ok);
     if (ok) return QVariant(r);
-    QColor c = colorFromString(s, &ok);
-    if (ok) return QVariant(c);
     QPointF p = pointFFromString(s, &ok);
     if (ok) return QVariant(p);
     QSizeF sz = sizeFFromString(s, &ok);
     if (ok) return QVariant(sz);
-    QVector3D v = vector3DFromString(s, &ok);
-    if (ok) return QVariant::fromValue(v);
-    QVector4D v4 = vector4DFromString(s, &ok);
-    if (ok) return QVariant::fromValue(v4);
 
-    return QVariant(s);
+    return QQml_valueTypeProvider()->createVariantFromString(s);
 }
 
 QVariant QQmlStringConverters::variantFromString(const QString &s, int preferredType, bool *ok)
@@ -107,8 +74,6 @@ QVariant QQmlStringConverters::variantFromString(const QString &s, int preferred
         return QVariant(int(qRound(s.toDouble(ok))));
     case QMetaType::UInt:
         return QVariant(uint(qRound(s.toDouble(ok))));
-    case QMetaType::QColor:
-        return QVariant::fromValue(colorFromString(s, ok));
 #ifndef QT_NO_DATESTRING
     case QMetaType::QDate:
         return QVariant::fromValue(dateFromString(s, ok));
@@ -129,30 +94,19 @@ QVariant QQmlStringConverters::variantFromString(const QString &s, int preferred
         return QVariant::fromValue(rectFFromString(s, ok));
     case QMetaType::QRect:
         return QVariant::fromValue(rectFFromString(s, ok).toRect());
-    case QMetaType::QVector3D:
-        return QVariant::fromValue(vector3DFromString(s, ok));
-    case QMetaType::QVector4D:
-        return QVariant::fromValue(vector4DFromString(s, ok));
     default:
-        if (ok) *ok = false;
-        return QVariant();
+        return QQml_valueTypeProvider()->createVariantFromString(preferredType, s, ok);
     }
 }
 
-QColor QQmlStringConverters::colorFromString(const QString &s, bool *ok)
+QVariant QQmlStringConverters::colorFromString(const QString &s, bool *ok)
 {
-    if (s.length() == 9 && s.startsWith(QLatin1Char('#'))) {
-        uchar a = fromHex(s, 1);
-        uchar r = fromHex(s, 3);
-        uchar g = fromHex(s, 5);
-        uchar b = fromHex(s, 7);
-        if (ok) *ok = true;
-        return QColor(r, g, b, a);
-    } else {
-        QColor rv(s);
-        if (ok) *ok = rv.isValid();
-        return rv;
-    }
+    return QQml_colorProvider()->colorFromString(s, ok);
+}
+
+unsigned QQmlStringConverters::rgbaFromString(const QString &s, bool *ok)
+{
+    return QQml_colorProvider()->rgbaFromString(s, ok);
 }
 
 #ifndef QT_NO_DATESTRING
@@ -254,58 +208,95 @@ QRectF QQmlStringConverters::rectFFromString(const QString &s, bool *ok)
     return QRectF(x, y, width, height);
 }
 
-//expects input of "x,y,z"
-QVector3D QQmlStringConverters::vector3DFromString(const QString &s, bool *ok)
+bool QQmlStringConverters::createFromString(int type, const QString &s, void *data, size_t n)
 {
-    if (s.count(QLatin1Char(',')) != 2) {
-        if (ok)
-            *ok = false;
-        return QVector3D();
-    }
-
-    bool xGood, yGood, zGood;
-    int index = s.indexOf(QLatin1Char(','));
-    int index2 = s.indexOf(QLatin1Char(','), index+1);
-    qreal xCoord = s.left(index).toDouble(&xGood);
-    qreal yCoord = s.mid(index+1, index2-index-1).toDouble(&yGood);
-    qreal zCoord = s.mid(index2+1).toDouble(&zGood);
-    if (!xGood || !yGood || !zGood) {
-        if (ok)
-            *ok = false;
-        return QVector3D();
-    }
-
-    if (ok)
-        *ok = true;
-    return QVector3D(xCoord, yCoord, zCoord);
-}
+    Q_ASSERT(data);
 
-//expects input of "x,y,z,w"
-QVector4D QQmlStringConverters::vector4DFromString(const QString &s, bool *ok)
-{
-    if (s.count(QLatin1Char(',')) != 3) {
-        if (ok)
-            *ok = false;
-        return QVector4D();
-    }
+    bool ok = false;
 
-    bool xGood, yGood, zGood, wGood;
-    int index = s.indexOf(QLatin1Char(','));
-    int index2 = s.indexOf(QLatin1Char(','), index+1);
-    int index3 = s.indexOf(QLatin1Char(','), index2+1);
-    qreal xCoord = s.left(index).toDouble(&xGood);
-    qreal yCoord = s.mid(index+1, index2-index-1).toDouble(&yGood);
-    qreal zCoord = s.mid(index2+1, index3-index2-1).toDouble(&zGood);
-    qreal wCoord = s.mid(index3+1).toDouble(&wGood);
-    if (!xGood || !yGood || !zGood || !wGood) {
-        if (ok)
-            *ok = false;
-        return QVector4D();
+    switch (type) {
+    case QMetaType::Int:
+        {
+        Q_ASSERT(n >= sizeof(int));
+        int *p = reinterpret_cast<int *>(data);
+        *p = int(qRound(s.toDouble(&ok)));
+        return ok;
+        }
+    case QMetaType::UInt:
+        {
+        Q_ASSERT(n >= sizeof(uint));
+        uint *p = reinterpret_cast<uint *>(data);
+        *p = uint(qRound(s.toDouble(&ok)));
+        return ok;
+        }
+#ifndef QT_NO_DATESTRING
+    case QMetaType::QDate:
+        {
+        Q_ASSERT(n >= sizeof(QDate));
+        QDate *p = reinterpret_cast<QDate *>(data);
+        *p = dateFromString(s, &ok);
+        return ok;
+        }
+    case QMetaType::QTime:
+        {
+        Q_ASSERT(n >= sizeof(QTime));
+        QTime *p = reinterpret_cast<QTime *>(data);
+        *p = timeFromString(s, &ok);
+        return ok;
+        }
+    case QMetaType::QDateTime:
+        {
+        Q_ASSERT(n >= sizeof(QDateTime));
+        QDateTime *p = reinterpret_cast<QDateTime *>(data);
+        *p = dateTimeFromString(s, &ok);
+        return ok;
+        }
+#endif // QT_NO_DATESTRING
+    case QMetaType::QPointF:
+        {
+        Q_ASSERT(n >= sizeof(QPointF));
+        QPointF *p = reinterpret_cast<QPointF *>(data);
+        *p = pointFFromString(s, &ok);
+        return ok;
+        }
+    case QMetaType::QPoint:
+        {
+        Q_ASSERT(n >= sizeof(QPoint));
+        QPoint *p = reinterpret_cast<QPoint *>(data);
+        *p = pointFFromString(s, &ok).toPoint();
+        return ok;
+        }
+    case QMetaType::QSizeF:
+        {
+        Q_ASSERT(n >= sizeof(QSizeF));
+        QSizeF *p = reinterpret_cast<QSizeF *>(data);
+        *p = sizeFFromString(s, &ok);
+        return ok;
+        }
+    case QMetaType::QSize:
+        {
+        Q_ASSERT(n >= sizeof(QSize));
+        QSize *p = reinterpret_cast<QSize *>(data);
+        *p = sizeFFromString(s, &ok).toSize();
+        return ok;
+        }
+    case QMetaType::QRectF:
+        {
+        Q_ASSERT(n >= sizeof(QRectF));
+        QRectF *p = reinterpret_cast<QRectF *>(data);
+        *p = rectFFromString(s, &ok);
+        return ok;
+        }
+    case QMetaType::QRect:
+        {
+        Q_ASSERT(n >= sizeof(QRect));
+        QRect *p = reinterpret_cast<QRect *>(data);
+        *p = rectFFromString(s, &ok).toRect();
+        return ok;
+        }
+    default:
+        return QQml_valueTypeProvider()->createValueFromString(type, s, data, n);
     }
-
-    if (ok)
-        *ok = true;
-    return QVector4D(xCoord, yCoord, zCoord, wCoord);
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlstringconverters_p.h b/src/qml/qml/qqmlstringconverters_p.h
index 8f6fb2485d..3e637db83b 100644
--- a/src/qml/qml/qqmlstringconverters_p.h
+++ b/src/qml/qml/qqmlstringconverters_p.h
@@ -60,32 +60,31 @@
 
 QT_BEGIN_NAMESPACE
 
-class QColor;
 class QPointF;
 class QSizeF;
 class QRectF;
 class QString;
 class QByteArray;
-class QVector3D;
-class QVector4D;
 
 // XXX - Bauhaus currently uses these methods which is why they're exported
 namespace QQmlStringConverters
 {
-    QVariant Q_QML_PRIVATE_EXPORT variantFromString(const QString &);
-    QVariant Q_QML_PRIVATE_EXPORT variantFromString(const QString &, int preferredType, bool *ok = 0);
+    Q_QML_PRIVATE_EXPORT QVariant variantFromString(const QString &);
+    Q_QML_PRIVATE_EXPORT QVariant variantFromString(const QString &, int preferredType, bool *ok = 0);
+
+    Q_QML_PRIVATE_EXPORT QVariant colorFromString(const QString &, bool *ok = 0);
+    Q_QML_PRIVATE_EXPORT unsigned rgbaFromString(const QString &, bool *ok = 0);
 
-    QColor Q_QML_PRIVATE_EXPORT colorFromString(const QString &, bool *ok = 0);
 #ifndef QT_NO_DATESTRING
-    QDate Q_QML_PRIVATE_EXPORT dateFromString(const QString &, bool *ok = 0); 
-    QTime Q_QML_PRIVATE_EXPORT timeFromString(const QString &, bool *ok = 0);
-    QDateTime Q_QML_PRIVATE_EXPORT dateTimeFromString(const QString &, bool *ok = 0);
+    Q_QML_PRIVATE_EXPORT QDate dateFromString(const QString &, bool *ok = 0);
+    Q_QML_PRIVATE_EXPORT QTime timeFromString(const QString &, bool *ok = 0);
+    Q_QML_PRIVATE_EXPORT QDateTime dateTimeFromString(const QString &, bool *ok = 0);
 #endif
-    QPointF Q_QML_PRIVATE_EXPORT pointFFromString(const QString &, bool *ok = 0);
-    QSizeF Q_QML_PRIVATE_EXPORT sizeFFromString(const QString &, bool *ok = 0);
-    QRectF Q_QML_PRIVATE_EXPORT rectFFromString(const QString &, bool *ok = 0);
-    QVector3D Q_QML_PRIVATE_EXPORT vector3DFromString(const QString &, bool *ok = 0);
-    QVector4D Q_QML_PRIVATE_EXPORT vector4DFromString(const QString &, bool *ok = 0);
+    Q_QML_PRIVATE_EXPORT QPointF pointFFromString(const QString &, bool *ok = 0);
+    Q_QML_PRIVATE_EXPORT QSizeF sizeFFromString(const QString &, bool *ok = 0);
+    Q_QML_PRIVATE_EXPORT QRectF rectFFromString(const QString &, bool *ok = 0);
+
+    Q_QML_PRIVATE_EXPORT bool createFromString(int, const QString &, void *, size_t);
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlvaluetype.cpp b/src/qml/qml/qqmlvaluetype.cpp
index 4ade00f9b4..fdc44c22be 100644
--- a/src/qml/qml/qqmlvaluetype.cpp
+++ b/src/qml/qml/qqmlvaluetype.cpp
@@ -40,48 +40,17 @@
 ****************************************************************************/
 
 #include "qqmlvaluetype_p.h"
-
 #include "qqmlmetatype_p.h"
-#include <private/qfont_p.h>
 
+#include <private/qqmlglobal_p.h>
 #include <QtCore/qdebug.h>
 
 QT_BEGIN_NAMESPACE
 
-template<typename T>
-int qmlRegisterValueTypeEnums(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
-{
-    QByteArray name(T::staticMetaObject.className());
-
-    QByteArray pointerName(name + '*');
-
-    QQmlPrivate::RegisterType type = {
-        0,
-
-        qRegisterMetaType<T *>(pointerName.constData()), 0, 0, 0,
-
-        QString(),
-
-        uri, versionMajor, versionMinor, qmlName, &T::staticMetaObject,
-
-        0, 0,
-
-        0, 0, 0,
-
-        0, 0,
-
-        0,
-        0
-    };
-
-    return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
-}
-
 QQmlValueTypeFactory::QQmlValueTypeFactory()
 {
-    // ### Optimize
     for (unsigned int ii = 0; ii < (QVariant::UserType - 1); ++ii)
-        valueTypes[ii] = valueType(ii);
+        valueTypes[ii] = 0;
 }
 
 QQmlValueTypeFactory::~QQmlValueTypeFactory()
@@ -106,7 +75,6 @@ bool QQmlValueTypeFactory::isValueType(int idx)
 void QQmlValueTypeFactory::registerBaseTypes(const char *uri, int versionMajor, int versionMinor)
 {
     qmlRegisterValueTypeEnums<QQmlEasingValueType>(uri, versionMajor, versionMinor, "Easing");
-    qmlRegisterValueTypeEnums<QQmlFontValueType>(uri, versionMajor, versionMinor, "Font");
 }
 
 void QQmlValueTypeFactory::registerValueTypes()
@@ -137,31 +105,11 @@ QQmlValueType *QQmlValueTypeFactory::valueType(int t)
     case QVariant::RectF:
         rv = new QQmlRectFValueType;
         break;
-    case QVariant::Vector2D:
-        rv = new QQmlVector2DValueType;
-        break;
-    case QVariant::Vector3D:
-        rv = new QQmlVector3DValueType;
-        break;
-    case QVariant::Vector4D:
-        rv = new QQmlVector4DValueType;
-        break;
-    case QVariant::Quaternion:
-        rv = new QQmlQuaternionValueType;
-        break;
-    case QVariant::Matrix4x4:
-        rv = new QQmlMatrix4x4ValueType;
-        break;
     case QVariant::EasingCurve:
         rv = new QQmlEasingValueType;
         break;
-    case QVariant::Font:
-        rv = new QQmlFontValueType;
-        break;
-    case QVariant::Color:
-        rv = new QQmlColorValueType;
-        break;
     default:
+        rv = QQml_valueTypeProvider()->createValueType(t);
         break;
     }
 
@@ -174,445 +122,281 @@ QQmlValueType::QQmlValueType(QObject *parent)
 {
 }
 
-#define QML_VALUETYPE_READWRITE(name, cpptype, var) \
-    QQml ## name ## ValueType::QQml ## name ## ValueType(QObject *parent) \
-    : QQmlValueType(parent) \
-    { \
-    } \
-    void QQml ## name ## ValueType::read(QObject *obj, int idx) \
-    { \
-        void *a[] = { &var, 0 }; \
-        QMetaObject::metacall(obj, QMetaObject::ReadProperty, idx, a); \
-        onLoad(); \
-    } \
-    void QQml ## name ## ValueType::write(QObject *obj, int idx, \
-                                                  QQmlPropertyPrivate::WriteFlags flags) \
-    { \
-        int status = -1; \
-        void *a[] = { &var, 0, &status, &flags }; \
-        QMetaObject::metacall(obj, QMetaObject::WriteProperty, idx, a); \
-    } \
-    bool QQml ## name ## ValueType::isEqual(const QVariant &value) const \
-    { \
-        return QVariant(var) == value; \
-    } \
-    QVariant QQml ## name ## ValueType::value() \
-    { \
-        return QVariant(var); \
-    } \
-    void QQml ## name ## ValueType::setValue(const QVariant &value) \
-    { \
-        var = qvariant_cast<cpptype>(value); \
-        onLoad(); \
-    }
 
-QML_VALUETYPE_READWRITE(PointF, QPointF, point);
-QML_VALUETYPE_READWRITE(Point, QPoint, point);
-QML_VALUETYPE_READWRITE(SizeF, QSizeF, size);
-QML_VALUETYPE_READWRITE(Size, QSize, size);
-QML_VALUETYPE_READWRITE(RectF, QRectF, rect);
-QML_VALUETYPE_READWRITE(Rect, QRect, rect);
-QML_VALUETYPE_READWRITE(Vector2D, QVector2D, vector);
-QML_VALUETYPE_READWRITE(Vector3D, QVector3D, vector);
-QML_VALUETYPE_READWRITE(Vector4D, QVector4D, vector);
-QML_VALUETYPE_READWRITE(Quaternion, QQuaternion, quaternion);
-QML_VALUETYPE_READWRITE(Matrix4x4, QMatrix4x4, matrix);
-QML_VALUETYPE_READWRITE(Easing, QEasingCurve, easing);
-QML_VALUETYPE_READWRITE(Font, QFont, font);
-QML_VALUETYPE_READWRITE(Color, QColor, color);
+QQmlPointFValueType::QQmlPointFValueType(QObject *parent)
+    : QQmlValueTypeBase<QPointF>(parent)
+{
+}
 
 QString QQmlPointFValueType::toString() const
 {
-    return QString(QLatin1String("QPointF(%1, %2)")).arg(point.x()).arg(point.y());
+    return QString(QLatin1String("QPointF(%1, %2)")).arg(v.x()).arg(v.y());
 }
 
 qreal QQmlPointFValueType::x() const
 {
-    return point.x();
+    return v.x();
 }
 
 qreal QQmlPointFValueType::y() const
 {
-    return point.y();
+    return v.y();
 }
 
 void QQmlPointFValueType::setX(qreal x)
 {
-    point.setX(x);
+    v.setX(x);
 }
 
 void QQmlPointFValueType::setY(qreal y)
 {
-    point.setY(y);
+    v.setY(y);
+}
+
+
+QQmlPointValueType::QQmlPointValueType(QObject *parent)
+    : QQmlValueTypeBase<QPoint>(parent)
+{
 }
 
 QString QQmlPointValueType::toString() const
 {
-    return QString(QLatin1String("QPoint(%1, %2)")).arg(point.x()).arg(point.y());
+    return QString(QLatin1String("QPoint(%1, %2)")).arg(v.x()).arg(v.y());
 }
 
 int QQmlPointValueType::x() const
 {
-    return point.x();
+    return v.x();
 }
 
 int QQmlPointValueType::y() const
 {
-    return point.y();
+    return v.y();
 }
 
 void QQmlPointValueType::setX(int x)
 {
-    point.setX(x);
+    v.setX(x);
 }
 
 void QQmlPointValueType::setY(int y)
 {
-    point.setY(y);
+    v.setY(y);
+}
+
+
+QQmlSizeFValueType::QQmlSizeFValueType(QObject *parent)
+    : QQmlValueTypeBase<QSizeF>(parent)
+{
 }
 
 QString QQmlSizeFValueType::toString() const
 {
-    return QString(QLatin1String("QSizeF(%1, %2)")).arg(size.width()).arg(size.height());
+    return QString(QLatin1String("QSizeF(%1, %2)")).arg(v.width()).arg(v.height());
 }
 
 qreal QQmlSizeFValueType::width() const
 {
-    return size.width();
+    return v.width();
 }
 
 qreal QQmlSizeFValueType::height() const
 {
-    return size.height();
+    return v.height();
 }
 
 void QQmlSizeFValueType::setWidth(qreal w)
 {
-    size.setWidth(w);
+    v.setWidth(w);
 }
 
 void QQmlSizeFValueType::setHeight(qreal h)
 {
-    size.setHeight(h);
+    v.setHeight(h);
+}
+
+
+QQmlSizeValueType::QQmlSizeValueType(QObject *parent)
+    : QQmlValueTypeBase<QSize>(parent)
+{
 }
 
 QString QQmlSizeValueType::toString() const
 {
-    return QString(QLatin1String("QSize(%1, %2)")).arg(size.width()).arg(size.height());
+    return QString(QLatin1String("QSize(%1, %2)")).arg(v.width()).arg(v.height());
 }
 
 int QQmlSizeValueType::width() const
 {
-    return size.width();
+    return v.width();
 }
 
 int QQmlSizeValueType::height() const
 {
-    return size.height();
+    return v.height();
 }
 
 void QQmlSizeValueType::setWidth(int w)
 {
-    size.setWidth(w);
+    v.setWidth(w);
 }
 
 void QQmlSizeValueType::setHeight(int h)
 {
-    size.setHeight(h);
+    v.setHeight(h);
+}
+
+
+QQmlRectFValueType::QQmlRectFValueType(QObject *parent)
+    : QQmlValueTypeBase<QRectF>(parent)
+{
 }
 
 QString QQmlRectFValueType::toString() const
 {
-    return QString(QLatin1String("QRectF(%1, %2, %3, %4)")).arg(rect.x()).arg(rect.y()).arg(rect.width()).arg(rect.height());
+    return QString(QLatin1String("QRectF(%1, %2, %3, %4)")).arg(v.x()).arg(v.y()).arg(v.width()).arg(v.height());
 }
 
 qreal QQmlRectFValueType::x() const
 {
-    return rect.x();
+    return v.x();
 }
 
 qreal QQmlRectFValueType::y() const
 {
-    return rect.y();
+    return v.y();
 }
 
 void QQmlRectFValueType::setX(qreal x)
 {
-    rect.moveLeft(x);
+    v.moveLeft(x);
 }
 
 void QQmlRectFValueType::setY(qreal y)
 {
-    rect.moveTop(y);
+    v.moveTop(y);
 }
 
 qreal QQmlRectFValueType::width() const
 {
-    return rect.width();
+    return v.width();
 }
 
 qreal QQmlRectFValueType::height() const
 {
-    return rect.height();
+    return v.height();
 }
 
 void QQmlRectFValueType::setWidth(qreal w)
 {
-    rect.setWidth(w);
+    v.setWidth(w);
 }
 
 void QQmlRectFValueType::setHeight(qreal h)
 {
-    rect.setHeight(h);
+    v.setHeight(h);
+}
+
+
+QQmlRectValueType::QQmlRectValueType(QObject *parent)
+    : QQmlValueTypeBase<QRect>(parent)
+{
 }
 
 QString QQmlRectValueType::toString() const
 {
-    return QString(QLatin1String("QRect(%1, %2, %3, %4)")).arg(rect.x()).arg(rect.y()).arg(rect.width()).arg(rect.height());
+    return QString(QLatin1String("QRect(%1, %2, %3, %4)")).arg(v.x()).arg(v.y()).arg(v.width()).arg(v.height());
 }
 
 int QQmlRectValueType::x() const
 {
-    return rect.x();
+    return v.x();
 }
 
 int QQmlRectValueType::y() const
 {
-    return rect.y();
+    return v.y();
 }
 
 void QQmlRectValueType::setX(int x)
 {
-    rect.moveLeft(x);
+    v.moveLeft(x);
 }
 
 void QQmlRectValueType::setY(int y)
 {
-    rect.moveTop(y);
+    v.moveTop(y);
 }
 
 int QQmlRectValueType::width() const
 {
-    return rect.width();
+    return v.width();
 }
 
 int QQmlRectValueType::height() const
 {
-    return rect.height();
+    return v.height();
 }
 
 void QQmlRectValueType::setWidth(int w)
 {
-    rect.setWidth(w);
+    v.setWidth(w);
 }
 
 void QQmlRectValueType::setHeight(int h)
 {
-    rect.setHeight(h);
+    v.setHeight(h);
 }
 
-QString QQmlVector2DValueType::toString() const
-{
-    return QString(QLatin1String("QVector2D(%1, %2)")).arg(vector.x()).arg(vector.y());
-}
 
-qreal QQmlVector2DValueType::x() const
+QQmlEasingValueType::QQmlEasingValueType(QObject *parent)
+    : QQmlValueTypeBase<QEasingCurve>(parent)
 {
-    return vector.x();
-}
-
-qreal QQmlVector2DValueType::y() const
-{
-    return vector.y();
-}
-
-void QQmlVector2DValueType::setX(qreal x)
-{
-    vector.setX(x);
-}
-
-void QQmlVector2DValueType::setY(qreal y)
-{
-    vector.setY(y);
-}
-
-QString QQmlVector3DValueType::toString() const
-{
-    return QString(QLatin1String("QVector3D(%1, %2, %3)")).arg(vector.x()).arg(vector.y()).arg(vector.z());
-}
-
-qreal QQmlVector3DValueType::x() const
-{
-    return vector.x();
-}
-
-qreal QQmlVector3DValueType::y() const
-{
-    return vector.y();
-}
-
-qreal QQmlVector3DValueType::z() const
-{
-    return vector.z();
-}
-
-void QQmlVector3DValueType::setX(qreal x)
-{
-    vector.setX(x);
-}
-
-void QQmlVector3DValueType::setY(qreal y)
-{
-    vector.setY(y);
-}
-
-void QQmlVector3DValueType::setZ(qreal z)
-{
-    vector.setZ(z);
-}
-
-QString QQmlVector4DValueType::toString() const
-{
-    return QString(QLatin1String("QVector4D(%1, %2, %3, %4)")).arg(vector.x()).arg(vector.y()).arg(vector.z()).arg(vector.w());
-}
-
-qreal QQmlVector4DValueType::x() const
-{
-    return vector.x();
-}
-
-qreal QQmlVector4DValueType::y() const
-{
-    return vector.y();
-}
-
-qreal QQmlVector4DValueType::z() const
-{
-    return vector.z();
-}
-
-qreal QQmlVector4DValueType::w() const
-{
-    return vector.w();
-}
-
-void QQmlVector4DValueType::setX(qreal x)
-{
-    vector.setX(x);
-}
-
-void QQmlVector4DValueType::setY(qreal y)
-{
-    vector.setY(y);
-}
-
-void QQmlVector4DValueType::setZ(qreal z)
-{
-    vector.setZ(z);
-}
-
-void QQmlVector4DValueType::setW(qreal w)
-{
-    vector.setW(w);
-}
-
-QString QQmlQuaternionValueType::toString() const
-{
-    return QString(QLatin1String("QQuaternion(%1, %2, %3, %4)")).arg(quaternion.scalar()).arg(quaternion.x()).arg(quaternion.y()).arg(quaternion.z());
-}
-
-qreal QQmlQuaternionValueType::scalar() const
-{
-    return quaternion.scalar();
-}
-
-qreal QQmlQuaternionValueType::x() const
-{
-    return quaternion.x();
-}
-
-qreal QQmlQuaternionValueType::y() const
-{
-    return quaternion.y();
-}
-
-qreal QQmlQuaternionValueType::z() const
-{
-    return quaternion.z();
-}
-
-void QQmlQuaternionValueType::setScalar(qreal scalar)
-{
-    quaternion.setScalar(scalar);
-}
-
-void QQmlQuaternionValueType::setX(qreal x)
-{
-    quaternion.setX(x);
-}
-
-void QQmlQuaternionValueType::setY(qreal y)
-{
-    quaternion.setY(y);
-}
-
-void QQmlQuaternionValueType::setZ(qreal z)
-{
-    quaternion.setZ(z);
-}
-
-QString QQmlMatrix4x4ValueType::toString() const
-{
-    return QString(QLatin1String("QMatrix4x4(%1, %2, %3, %4, %5, %6, %7, %8, %9, %10, %11, %12, %13, %14, %15, %16)"))
-            .arg(matrix(0, 0)).arg(matrix(0, 1)).arg(matrix(0, 2)).arg(matrix(0, 3))
-            .arg(matrix(1, 0)).arg(matrix(1, 1)).arg(matrix(1, 2)).arg(matrix(1, 3))
-            .arg(matrix(2, 0)).arg(matrix(2, 1)).arg(matrix(2, 2)).arg(matrix(2, 3))
-            .arg(matrix(3, 0)).arg(matrix(3, 1)).arg(matrix(3, 2)).arg(matrix(3, 3));
 }
 
 QString QQmlEasingValueType::toString() const
 {
-    return QString(QLatin1String("QEasingCurve(%1, %2, %3, %4)")).arg(easing.type()).arg(easing.amplitude()).arg(easing.overshoot()).arg(easing.period());
+    return QString(QLatin1String("QEasingCurve(%1, %2, %3, %4)")).arg(v.type()).arg(v.amplitude()).arg(v.overshoot()).arg(v.period());
 }
 
 QQmlEasingValueType::Type QQmlEasingValueType::type() const
 {
-    return (QQmlEasingValueType::Type)easing.type();
+    return (QQmlEasingValueType::Type)v.type();
 }
 
 qreal QQmlEasingValueType::amplitude() const
 {
-    return easing.amplitude();
+    return v.amplitude();
 }
 
 qreal QQmlEasingValueType::overshoot() const
 {
-    return easing.overshoot();
+    return v.overshoot();
 }
 
 qreal QQmlEasingValueType::period() const
 {
-    return easing.period();
+    return v.period();
 }
 
 void QQmlEasingValueType::setType(QQmlEasingValueType::Type type)
 {
-    easing.setType((QEasingCurve::Type)type);
+    v.setType((QEasingCurve::Type)type);
 }
 
 void QQmlEasingValueType::setAmplitude(qreal amplitude)
 {
-    easing.setAmplitude(amplitude);
+    v.setAmplitude(amplitude);
 }
 
 void QQmlEasingValueType::setOvershoot(qreal overshoot)
 {
-    easing.setOvershoot(overshoot);
+    v.setOvershoot(overshoot);
 }
 
 void QQmlEasingValueType::setPeriod(qreal period)
 {
-    easing.setPeriod(period);
+    v.setPeriod(period);
 }
 
 void QQmlEasingValueType::setBezierCurve(const QVariantList &customCurveVariant)
@@ -646,7 +430,7 @@ void QQmlEasingValueType::setBezierCurve(const QVariantList &customCurveVariant)
                 const QPointF c3(c3x, c3y);
 
                 newEasingCurve.addCubicBezierSegment(c1, c2, c3);
-                easing = newEasingCurve;
+                v = newEasingCurve;
             }
         }
     }
@@ -655,214 +439,10 @@ void QQmlEasingValueType::setBezierCurve(const QVariantList &customCurveVariant)
 QVariantList QQmlEasingValueType::bezierCurve() const
 {
     QVariantList rv;
-    QList<QPointF> points = easing.cubicBezierSpline();
+    QList<QPointF> points = v.cubicBezierSpline();
     for (int ii = 0; ii < points.count(); ++ii)
         rv << QVariant(points.at(ii).x()) << QVariant(points.at(ii).y());
     return rv;
 }
 
-void QQmlFontValueType::onLoad()
-{
-    pixelSizeSet = false;
-    pointSizeSet = false;
-}
-
-QString QQmlFontValueType::toString() const
-{
-    return QString(QLatin1String("QFont(%1)")).arg(font.toString());
-}
-
-QString QQmlFontValueType::family() const
-{
-    return font.family();
-}
-
-void QQmlFontValueType::setFamily(const QString &family)
-{
-    font.setFamily(family);
-}
-
-bool QQmlFontValueType::bold() const
-{
-    return font.bold();
-}
-
-void QQmlFontValueType::setBold(bool b)
-{
-    font.setBold(b);
-}
-
-QQmlFontValueType::FontWeight QQmlFontValueType::weight() const
-{
-    return (QQmlFontValueType::FontWeight)font.weight();
-}
-
-void QQmlFontValueType::setWeight(QQmlFontValueType::FontWeight w)
-{
-    font.setWeight((QFont::Weight)w);
-}
-
-bool QQmlFontValueType::italic() const
-{
-    return font.italic();
-}
-
-void QQmlFontValueType::setItalic(bool b)
-{
-    font.setItalic(b);
-}
-
-bool QQmlFontValueType::underline() const
-{
-    return font.underline();
-}
-
-void QQmlFontValueType::setUnderline(bool b)
-{
-    font.setUnderline(b);
-}
-
-bool QQmlFontValueType::overline() const
-{
-    return font.overline();
-}
-
-void QQmlFontValueType::setOverline(bool b)
-{
-    font.setOverline(b);
-}
-
-bool QQmlFontValueType::strikeout() const
-{
-    return font.strikeOut();
-}
-
-void QQmlFontValueType::setStrikeout(bool b)
-{
-    font.setStrikeOut(b);
-}
-
-qreal QQmlFontValueType::pointSize() const
-{
-    if (font.pointSizeF() == -1) {
-        if (dpi.isNull)
-            dpi = qt_defaultDpi();
-        return font.pixelSize() * qreal(72.) / qreal(dpi);
-    }
-    return font.pointSizeF();
-}
-
-void QQmlFontValueType::setPointSize(qreal size)
-{
-    if (pixelSizeSet) {
-        qWarning() << "Both point size and pixel size set. Using pixel size.";
-        return;
-    }
-
-    if (size >= 0.0) {
-        pointSizeSet = true;
-        font.setPointSizeF(size);
-    } else {
-        pointSizeSet = false;
-    }
-}
-
-int QQmlFontValueType::pixelSize() const
-{
-    if (font.pixelSize() == -1) {
-        if (dpi.isNull)
-            dpi = qt_defaultDpi();
-        return (font.pointSizeF() * dpi) / qreal(72.);
-    }
-    return font.pixelSize();
-}
-
-void QQmlFontValueType::setPixelSize(int size)
-{
-    if (size >0) {
-        if (pointSizeSet)
-            qWarning() << "Both point size and pixel size set. Using pixel size.";
-        font.setPixelSize(size);
-        pixelSizeSet = true;
-    } else {
-        pixelSizeSet = false;
-    }
-}
-
-QQmlFontValueType::Capitalization QQmlFontValueType::capitalization() const
-{
-    return (QQmlFontValueType::Capitalization)font.capitalization();
-}
-
-void QQmlFontValueType::setCapitalization(QQmlFontValueType::Capitalization c)
-{
-    font.setCapitalization((QFont::Capitalization)c);
-}
-
-qreal QQmlFontValueType::letterSpacing() const
-{
-    return font.letterSpacing();
-}
-
-void QQmlFontValueType::setLetterSpacing(qreal size)
-{
-    font.setLetterSpacing(QFont::AbsoluteSpacing, size);
-}
-
-qreal QQmlFontValueType::wordSpacing() const
-{
-    return font.wordSpacing();
-}
-
-void QQmlFontValueType::setWordSpacing(qreal size)
-{
-    font.setWordSpacing(size);
-}
-
-QString QQmlColorValueType::toString() const
-{
-    // special case - to maintain behaviour with QtQuick 1.0, we just output normal toString() value.
-    return QVariant(color).toString();
-}
-
-qreal QQmlColorValueType::r() const
-{
-    return color.redF();
-}
-
-qreal QQmlColorValueType::g() const
-{
-    return color.greenF();
-}
-
-qreal QQmlColorValueType::b() const
-{
-    return color.blueF();
-}
-
-qreal QQmlColorValueType::a() const
-{
-    return color.alphaF();
-}
-
-void QQmlColorValueType::setR(qreal r)
-{
-    color.setRedF(r);
-}
-
-void QQmlColorValueType::setG(qreal g)
-{
-    color.setGreenF(g);
-}
-
-void QQmlColorValueType::setB(qreal b)
-{
-    color.setBlueF(b);
-}
-
-void QQmlColorValueType::setA(qreal a)
-{
-    color.setAlphaF(a);
-}
-
 QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlvaluetype_p.h b/src/qml/qml/qqmlvaluetype_p.h
index 71817c2a2d..d55c839c7d 100644
--- a/src/qml/qml/qqmlvaluetype_p.h
+++ b/src/qml/qml/qqmlvaluetype_p.h
@@ -53,6 +53,7 @@
 // We mean it.
 //
 
+#include "qqml.h"
 #include "qqmlproperty.h"
 #include "qqmlproperty_p.h"
 #include "qqmlnullablevalue_p_p.h"
@@ -61,13 +62,6 @@
 #include <QtCore/qrect.h>
 #include <QtCore/qeasingcurve.h>
 #include <QtCore/qvariant.h>
-#include <QtGui/qvector2d.h>
-#include <QtGui/qvector3d.h>
-#include <QtGui/qvector4d.h>
-#include <QtGui/qmatrix4x4.h>
-#include <QtGui/qquaternion.h>
-#include <QtGui/qfont.h>
-#include <QtGui/qcolor.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -84,7 +78,63 @@ public:
     virtual QString toString() const = 0;
     virtual bool isEqual(const QVariant &value) const = 0;
 
-    inline void onLoad();
+    virtual void onLoad() {}
+
+protected:
+    inline void readProperty(QObject *obj, int idx, void *p)
+    {
+        void *a[] = { p, 0 };
+        QMetaObject::metacall(obj, QMetaObject::ReadProperty, idx, a);
+        onLoad();
+    }
+
+    inline void writeProperty(QObject *obj, int idx, QQmlPropertyPrivate::WriteFlags flags, void *p)
+    {
+        int status = -1;
+        void *a[] = { p, 0, &status, &flags };
+        QMetaObject::metacall(obj, QMetaObject::WriteProperty, idx, a);
+    }
+};
+
+template <typename T>
+class QQmlValueTypeBase : public QQmlValueType
+{
+public:
+    typedef T ValueType;
+
+    QQmlValueTypeBase(QObject *parent)
+        : QQmlValueType(parent)
+    {
+    }
+
+    virtual void read(QObject *obj, int idx)
+    {
+        readProperty(obj, idx, &v);
+    }
+
+    virtual void write(QObject *obj, int idx, QQmlPropertyPrivate::WriteFlags flags)
+    {
+        writeProperty(obj, idx, flags, &v);
+    }
+
+    virtual QVariant value()
+    {
+        return QVariant(v);
+    }
+
+    virtual void setValue(const QVariant &value)
+    {
+        v = qvariant_cast<T>(value);
+        onLoad();
+    }
+
+    virtual bool isEqual(const QVariant &other) const
+    {
+        return QVariant(v) == other;
+    }
+
+protected:
+    ValueType v;
 };
 
 class Q_QML_PRIVATE_EXPORT QQmlValueTypeFactory
@@ -99,16 +149,27 @@ public:
     static void registerValueTypes();
 
     QQmlValueType *operator[](int idx) const {
-        if (idx >= (int)QVariant::UserType) return 0;
-        else return valueTypes[idx];
+        if (idx >= (int)QVariant::UserType)
+            return 0;
+
+        QQmlValueType *rv = valueTypes[idx];
+        if (!rv) {
+            // Table update is not thread-safe, but the potential for leaks is
+            // so small that the cost of protection is unwarranted
+            if ((rv = valueType(idx))) {
+                valueTypes[idx] = rv;
+            }
+        }
+        return rv;
     }
 
 private:
-    QQmlValueType *valueTypes[QVariant::UserType - 1]; 
+    mutable QQmlValueType *valueTypes[QVariant::UserType - 1];
 };
 
-// Exported for QtQuick1
-class Q_QML_PRIVATE_EXPORT QQmlPointFValueType : public QQmlValueType
+// These exports of these value types are obsolete since QtQuick1 no longer
+// needs them - they should become Q_AUTOTEST_EXPORT
+class Q_QML_PRIVATE_EXPORT QQmlPointFValueType : public QQmlValueTypeBase<QPointF>
 {
     Q_PROPERTY(qreal x READ x WRITE setX)
     Q_PROPERTY(qreal y READ y WRITE setY)
@@ -116,24 +177,15 @@ class Q_QML_PRIVATE_EXPORT QQmlPointFValueType : public QQmlValueType
 public:
     QQmlPointFValueType(QObject *parent = 0);
 
-    virtual void read(QObject *, int);
-    virtual void write(QObject *, int, QQmlPropertyPrivate::WriteFlags);
-    virtual QVariant value();
-    virtual void setValue(const QVariant &value);
     virtual QString toString() const;
-    virtual bool isEqual(const QVariant &value) const;
 
     qreal x() const;
     qreal y() const;
     void setX(qreal);
     void setY(qreal);
-
-private:
-    QPointF point;
 };
 
-// Exported for QtQuick1
-class Q_QML_PRIVATE_EXPORT QQmlPointValueType : public QQmlValueType
+class Q_QML_PRIVATE_EXPORT QQmlPointValueType : public QQmlValueTypeBase<QPoint>
 {
     Q_PROPERTY(int x READ x WRITE setX)
     Q_PROPERTY(int y READ y WRITE setY)
@@ -141,24 +193,15 @@ class Q_QML_PRIVATE_EXPORT QQmlPointValueType : public QQmlValueType
 public:
     QQmlPointValueType(QObject *parent = 0);
 
-    virtual void read(QObject *, int);
-    virtual void write(QObject *, int, QQmlPropertyPrivate::WriteFlags);
-    virtual QVariant value();
-    virtual void setValue(const QVariant &value);
     virtual QString toString() const;
-    virtual bool isEqual(const QVariant &value) const;
 
     int x() const;
     int y() const;
     void setX(int);
     void setY(int);
-
-private:
-    QPoint point;
 };
 
-// Exported for QtQuick1
-class Q_QML_PRIVATE_EXPORT QQmlSizeFValueType : public QQmlValueType
+class Q_QML_PRIVATE_EXPORT QQmlSizeFValueType : public QQmlValueTypeBase<QSizeF>
 {
     Q_PROPERTY(qreal width READ width WRITE setWidth)
     Q_PROPERTY(qreal height READ height WRITE setHeight)
@@ -166,24 +209,15 @@ class Q_QML_PRIVATE_EXPORT QQmlSizeFValueType : public QQmlValueType
 public:
     QQmlSizeFValueType(QObject *parent = 0);
 
-    virtual void read(QObject *, int);
-    virtual void write(QObject *, int, QQmlPropertyPrivate::WriteFlags);
-    virtual QVariant value();
-    virtual void setValue(const QVariant &value);
     virtual QString toString() const;
-    virtual bool isEqual(const QVariant &value) const;
 
     qreal width() const;
     qreal height() const;
     void setWidth(qreal);
     void setHeight(qreal);
-
-private:
-    QSizeF size;
 };
 
-// Exported for QtQuick1
-class Q_QML_PRIVATE_EXPORT QQmlSizeValueType : public QQmlValueType
+class Q_QML_PRIVATE_EXPORT QQmlSizeValueType : public QQmlValueTypeBase<QSize>
 {
     Q_PROPERTY(int width READ width WRITE setWidth)
     Q_PROPERTY(int height READ height WRITE setHeight)
@@ -191,24 +225,15 @@ class Q_QML_PRIVATE_EXPORT QQmlSizeValueType : public QQmlValueType
 public:
     QQmlSizeValueType(QObject *parent = 0);
 
-    virtual void read(QObject *, int);
-    virtual void write(QObject *, int, QQmlPropertyPrivate::WriteFlags);
-    virtual QVariant value();
-    virtual void setValue(const QVariant &value);
     virtual QString toString() const;
-    virtual bool isEqual(const QVariant &value) const;
 
     int width() const;
     int height() const;
     void setWidth(int);
     void setHeight(int);
-
-private:
-    QSize size;
 };
 
-// Exported for QtQuick1
-class Q_QML_PRIVATE_EXPORT QQmlRectFValueType : public QQmlValueType
+class Q_QML_PRIVATE_EXPORT QQmlRectFValueType : public QQmlValueTypeBase<QRectF>
 {
     Q_PROPERTY(qreal x READ x WRITE setX)
     Q_PROPERTY(qreal y READ y WRITE setY)
@@ -218,12 +243,7 @@ class Q_QML_PRIVATE_EXPORT QQmlRectFValueType : public QQmlValueType
 public:
     QQmlRectFValueType(QObject *parent = 0);
 
-    virtual void read(QObject *, int);
-    virtual void write(QObject *, int, QQmlPropertyPrivate::WriteFlags);
-    virtual QVariant value();
-    virtual void setValue(const QVariant &value);
     virtual QString toString() const;
-    virtual bool isEqual(const QVariant &value) const;
 
     qreal x() const;
     qreal y() const;
@@ -234,13 +254,9 @@ public:
     qreal height() const;
     void setWidth(qreal);
     void setHeight(qreal);
-
-private:
-    QRectF rect;
 };
 
-// Exported for QtQuick1
-class Q_QML_PRIVATE_EXPORT QQmlRectValueType : public QQmlValueType
+class Q_QML_PRIVATE_EXPORT QQmlRectValueType : public QQmlValueTypeBase<QRect>
 {
     Q_PROPERTY(int x READ x WRITE setX)
     Q_PROPERTY(int y READ y WRITE setY)
@@ -250,12 +266,7 @@ class Q_QML_PRIVATE_EXPORT QQmlRectValueType : public QQmlValueType
 public:
     QQmlRectValueType(QObject *parent = 0);
 
-    virtual void read(QObject *, int);
-    virtual void write(QObject *, int, QQmlPropertyPrivate::WriteFlags);
-    virtual QVariant value();
-    virtual void setValue(const QVariant &value);
     virtual QString toString() const;
-    virtual bool isEqual(const QVariant &value) const;
 
     int x() const;
     int y() const;
@@ -266,190 +277,9 @@ public:
     int height() const;
     void setWidth(int);
     void setHeight(int);
-
-private:
-    QRect rect;
 };
 
-class Q_QML_PRIVATE_EXPORT QQmlVector2DValueType : public QQmlValueType
-{
-    Q_PROPERTY(qreal x READ x WRITE setX)
-    Q_PROPERTY(qreal y READ y WRITE setY)
-    Q_OBJECT
-public:
-    QQmlVector2DValueType(QObject *parent = 0);
-
-    virtual void read(QObject *, int);
-    virtual void write(QObject *, int, QQmlPropertyPrivate::WriteFlags);
-    virtual QVariant value();
-    virtual void setValue(const QVariant &value);
-    virtual QString toString() const;
-    virtual bool isEqual(const QVariant &value) const;
-
-    qreal x() const;
-    qreal y() const;
-    void setX(qreal);
-    void setY(qreal);
-
-private:
-    QVector2D vector;
-};
-
-class Q_QML_PRIVATE_EXPORT QQmlVector3DValueType : public QQmlValueType
-{
-    Q_PROPERTY(qreal x READ x WRITE setX)
-    Q_PROPERTY(qreal y READ y WRITE setY)
-    Q_PROPERTY(qreal z READ z WRITE setZ)
-    Q_OBJECT
-public:
-    QQmlVector3DValueType(QObject *parent = 0);
-
-    virtual void read(QObject *, int);
-    virtual void write(QObject *, int, QQmlPropertyPrivate::WriteFlags);
-    virtual QVariant value();
-    virtual void setValue(const QVariant &value);
-    virtual QString toString() const;
-    virtual bool isEqual(const QVariant &value) const;
-
-    qreal x() const;
-    qreal y() const;
-    qreal z() const;
-    void setX(qreal);
-    void setY(qreal);
-    void setZ(qreal);
-
-private:
-    QVector3D vector;
-};
-
-class Q_QML_PRIVATE_EXPORT QQmlVector4DValueType : public QQmlValueType
-{
-    Q_PROPERTY(qreal x READ x WRITE setX)
-    Q_PROPERTY(qreal y READ y WRITE setY)
-    Q_PROPERTY(qreal z READ z WRITE setZ)
-    Q_PROPERTY(qreal w READ w WRITE setW)
-    Q_OBJECT
-public:
-    QQmlVector4DValueType(QObject *parent = 0);
-
-    virtual void read(QObject *, int);
-    virtual void write(QObject *, int, QQmlPropertyPrivate::WriteFlags);
-    virtual QVariant value();
-    virtual void setValue(const QVariant &value);
-    virtual QString toString() const;
-    virtual bool isEqual(const QVariant &value) const;
-
-    qreal x() const;
-    qreal y() const;
-    qreal z() const;
-    qreal w() const;
-    void setX(qreal);
-    void setY(qreal);
-    void setZ(qreal);
-    void setW(qreal);
-
-private:
-    QVector4D vector;
-};
-
-class Q_QML_PRIVATE_EXPORT QQmlQuaternionValueType : public QQmlValueType
-{
-    Q_PROPERTY(qreal scalar READ scalar WRITE setScalar)
-    Q_PROPERTY(qreal x READ x WRITE setX)
-    Q_PROPERTY(qreal y READ y WRITE setY)
-    Q_PROPERTY(qreal z READ z WRITE setZ)
-    Q_OBJECT
-public:
-    QQmlQuaternionValueType(QObject *parent = 0);
-
-    virtual void read(QObject *, int);
-    virtual void write(QObject *, int, QQmlPropertyPrivate::WriteFlags);
-    virtual QVariant value();
-    virtual void setValue(const QVariant &value);
-    virtual QString toString() const;
-    virtual bool isEqual(const QVariant &value) const;
-
-    qreal scalar() const;
-    qreal x() const;
-    qreal y() const;
-    qreal z() const;
-    void setScalar(qreal);
-    void setX(qreal);
-    void setY(qreal);
-    void setZ(qreal);
-
-private:
-    QQuaternion quaternion;
-};
-
-class Q_QML_PRIVATE_EXPORT QQmlMatrix4x4ValueType : public QQmlValueType
-{
-    Q_PROPERTY(qreal m11 READ m11 WRITE setM11)
-    Q_PROPERTY(qreal m12 READ m12 WRITE setM12)
-    Q_PROPERTY(qreal m13 READ m13 WRITE setM13)
-    Q_PROPERTY(qreal m14 READ m14 WRITE setM14)
-    Q_PROPERTY(qreal m21 READ m21 WRITE setM21)
-    Q_PROPERTY(qreal m22 READ m22 WRITE setM22)
-    Q_PROPERTY(qreal m23 READ m23 WRITE setM23)
-    Q_PROPERTY(qreal m24 READ m24 WRITE setM24)
-    Q_PROPERTY(qreal m31 READ m31 WRITE setM31)
-    Q_PROPERTY(qreal m32 READ m32 WRITE setM32)
-    Q_PROPERTY(qreal m33 READ m33 WRITE setM33)
-    Q_PROPERTY(qreal m34 READ m34 WRITE setM34)
-    Q_PROPERTY(qreal m41 READ m41 WRITE setM41)
-    Q_PROPERTY(qreal m42 READ m42 WRITE setM42)
-    Q_PROPERTY(qreal m43 READ m43 WRITE setM43)
-    Q_PROPERTY(qreal m44 READ m44 WRITE setM44)
-    Q_OBJECT
-public:
-    QQmlMatrix4x4ValueType(QObject *parent = 0);
-
-    virtual void read(QObject *, int);
-    virtual void write(QObject *, int, QQmlPropertyPrivate::WriteFlags);
-    virtual QVariant value();
-    virtual void setValue(const QVariant &value);
-    virtual QString toString() const;
-    virtual bool isEqual(const QVariant &value) const;
-
-    qreal m11() const { return matrix(0, 0); }
-    qreal m12() const { return matrix(0, 1); }
-    qreal m13() const { return matrix(0, 2); }
-    qreal m14() const { return matrix(0, 3); }
-    qreal m21() const { return matrix(1, 0); }
-    qreal m22() const { return matrix(1, 1); }
-    qreal m23() const { return matrix(1, 2); }
-    qreal m24() const { return matrix(1, 3); }
-    qreal m31() const { return matrix(2, 0); }
-    qreal m32() const { return matrix(2, 1); }
-    qreal m33() const { return matrix(2, 2); }
-    qreal m34() const { return matrix(2, 3); }
-    qreal m41() const { return matrix(3, 0); }
-    qreal m42() const { return matrix(3, 1); }
-    qreal m43() const { return matrix(3, 2); }
-    qreal m44() const { return matrix(3, 3); }
-
-    void setM11(qreal value) { matrix(0, 0) = value; }
-    void setM12(qreal value) { matrix(0, 1) = value; }
-    void setM13(qreal value) { matrix(0, 2) = value; }
-    void setM14(qreal value) { matrix(0, 3) = value; }
-    void setM21(qreal value) { matrix(1, 0) = value; }
-    void setM22(qreal value) { matrix(1, 1) = value; }
-    void setM23(qreal value) { matrix(1, 2) = value; }
-    void setM24(qreal value) { matrix(1, 3) = value; }
-    void setM31(qreal value) { matrix(2, 0) = value; }
-    void setM32(qreal value) { matrix(2, 1) = value; }
-    void setM33(qreal value) { matrix(2, 2) = value; }
-    void setM34(qreal value) { matrix(2, 3) = value; }
-    void setM41(qreal value) { matrix(3, 0) = value; }
-    void setM42(qreal value) { matrix(3, 1) = value; }
-    void setM43(qreal value) { matrix(3, 2) = value; }
-    void setM44(qreal value) { matrix(3, 3) = value; }
-
-private:
-    QMatrix4x4 matrix;
-};
-
-class Q_QML_PRIVATE_EXPORT QQmlEasingValueType : public QQmlValueType
+class Q_QML_PRIVATE_EXPORT QQmlEasingValueType : public QQmlValueTypeBase<QEasingCurve>
 {
     Q_OBJECT
     Q_ENUMS(Type)
@@ -489,12 +319,7 @@ public:
 
     QQmlEasingValueType(QObject *parent = 0);
 
-    virtual void read(QObject *, int);
-    virtual void write(QObject *, int, QQmlPropertyPrivate::WriteFlags);
-    virtual QVariant value();
-    virtual void setValue(const QVariant &value);
     virtual QString toString() const;
-    virtual bool isEqual(const QVariant &value) const;
 
     Type type() const;
     qreal amplitude() const;
@@ -506,128 +331,35 @@ public:
     void setPeriod(qreal);
     void setBezierCurve(const QVariantList &);
     QVariantList bezierCurve() const;
-
-
-private:
-    QEasingCurve easing;
 };
 
-class Q_QML_PRIVATE_EXPORT QQmlFontValueType : public QQmlValueType
+template<typename T>
+int qmlRegisterValueTypeEnums(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
 {
-    Q_OBJECT
-    Q_ENUMS(FontWeight)
-    Q_ENUMS(Capitalization)
-
-    Q_PROPERTY(QString family READ family WRITE setFamily)
-    Q_PROPERTY(bool bold READ bold WRITE setBold)
-    Q_PROPERTY(FontWeight weight READ weight WRITE setWeight)
-    Q_PROPERTY(bool italic READ italic WRITE setItalic)
-    Q_PROPERTY(bool underline READ underline WRITE setUnderline)
-    Q_PROPERTY(bool overline READ overline WRITE setOverline)
-    Q_PROPERTY(bool strikeout READ strikeout WRITE setStrikeout)
-    Q_PROPERTY(qreal pointSize READ pointSize WRITE setPointSize)
-    Q_PROPERTY(int pixelSize READ pixelSize WRITE setPixelSize)
-    Q_PROPERTY(Capitalization capitalization READ capitalization WRITE setCapitalization)
-    Q_PROPERTY(qreal letterSpacing READ letterSpacing WRITE setLetterSpacing)
-    Q_PROPERTY(qreal wordSpacing READ wordSpacing WRITE setWordSpacing)
-
-public:
-    enum FontWeight { Light = QFont::Light,
-                       Normal = QFont::Normal,
-                       DemiBold = QFont::DemiBold,
-                       Bold = QFont::Bold,
-                       Black = QFont::Black };
-    enum Capitalization { MixedCase = QFont::MixedCase,
-                           AllUppercase = QFont::AllUppercase,
-                           AllLowercase = QFont::AllLowercase,
-                           SmallCaps = QFont::SmallCaps,
-                           Capitalize = QFont::Capitalize };
-
-    QQmlFontValueType(QObject *parent = 0);
-
-    virtual void read(QObject *, int);
-    virtual void write(QObject *, int, QQmlPropertyPrivate::WriteFlags);
-    virtual QVariant value();
-    virtual void setValue(const QVariant &value);
-    virtual QString toString() const;
-    virtual bool isEqual(const QVariant &value) const;
-
-    QString family() const;
-    void setFamily(const QString &);
-
-    bool bold() const;
-    void setBold(bool b);
+    QByteArray name(T::staticMetaObject.className());
 
-    FontWeight weight() const;
-    void setWeight(FontWeight);
+    QByteArray pointerName(name + '*');
 
-    bool italic() const;
-    void setItalic(bool b);
+    QQmlPrivate::RegisterType type = {
+        0,
 
-    bool underline() const;
-    void setUnderline(bool b);
+        qRegisterMetaType<T *>(pointerName.constData()), 0, 0, 0,
 
-    bool overline() const;
-    void setOverline(bool b);
+        QString(),
 
-    bool strikeout() const;
-    void setStrikeout(bool b);
+        uri, versionMajor, versionMinor, qmlName, &T::staticMetaObject,
 
-    qreal pointSize() const;
-    void setPointSize(qreal size);
+        0, 0,
 
-    int pixelSize() const;
-    void setPixelSize(int size);
+        0, 0, 0,
 
-    Capitalization capitalization() const;
-    void setCapitalization(Capitalization);
+        0, 0,
 
-    qreal letterSpacing() const;
-    void setLetterSpacing(qreal spacing);
-
-    qreal wordSpacing() const;
-    void setWordSpacing(qreal spacing);
-
-    void onLoad();
-private:
-    QFont font;
-    bool pixelSizeSet;
-    bool pointSizeSet;
-    mutable QQmlNullableValue<int> dpi;
-};
-
-class Q_QML_PRIVATE_EXPORT QQmlColorValueType : public QQmlValueType
-{
-    Q_PROPERTY(qreal r READ r WRITE setR)
-    Q_PROPERTY(qreal g READ g WRITE setG)
-    Q_PROPERTY(qreal b READ b WRITE setB)
-    Q_PROPERTY(qreal a READ a WRITE setA)
-    Q_OBJECT
-public:
-    QQmlColorValueType(QObject *parent = 0);
-
-    virtual void read(QObject *, int);
-    virtual void write(QObject *, int, QQmlPropertyPrivate::WriteFlags);
-    virtual QVariant value();
-    virtual void setValue(const QVariant &value);
-    virtual QString toString() const;
-    virtual bool isEqual(const QVariant &value) const;
-
-    qreal r() const;
-    qreal g() const;
-    qreal b() const;
-    qreal a() const;
-    void setR(qreal);
-    void setG(qreal);
-    void setB(qreal);
-    void setA(qreal);
-
-private:
-    QColor color;
-};
+        0,
+        0
+    };
 
-void QQmlValueType::onLoad()
-{
+    return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlvme.cpp b/src/qml/qml/qqmlvme.cpp
index 86e9f0963a..6309335e59 100644
--- a/src/qml/qml/qqmlvme.cpp
+++ b/src/qml/qml/qqmlvme.cpp
@@ -68,7 +68,6 @@
 #include "qqmlvaluetypeproxybinding_p.h"
 
 #include <QStack>
-#include <QColor>
 #include <QPointF>
 #include <QSizeF>
 #include <QRectF>
@@ -267,6 +266,17 @@ static QVariant variantFromString(const QString &string)
         QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.propertyIndex, a); \
     QML_END_INSTR(name)
 
+#define QML_STORE_PROVIDER_VALUE(name, type, value) \
+    QML_BEGIN_INSTR(name) \
+        struct { void *data[4]; } buffer; \
+        if (QQml_valueTypeProvider()->storeValueType(type, &value, &buffer, sizeof(buffer))) { \
+            void *a[] = { reinterpret_cast<void *>(&buffer), 0, &status, &flags }; \
+            QObject *target = objects.top(); \
+            CLEAN_PROPERTY(target, instr.propertyIndex); \
+            QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.propertyIndex, a); \
+        } \
+    QML_END_INSTR(name)
+
 #define QML_STORE_LIST(name, cpptype, value) \
     QML_BEGIN_INSTR(name) \
         cpptype v; \
@@ -366,7 +376,7 @@ QObject *QQmlVME::run(QList<QQmlError> *errors,
         QML_STORE_VALUE(StoreDouble, double, instr.value);
         QML_STORE_VALUE(StoreBool, bool, instr.value);
         QML_STORE_VALUE(StoreInteger, int, instr.value);
-        QML_STORE_VALUE(StoreColor, QColor, QColor::fromRgba(instr.value));
+        QML_STORE_PROVIDER_VALUE(StoreColor, QMetaType::QColor, instr.value);
         QML_STORE_VALUE(StoreDate, QDate, QDate::fromJulianDay(instr.value));
         QML_STORE_VALUE(StoreDateTime, QDateTime,
                         QDateTime(QDate::fromJulianDay(instr.date), *(QTime *)&instr.time));
@@ -377,8 +387,8 @@ QObject *QQmlVME::run(QList<QQmlError> *errors,
         QML_STORE_POINTER(StoreSizeF, (QSizeF *)&instr.size);
         QML_STORE_POINTER(StoreRect, (QRect *)&instr.rect);
         QML_STORE_POINTER(StoreRectF, (QRectF *)&instr.rect);
-        QML_STORE_POINTER(StoreVector3D, (QVector3D *)&instr.vector);
-        QML_STORE_POINTER(StoreVector4D, (QVector4D *)&instr.vector);
+        QML_STORE_PROVIDER_VALUE(StoreVector3D, QMetaType::QVector3D, instr.vector);
+        QML_STORE_PROVIDER_VALUE(StoreVector4D, QMetaType::QVector4D, instr.vector);
         QML_STORE_POINTER(StoreString, &PRIMITIVES.at(instr.value));
         QML_STORE_POINTER(StoreByteArray, &DATAS.at(instr.value));
         QML_STORE_POINTER(StoreUrl, &URLS.at(instr.value));
diff --git a/src/qml/qml/qqmlvmemetaobject.cpp b/src/qml/qml/qqmlvmemetaobject.cpp
index c4e801f2db..afcc57e479 100644
--- a/src/qml/qml/qqmlvmemetaobject.cpp
+++ b/src/qml/qml/qqmlvmemetaobject.cpp
@@ -51,6 +51,7 @@
 #include "qqmlpropertyvalueinterceptor_p.h"
 
 #include <private/qv8variantresource_p.h>
+#include <private/qqmlglobal_p.h>
 
 Q_DECLARE_METATYPE(QJSValue);
 
@@ -87,6 +88,7 @@ public:
     inline const void *dataPtr() const;
     inline void *dataPtr();
     inline int dataType() const;
+    inline size_t dataSize() const;
 
     inline QObject *asQObject();
     inline const QVariant &asQVariant();
@@ -95,7 +97,6 @@ public:
     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();
@@ -108,11 +109,13 @@ public:
     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 QJSValue &);
+
+    inline void setDataType(int t);
+
 private:
     int type;
     void *data[6]; // Large enough to hold all types
@@ -157,9 +160,6 @@ void QQmlVMEVariant::cleanup()
     } 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;
@@ -175,8 +175,11 @@ void QQmlVMEVariant::cleanup()
     } else if (type == qMetaTypeId<QJSValue>()) {
         ((QJSValue *)dataPtr())->~QJSValue();
         type = QVariant::Invalid;
+    } else {
+        if (QQml_valueTypeProvider()->destroyValueType(type, dataPtr(), dataSize())) {
+            type = QVariant::Invalid;
+        }
     }
-
 }
 
 int QQmlVMEVariant::dataType() const
@@ -194,6 +197,11 @@ void *QQmlVMEVariant::dataPtr()
     return &data;
 }
 
+size_t QQmlVMEVariant::dataSize() const
+{
+    return sizeof(data);
+}
+
 QObject *QQmlVMEVariant::asQObject() 
 {
     if (type != QMetaType::QObjectStar)
@@ -250,14 +258,6 @@ const QUrl &QQmlVMEVariant::asQUrl()
     return *(QUrl *)(dataPtr());
 }
 
-const QColor &QQmlVMEVariant::asQColor() 
-{
-    if (type != QMetaType::QColor)
-        setValue(QColor());
-
-    return *(QColor *)(dataPtr());
-}
-
 const QTime &QQmlVMEVariant::asQTime() 
 {
     if (type != QMetaType::QTime)
@@ -360,17 +360,6 @@ void QQmlVMEVariant::setValue(const QUrl &v)
     }
 }
 
-void QQmlVMEVariant::setValue(const QColor &v)
-{
-    if (type != QMetaType::QColor) {
-        cleanup();
-        type = QMetaType::QColor;
-        new (dataPtr()) QColor(v);
-    } else {
-        *(QColor *)(dataPtr()) = v;
-    }
-}
-
 void QQmlVMEVariant::setValue(const QTime &v)
 {
     if (type != QMetaType::QTime) {
@@ -415,6 +404,11 @@ void QQmlVMEVariant::setValue(const QJSValue &v)
     }
 }
 
+void QQmlVMEVariant::setDataType(int t)
+{
+    type = t;
+}
+
 QQmlVMEMetaObjectEndpoint::QQmlVMEMetaObjectEndpoint()
 {
     callback = &vmecallback;
@@ -587,9 +581,6 @@ int QQmlVMEMetaObject::metaCall(QMetaObject::Call c, int _id, void **a)
                         case QVariant::Url:
                             *reinterpret_cast<QUrl *>(a[0]) = data[id].asQUrl();
                             break;
-                        case QVariant::Color:
-                            *reinterpret_cast<QColor *>(a[0]) = data[id].asQColor();
-                            break;
                         case QVariant::Date:
                             *reinterpret_cast<QDate *>(a[0]) = data[id].asQDate();
                             break;
@@ -603,6 +594,7 @@ int QQmlVMEMetaObject::metaCall(QMetaObject::Call c, int _id, void **a)
                             *reinterpret_cast<QVariant *>(a[0]) = readPropertyAsVariant(id);
                             break;
                         default:
+                            QQml_valueTypeProvider()->readValueType(data[id].dataType(), data[id].dataPtr(), t, a[0]);
                             break;
                         }
                         if (t == qMetaTypeId<QQmlListProperty<QObject> >()) {
@@ -637,10 +629,6 @@ int QQmlVMEMetaObject::metaCall(QMetaObject::Call c, int _id, void **a)
                             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]));
@@ -657,6 +645,10 @@ int QQmlVMEMetaObject::metaCall(QMetaObject::Call c, int _id, void **a)
                             writeProperty(id, *reinterpret_cast<QVariant *>(a[0]));
                             break;
                         default:
+                            needActivate = QQml_valueTypeProvider()->writeValueType(t, a[0], data[id].dataPtr(), data[id].dataSize());
+                            if (needActivate) {
+                                data[id].setDataType(t);
+                            }
                             break;
                         }
                     }
diff --git a/src/qml/qml/qqmlvmemetaobject_p.h b/src/qml/qml/qqmlvmemetaobject_p.h
index 1b5ceb8203..5bd472a067 100644
--- a/src/qml/qml/qqmlvmemetaobject_p.h
+++ b/src/qml/qml/qqmlvmemetaobject_p.h
@@ -58,7 +58,6 @@
 #include <QtCore/QMetaObject>
 #include <QtCore/QBitArray>
 #include <QtCore/QPair>
-#include <QtGui/QColor>
 #include <QtCore/QDate>
 #include <QtCore/qlist.h>
 #include <QtCore/qdebug.h>
diff --git a/src/qml/qml/qquicklistmodelworkeragent_p.h b/src/qml/qml/qquicklistmodelworkeragent_p.h
index cf2ef45c16..24198b020c 100644
--- a/src/qml/qml/qquicklistmodelworkeragent_p.h
+++ b/src/qml/qml/qquicklistmodelworkeragent_p.h
@@ -55,7 +55,6 @@
 
 #include <qqml.h>
 
-#include <QtGui/qevent.h>
 #include <QMutex>
 #include <QWaitCondition>
 
diff --git a/src/qml/qml/v4/qv4bindings.cpp b/src/qml/qml/v4/qv4bindings.cpp
index 5d367f2ae6..38a3acafa2 100644
--- a/src/qml/qml/v4/qv4bindings.cpp
+++ b/src/qml/qml/v4/qv4bindings.cpp
@@ -46,6 +46,7 @@
 #include "qv4compiler_p.h"
 #include "qv4compiler_p_p.h"
 
+#include <private/qqmlglobal_p.h>
 #include <private/qqmlaccessors_p.h>
 #include <private/qqmlprofilerservice_p.h>
 #include <private/qqmlmetatype_p.h>
@@ -88,12 +89,11 @@ struct Register {
     QVariant *getvariantptr() { return (QVariant *)typeDataPtr(); }
     QString *getstringptr() { return (QString *)typeDataPtr(); }
     QUrl *geturlptr() { return (QUrl *)typeDataPtr(); }
-    QColor *getcolorptr() { return (QColor *)typeDataPtr(); }
     const QVariant *getvariantptr() const { return (QVariant *)typeDataPtr(); }
     const QString *getstringptr() const { return (QString *)typeDataPtr(); }
     const QUrl *geturlptr() const { return (QUrl *)typeDataPtr(); }
-    const QColor *getcolorptr() const { return (QColor *)typeDataPtr(); }
 
+    size_t dataSize() { return sizeof(data); }
     void *typeDataPtr() { return (void *)&data; }
     void *typeMemory() { return (void *)data; }
     const void *typeDataPtr() const { return (void *)&data; }
@@ -141,7 +141,7 @@ void Register::cleanup()
         } else if (dataType == QUrlType) {
             geturlptr()->~QUrl();
         } else if (dataType == QColorType) {
-            getcolorptr()->~QColor();
+            QQml_valueTypeProvider()->destroyValueType(QMetaType::QColor, typeDataPtr(), dataSize());
         } else if (dataType == QVariantType) {
             getvariantptr()->~QVariant();
         }
@@ -163,7 +163,7 @@ void Register::cleanupUrl()
 
 void Register::cleanupColor()
 {
-    getcolorptr()->~QColor();
+    QQml_valueTypeProvider()->destroyValueType(QMetaType::QColor, typeDataPtr(), dataSize());
     setUndefined();
 }
 
@@ -182,7 +182,7 @@ void Register::copy(const Register &other)
         else if (other.dataType == QUrlType)
             new (geturlptr()) QUrl(*other.geturlptr());
         else if (other.dataType == QColorType)
-            new (getcolorptr()) QColor(*other.getcolorptr());
+            QQml_valueTypeProvider()->copyValueType(QMetaType::QColor, other.typeDataPtr(), typeDataPtr(), dataSize());
         else if (other.dataType == QVariantType)
             new (getvariantptr()) QVariant(*other.getvariantptr());
     } 
@@ -197,7 +197,7 @@ void Register::init(Type type)
         else if (dataType == QUrlType)
             new (geturlptr()) QUrl();
         else if (dataType == QColorType)
-            new (getcolorptr()) QColor();
+            QQml_valueTypeProvider()->initValueType(QMetaType::QColor, typeDataPtr(), dataSize());
         else if (dataType == QVariantType)
             new (getvariantptr()) QVariant();
     }
@@ -1081,8 +1081,7 @@ void QV4Bindings::run(int instrIndex, quint32 &executedBlocks,
                 output.cleanupString();
                 MARK_CLEAN_REGISTER(instr->unaryop.output);
             }
-            QColor *colorPtr = output.getcolorptr();
-            new (colorPtr) QColor(QQmlStringConverters::colorFromString(tmp));
+            QQml_valueTypeProvider()->createValueFromString(QMetaType::QColor, tmp, output.typeDataPtr(), output.dataSize());
 
             COLOR_REGISTER(instr->unaryop.output);
         }
@@ -1148,13 +1147,7 @@ void QV4Bindings::run(int instrIndex, quint32 &executedBlocks,
         if (src.isUndefined()) {
             output.setUndefined();
         } else {
-            const QColor tmp(*src.getcolorptr());
-            if (instr->unaryop.src == instr->unaryop.output) {
-                output.cleanupColor();
-                MARK_CLEAN_REGISTER(instr->unaryop.output);
-            }
-            // to maintain behaviour with QtQuick 1.0, we just output normal toString() value.
-            new (output.getstringptr()) QString(QVariant(tmp).toString());
+            QQml_valueTypeProvider()->createStringFromValue(QMetaType::QColor, src.typeDataPtr(), output.getstringptr());
             STRING_REGISTER(instr->unaryop.output);
         }
     }
diff --git a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
index 68c62ef240..0cd5d0ad6c 100644
--- a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
+++ b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
@@ -51,6 +51,7 @@
 
 #include <private/qv8profilerservice_p.h>
 #include <private/qqmlprofilerservice_p.h>
+#include <private/qqmlglobal_p.h>
 
 #include <QtCore/qstring.h>
 #include <QtCore/qdatetime.h>
@@ -62,12 +63,6 @@
 #include <QtCore/qfile.h>
 #include <QtCore/qcoreapplication.h>
 
-#include <QtGui/qcolor.h>
-#include <QtGui/qvector3d.h>
-#include <QtGui/qvector4d.h>
-#include <QtGui/qdesktopservices.h>
-#include <QtGui/qfontdatabase.h>
-
 QT_BEGIN_NAMESPACE
 
 namespace QQmlBuiltinFunctions {
@@ -417,7 +412,7 @@ v8::Handle<v8::Value> rgba(const v8::Arguments &args)
     if (a < 0.0) a=0.0;
     if (a > 1.0) a=1.0;
 
-    return V8ENGINE()->fromVariant(QVariant::fromValue(QColor::fromRgbF(r, g, b, a)));
+    return V8ENGINE()->fromVariant(QQml_colorProvider()->fromRgbF(r, g, b, a));
 }
 
 /*!
@@ -446,7 +441,7 @@ v8::Handle<v8::Value> hsla(const v8::Arguments &args)
     if (a < 0.0) a=0.0;
     if (a > 1.0) a=1.0;
 
-    return V8ENGINE()->fromVariant(QVariant::fromValue(QColor::fromHslF(h, s, l, a)));
+    return V8ENGINE()->fromVariant(QQml_colorProvider()->fromHslF(h, s, l, a));
 }
 
 /*!
@@ -508,11 +503,13 @@ v8::Handle<v8::Value> vector3d(const v8::Arguments &args)
     if (args.Length() != 3)
         V8THROW_ERROR("Qt.vector(): Invalid arguments");
 
-    double x = args[0]->ToNumber()->Value();
-    double y = args[1]->ToNumber()->Value();
-    double z = args[2]->ToNumber()->Value();
+    float xyz[3];
+    xyz[0] = args[0]->ToNumber()->Value();
+    xyz[1] = args[1]->ToNumber()->Value();
+    xyz[2] = args[2]->ToNumber()->Value();
 
-    return V8ENGINE()->fromVariant(QVariant::fromValue(QVector3D(x, y, z)));
+    const void *params[] = { xyz };
+    return V8ENGINE()->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QVector3D, 1, params));
 }
 
 /*!
@@ -524,12 +521,14 @@ v8::Handle<v8::Value> vector4d(const v8::Arguments &args)
     if (args.Length() != 4)
         V8THROW_ERROR("Qt.vector4d(): Invalid arguments");
 
-    double x = args[0]->NumberValue();
-    double y = args[1]->NumberValue();
-    double z = args[2]->NumberValue();
-    double w = args[3]->NumberValue();
+    float xyzw[4];
+    xyzw[0] = args[0]->ToNumber()->Value();
+    xyzw[1] = args[1]->ToNumber()->Value();
+    xyzw[2] = args[2]->ToNumber()->Value();
+    xyzw[3] = args[3]->ToNumber()->Value();
 
-    return V8ENGINE()->fromVariant(QVariant::fromValue(QVector4D(x, y, z, w)));
+    const void *params[] = { xyzw };
+    return V8ENGINE()->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QVector4D, 1, params));
 }
 
 /*!
@@ -551,17 +550,14 @@ v8::Handle<v8::Value> lighter(const v8::Arguments &args)
     if (args.Length() != 1 && args.Length() != 2)
         V8THROW_ERROR("Qt.lighter(): Invalid arguments");
 
-    QColor color;
     QVariant v = V8ENGINE()->toVariant(args[0], -1);
-    if (v.userType() == QVariant::Color) {
-        color = v.value<QColor>();
-    } else if (v.userType() == QVariant::String) {
+    if (v.userType() == QVariant::String) {
         bool ok = false;
-        color = QQmlStringConverters::colorFromString(v.toString(), &ok);
+        v = QQmlStringConverters::colorFromString(v.toString(), &ok);
         if (!ok) {
             return v8::Null();
         }
-    } else {
+    } else if (v.userType() != QVariant::Color) {
         return v8::Null();
     }
 
@@ -569,8 +565,7 @@ v8::Handle<v8::Value> lighter(const v8::Arguments &args)
     if (args.Length() == 2)
         factor = args[1]->ToNumber()->Value();
 
-    color = color.lighter(int(qRound(factor*100.)));
-    return V8ENGINE()->fromVariant(QVariant::fromValue(color));
+    return V8ENGINE()->fromVariant(QQml_colorProvider()->lighter(v, factor));
 }
 
 /*!
@@ -593,17 +588,14 @@ v8::Handle<v8::Value> darker(const v8::Arguments &args)
     if (args.Length() != 1 && args.Length() != 2)
         V8THROW_ERROR("Qt.darker(): Invalid arguments");
 
-    QColor color;
     QVariant v = V8ENGINE()->toVariant(args[0], -1);
-    if (v.userType() == QVariant::Color) {
-        color = v.value<QColor>();
-    } else if (v.userType() == QVariant::String) {
+    if (v.userType() == QVariant::String) {
         bool ok = false;
-        color = QQmlStringConverters::colorFromString(v.toString(), &ok);
+        v = QQmlStringConverters::colorFromString(v.toString(), &ok);
         if (!ok) {
             return v8::Null();
         }
-    } else {
+    } else if (v.userType() != QVariant::Color) {
         return v8::Null();
     }
 
@@ -611,8 +603,7 @@ v8::Handle<v8::Value> darker(const v8::Arguments &args)
     if (args.Length() == 2)
         factor = args[1]->ToNumber()->Value();
 
-    color = color.darker(int(qRound(factor*100.)));
-    return V8ENGINE()->fromVariant(QVariant::fromValue(color));
+    return V8ENGINE()->fromVariant(QQml_colorProvider()->darker(v, factor));
 }
 
 /*!
@@ -645,53 +636,30 @@ v8::Handle<v8::Value> tint(const v8::Arguments &args)
         V8THROW_ERROR("Qt.tint(): Invalid arguments");
 
     // base color
-    QColor color;
-    QVariant v = V8ENGINE()->toVariant(args[0], -1);
-    if (v.userType() == QVariant::Color) {
-        color = v.value<QColor>();
-    } else if (v.userType() == QVariant::String) {
+    QVariant v1 = V8ENGINE()->toVariant(args[0], -1);
+    if (v1.userType() == QVariant::String) {
         bool ok = false;
-        color = QQmlStringConverters::colorFromString(v.toString(), &ok);
+        v1 = QQmlStringConverters::colorFromString(v1.toString(), &ok);
         if (!ok) {
             return v8::Null();
         }
-    } else {
+    } else if (v1.userType() != QVariant::Color) {
         return v8::Null();
     }
 
     // tint color
-    QColor tintColor;
-    v = V8ENGINE()->toVariant(args[1], -1);
-    if (v.userType() == QVariant::Color) {
-        tintColor = v.value<QColor>();
-    } else if (v.userType() == QVariant::String) {
+    QVariant v2 = V8ENGINE()->toVariant(args[1], -1);
+    if (v2.userType() == QVariant::String) {
         bool ok = false;
-        tintColor = QQmlStringConverters::colorFromString(v.toString(), &ok);
+        v2 = QQmlStringConverters::colorFromString(v2.toString(), &ok);
         if (!ok) {
             return v8::Null();
         }
-    } else {
+    } else if (v2.userType() != QVariant::Color) {
         return v8::Null();
     }
 
-    // tint the base color and return the final color
-    QColor finalColor;
-    int a = tintColor.alpha();
-    if (a == 0xFF)
-        finalColor = tintColor;
-    else if (a == 0x00)
-        finalColor = color;
-    else {
-        qreal a = tintColor.alphaF();
-        qreal inv_a = 1.0 - a;
-
-        finalColor.setRgbF(tintColor.redF() * a + color.redF() * inv_a,
-                           tintColor.greenF() * a + color.greenF() * inv_a,
-                           tintColor.blueF() * a + color.blueF() * inv_a,
-                           a + inv_a * color.alphaF());
-    }
-
-    return V8ENGINE()->fromVariant(QVariant::fromValue(finalColor));
+    return V8ENGINE()->fromVariant(QQml_colorProvider()->tint(v1, v2));
 }
 
 /*!
@@ -908,11 +876,8 @@ v8::Handle<v8::Value> openUrlExternally(const v8::Arguments &args)
     if (args.Length() != 1)
         return V8ENGINE()->fromVariant(false);
 
-    bool ret = false;
-#ifndef QT_NO_DESKTOPSERVICES
-    ret = QDesktopServices::openUrl(V8ENGINE()->toVariant(resolvedUrl(args), -1).toUrl());
-#endif
-    return V8ENGINE()->fromVariant(ret);
+    QUrl url(V8ENGINE()->toVariant(resolvedUrl(args), -1).toUrl());
+    return V8ENGINE()->fromVariant(QQml_guiProvider()->openUrlExternally(url));
 }
 
 /*!
@@ -945,8 +910,7 @@ v8::Handle<v8::Value> fontFamilies(const v8::Arguments &args)
     if (args.Length() != 0)
         V8THROW_ERROR("Qt.fontFamilies(): Invalid arguments");
 
-    QFontDatabase database;
-    return V8ENGINE()->fromVariant(database.families());
+    return V8ENGINE()->fromVariant(QVariant(QQml_guiProvider()->fontFamilies()));
 }
 
 /*!
diff --git a/src/qml/qml/v8/qv8engine.cpp b/src/qml/qml/v8/qv8engine.cpp
index ab3283f727..f0df025541 100644
--- a/src/qml/qml/v8/qv8engine.cpp
+++ b/src/qml/qml/v8/qv8engine.cpp
@@ -41,8 +41,6 @@
 
 #include "qv8engine_p.h"
 
-#include <QtGui/QGuiApplication>
-
 #include "qv8contextwrapper_p.h"
 #include "qv8valuetypewrapper_p.h"
 #include "qv8sequencewrapper_p.h"
@@ -53,9 +51,9 @@
 #include <private/qqmlbuiltinfunctions_p.h>
 #include <private/qqmllist_p.h>
 #include <private/qqmlengine_p.h>
-#include <private/qquickapplication_p.h>
 #include <private/qqmlxmlhttprequest_p.h>
 #include <private/qqmllocale_p.h>
+#include <private/qqmlglobal_p.h>
 
 #include "qscript_impl_p.h"
 #include "qv8domerrors_p.h"
@@ -125,6 +123,7 @@ QV8Engine::QV8Engine(QJSEngine* qq, QJSEngine::ContextOwnership ownership)
     , m_ownsV8Context(ownership == QJSEngine::CreateNewContext)
     , m_xmlHttpRequestData(0)
     , m_listModelData(0)
+    , m_application(0)
 {
     qMetaTypeId<QJSValue>();
     qMetaTypeId<QList<int> >();
@@ -538,9 +537,6 @@ QVariant QV8Engine::toBasicVariant(v8::Handle<v8::Value> value)
 
 
 
-#include <QtGui/qvector3d.h>
-#include <QtGui/qvector4d.h>
-
 struct StaticQtMetaObject : public QObject
 {
     static const QMetaObject *get()
@@ -606,8 +602,8 @@ void QV8Engine::initializeGlobal(v8::Handle<v8::Object> global)
     qt->Set(v8::String::New("binding"), V8FUNCTION(binding, this));
 
     if (m_engine) {
-        qt->Set(v8::String::New("application"), newQObject(new QQuickApplication(m_engine)));
-        qt->Set(v8::String::New("inputMethod"), newQObject(qGuiApp->inputMethod(), CppOwnership));
+        qt->SetAccessor(v8::String::New("application"), getApplication, 0, v8::External::New(this));
+        qt->SetAccessor(v8::String::New("inputMethod"), getInputMethod, 0, v8::External::New(this));
         qt->Set(v8::String::New("lighter"), V8FUNCTION(lighter, this));
         qt->Set(v8::String::New("darker"), V8FUNCTION(darker, this));
         qt->Set(v8::String::New("tint"), V8FUNCTION(tint, this));
@@ -1528,6 +1524,22 @@ int QV8Engine::consoleCountHelper(const QString &file, int line, int column)
     return number;
 }
 
+v8::Handle<v8::Value> QV8Engine::getApplication(v8::Local<v8::String>, const v8::AccessorInfo &info)
+{
+    QV8Engine *engine = reinterpret_cast<QV8Engine*>(v8::External::Unwrap(info.Data()));
+    if (!engine->m_application) {
+        // Only allocate an application object once
+        engine->m_application = QQml_guiProvider()->application(engine->m_engine);
+    }
+    return engine->newQObject(engine->m_application);
+}
+
+v8::Handle<v8::Value> QV8Engine::getInputMethod(v8::Local<v8::String>, const v8::AccessorInfo &info)
+{
+    QV8Engine *engine = reinterpret_cast<QV8Engine*>(v8::External::Unwrap(info.Data()));
+    return engine->newQObject(QQml_guiProvider()->inputMethod(), CppOwnership);
+}
+
 void QV8GCCallback::registerGcPrologueCallback()
 {
     QV8Engine::ThreadData *td = QV8Engine::threadData();
diff --git a/src/qml/qml/v8/qv8engine_p.h b/src/qml/qml/v8/qv8engine_p.h
index 825d7a3583..2eb3668501 100644
--- a/src/qml/qml/v8/qv8engine_p.h
+++ b/src/qml/qml/v8/qv8engine_p.h
@@ -443,6 +443,9 @@ public:
     void addRelationshipForGC(QObject *object, v8::Persistent<v8::Value> handle);
     void addRelationshipForGC(QObject *object, QObject *other);
 
+    static v8::Handle<v8::Value> getApplication(v8::Local<v8::String> property, const v8::AccessorInfo &info);
+    static v8::Handle<v8::Value> getInputMethod(v8::Local<v8::String> property, const v8::AccessorInfo &info);
+
     struct ThreadData {
         ThreadData();
         ~ThreadData();
@@ -492,6 +495,8 @@ protected:
 
     QHash<QString, quint32> m_consoleCount;
 
+    QObject *m_application;
+
     QVariant toBasicVariant(v8::Handle<v8::Value>);
 
     void initializeGlobal(v8::Handle<v8::Object>);
diff --git a/src/quick/qtquick2.cpp b/src/quick/qtquick2.cpp
index a97dade106..16cf2198a2 100644
--- a/src/quick/qtquick2.cpp
+++ b/src/quick/qtquick2.cpp
@@ -42,10 +42,11 @@
 #include "qtquick2_p.h"
 #include <private/qqmlengine_p.h>
 #include <private/qquickutilmodule_p.h>
-#include <private/qqmlvaluetype_p.h>
+#include <private/qquickvaluetypes_p.h>
 #include <private/qquickitemsmodule_p.h>
 #include <private/qquickparticlesmodule_p.h>
 #include <private/qquickwindowmodule_p.h>
+#include <private/qquickapplication_p.h>
 
 #include <private/qqmlenginedebugservice_p.h>
 #include <private/qqmldebugstatesdelegate_p.h>
@@ -177,7 +178,10 @@ void QQmlQtQuick2Module::defineModule()
     QQuickItemsModule::defineModule();
     QQuickParticlesModule::defineModule();
     QQuickWindowModule::defineModule();
-    QQmlValueTypeFactory::registerValueTypes();
+
+    qmlRegisterUncreatableType<QQuickApplication>("QtQuick",2,0,"Application", QQuickApplication::tr("Application is an abstract class"));
+
+    QQuickValueTypes::registerValueTypes();
 
     if (QQmlEngineDebugService::isDebuggingEnabled()) {
         QQmlEngineDebugService::instance()->setStatesDelegate(
diff --git a/src/quick/util/qquickanimation.cpp b/src/quick/util/qquickanimation.cpp
index 33a5d0a438..fc1e6ec89f 100644
--- a/src/quick/util/qquickanimation.cpp
+++ b/src/quick/util/qquickanimation.cpp
@@ -1755,38 +1755,19 @@ void QQuickPropertyAnimationPrivate::convertVariant(QVariant &variant, int type)
     }
 
     switch (type) {
-    case QVariant::Rect: {
-        variant.setValue(QQmlStringConverters::rectFFromString(variant.toString()).toRect());
-        break;
-    }
-    case QVariant::RectF: {
-        variant.setValue(QQmlStringConverters::rectFFromString(variant.toString()));
-        break;
-    }
-    case QVariant::Point: {
-        variant.setValue(QQmlStringConverters::pointFFromString(variant.toString()).toPoint());
-        break;
-    }
-    case QVariant::PointF: {
-        variant.setValue(QQmlStringConverters::pointFFromString(variant.toString()));
-        break;
-    }
-    case QVariant::Size: {
-        variant.setValue(QQmlStringConverters::sizeFFromString(variant.toString()).toSize());
-        break;
-    }
-    case QVariant::SizeF: {
-        variant.setValue(QQmlStringConverters::sizeFFromString(variant.toString()));
-        break;
-    }
-    case QVariant::Color: {
-        variant.setValue(QQmlStringConverters::colorFromString(variant.toString()));
-        break;
-    }
-    case QVariant::Vector3D: {
-        variant.setValue(QQmlStringConverters::vector3DFromString(variant.toString()));
+    case QVariant::Rect:
+    case QVariant::RectF:
+    case QVariant::Point:
+    case QVariant::PointF:
+    case QVariant::Size:
+    case QVariant::SizeF:
+    case QVariant::Color:
+    case QVariant::Vector3D:
+        {
+        bool ok = false;
+        variant = QQmlStringConverters::variantFromString(variant.toString(), type, &ok);
+        }
         break;
-    }
     default:
         if (QQmlValueTypeFactory::isValueType((uint)type)) {
             variant.convert((QVariant::Type)type);
diff --git a/src/qml/qml/qquickapplication.cpp b/src/quick/util/qquickapplication.cpp
index 198a917cb8..55ebb11d29 100644
--- a/src/qml/qml/qquickapplication.cpp
+++ b/src/quick/util/qquickapplication.cpp
@@ -3,7 +3,7 @@
 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
 ** Contact: http://www.qt-project.org/
 **
-** This file is part of the QtQml module of the Qt Toolkit.
+** This file is part of the QtQuick module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** GNU Lesser General Public License Usage
@@ -40,9 +40,9 @@
 ****************************************************************************/
 
 #include "qquickapplication_p.h"
+
 #include <private/qobject_p.h>
 #include <QtGui/QGuiApplication>
-#include <QtGui/QInputMethod>
 #include <QtCore/QDebug>
 
 QT_BEGIN_NAMESPACE
@@ -51,21 +51,28 @@ class QQuickApplicationPrivate : public QObjectPrivate
 {
     Q_DECLARE_PUBLIC(QQuickApplication)
 public:
-    QQuickApplicationPrivate() : active(QGuiApplication::activeWindow() != 0),
-    layoutDirection(QGuiApplication::layoutDirection()) {}
-    bool active;
-    Qt::LayoutDirection layoutDirection;
+    QQuickApplicationPrivate()
+        : isActive(QGuiApplication::focusWindow() != 0),
+          direction(QGuiApplication::layoutDirection())
+    {
+    }
+
+private:
+    bool isActive;
+    Qt::LayoutDirection direction;
 };
 
 /*
     This object and its properties are documented as part of the Qt object,
-    in qdeclarativengine.cpp
+    in qqmlengine.cpp
 */
 
-QQuickApplication::QQuickApplication(QObject *parent) : QObject(*new QQuickApplicationPrivate(), parent)
+QQuickApplication::QQuickApplication(QObject *parent)
+    : QObject(*new QQuickApplicationPrivate(), parent)
 {
-    if (qApp)
+    if (qApp) {
         qApp->installEventFilter(this);
+    }
 }
 
 QQuickApplication::~QQuickApplication()
@@ -75,13 +82,13 @@ QQuickApplication::~QQuickApplication()
 bool QQuickApplication::active() const
 {
     Q_D(const QQuickApplication);
-    return d->active;
+    return d->isActive;
 }
 
 Qt::LayoutDirection QQuickApplication::layoutDirection() const
 {
     Q_D(const QQuickApplication);
-    return d->layoutDirection;
+    return d->direction;
 }
 
 QObject *QQuickApplication::inputPanel() const
@@ -91,30 +98,23 @@ QObject *QQuickApplication::inputPanel() const
         qWarning() << "Qt.application.inputPanel is deprecated, use Qt.inputMethod instead";
         warned = true;
     }
-    return qApp ? qApp->inputMethod() : 0;
+    return qGuiApp->inputMethod();
 }
 
-bool QQuickApplication::eventFilter(QObject *obj, QEvent *event)
+bool QQuickApplication::eventFilter(QObject *, QEvent *event)
 {
-    Q_UNUSED(obj)
     Q_D(QQuickApplication);
-    if (event->type() == QEvent::ApplicationActivate
-     || event->type() == QEvent::ApplicationDeactivate) {
-        bool active = d->active;
-        if (event->type() == QEvent::ApplicationActivate)
-            active  = true;
-        else if (event->type() == QEvent::ApplicationDeactivate)
-            active  = false;
-
-        if (d->active != active) {
-            d->active = active;
+    if ((event->type() == QEvent::ApplicationActivate) ||
+        (event->type() == QEvent::ApplicationDeactivate)) {
+        bool wasActive = d->isActive;
+        d->isActive = (event->type() == QEvent::ApplicationActivate);
+        if (d->isActive != wasActive) {
             emit activeChanged();
         }
-    }
-    if (event->type() == QEvent::LayoutDirectionChange) {
-        Qt::LayoutDirection direction = QGuiApplication::layoutDirection();
-        if (d->layoutDirection != direction) {
-            d->layoutDirection = direction;
+    } else if (event->type() == QEvent::LayoutDirectionChange) {
+        Qt::LayoutDirection newDirection = QGuiApplication::layoutDirection();
+        if (d->direction != newDirection) {
+            d->direction = newDirection;
             emit layoutDirectionChanged();
         }
     }
diff --git a/src/qml/qml/qquickapplication_p.h b/src/quick/util/qquickapplication_p.h
index 66198948ac..e8a3cd58ca 100644
--- a/src/qml/qml/qquickapplication_p.h
+++ b/src/quick/util/qquickapplication_p.h
@@ -3,7 +3,7 @@
 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
 ** Contact: http://www.qt-project.org/
 **
-** This file is part of the QtQml module of the Qt Toolkit.
+** This file is part of the QtQuick module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** GNU Lesser General Public License Usage
@@ -44,7 +44,7 @@
 
 #include <QtCore/QObject>
 #include <qqml.h>
-#include <private/qtqmlglobal_p.h>
+#include <private/qtquickglobal_p.h>
 
 QT_BEGIN_HEADER
 
@@ -52,7 +52,7 @@ QT_BEGIN_NAMESPACE
 
 
 class QQuickApplicationPrivate;
-class Q_QML_PRIVATE_EXPORT QQuickApplication : public QObject
+class Q_QUICK_PRIVATE_EXPORT QQuickApplication : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(bool active READ active NOTIFY activeChanged)
@@ -66,14 +66,13 @@ public:
     Qt::LayoutDirection layoutDirection() const;
     QT_DEPRECATED QObject *inputPanel() const;
 
-protected:
-    bool eventFilter(QObject *obj, QEvent *event);
-
 Q_SIGNALS:
     void activeChanged();
     void layoutDirectionChanged();
 
 private:
+    bool eventFilter(QObject *, QEvent *event);
+
     Q_DISABLE_COPY(QQuickApplication)
     Q_DECLARE_PRIVATE(QQuickApplication)
 };
diff --git a/src/quick/util/qquickglobal.cpp b/src/quick/util/qquickglobal.cpp
new file mode 100644
index 0000000000..b99cb7a1d4
--- /dev/null
+++ b/src/quick/util/qquickglobal.cpp
@@ -0,0 +1,530 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qquickvaluetypes_p.h>
+#include <private/qquickapplication_p.h>
+#include <private/qqmlglobal_p.h>
+
+#include <QtGui/QGuiApplication>
+#include <QtGui/qdesktopservices.h>
+#include <QtGui/qfontdatabase.h>
+
+
+QT_BEGIN_NAMESPACE
+
+class QQuickColorProvider : public QQmlColorProvider
+{
+public:
+    static inline QColor QColorFromString(const QString &s)
+    {
+        // Should we also handle #rrggbb here?
+        if (s.length() == 9 && s.startsWith(QLatin1Char('#'))) {
+            uchar a = fromHex(s, 1);
+            uchar r = fromHex(s, 3);
+            uchar g = fromHex(s, 5);
+            uchar b = fromHex(s, 7);
+            return QColor(r, g, b, a);
+        }
+
+        return QColor(s);
+    }
+
+    QVariant colorFromString(const QString &s, bool *ok)
+    {
+        QColor c(QColorFromString(s));
+        if (c.isValid()) {
+            if (ok) *ok = true;
+            return QVariant(c);
+        }
+
+        if (ok) *ok = false;
+        return QVariant();
+    }
+
+    unsigned rgbaFromString(const QString &s, bool *ok)
+    {
+        QColor c(QColorFromString(s));
+        if (c.isValid()) {
+            if (ok) *ok = true;
+            return c.rgba();
+        }
+
+        if (ok) *ok = false;
+        return 0;
+    }
+
+    QString stringFromRgba(unsigned rgba)
+    {
+        QColor c(QColor::fromRgba(rgba));
+        if (c.isValid()) {
+            return QVariant(c).toString();
+        }
+
+        return QString();
+    }
+
+    QVariant fromRgbF(double r, double g, double b, double a)
+    {
+        return QVariant(QColor::fromRgbF(r, g, b, a));
+    }
+
+    QVariant fromHslF(double h, double s, double l, double a)
+    {
+        return QVariant(QColor::fromHslF(h, s, l, a));
+    }
+
+    QVariant lighter(const QVariant &var, qreal factor)
+    {
+        QColor color = var.value<QColor>();
+        color = color.lighter(int(qRound(factor*100.)));
+        return QVariant::fromValue(color);
+    }
+
+    QVariant darker(const QVariant &var, qreal factor)
+    {
+        QColor color = var.value<QColor>();
+        color = color.darker(int(qRound(factor*100.)));
+        return QVariant::fromValue(color);
+    }
+
+    QVariant tint(const QVariant &baseVar, const QVariant &tintVar)
+    {
+        QColor tintColor = tintVar.value<QColor>();
+
+        int tintAlpha = tintColor.alpha();
+        if (tintAlpha == 0xFF) {
+            return tintVar;
+        } else if (tintAlpha == 0x00) {
+            return baseVar;
+        }
+
+        // tint the base color and return the final color
+        QColor baseColor = baseVar.value<QColor>();
+        qreal a = tintColor.alphaF();
+        qreal inv_a = 1.0 - a;
+
+        qreal r = tintColor.redF() * a + baseColor.redF() * inv_a;
+        qreal g = tintColor.greenF() * a + baseColor.greenF() * inv_a;
+        qreal b = tintColor.blueF() * a + baseColor.blueF() * inv_a;
+
+        return QVariant::fromValue(QColor::fromRgbF(r, g, b, a + inv_a * baseColor.alphaF()));
+    }
+
+private:
+    static uchar fromHex(const uchar c, const uchar c2)
+    {
+        uchar rv = 0;
+        if (c >= '0' && c <= '9')
+            rv += (c - '0') * 16;
+        else if (c >= 'A' && c <= 'F')
+            rv += (c - 'A' + 10) * 16;
+        else if (c >= 'a' && c <= 'f')
+            rv += (c - 'a' + 10) * 16;
+
+        if (c2 >= '0' && c2 <= '9')
+            rv += (c2 - '0');
+        else if (c2 >= 'A' && c2 <= 'F')
+            rv += (c2 - 'A' + 10);
+        else if (c2 >= 'a' && c2 <= 'f')
+            rv += (c2 - 'a' + 10);
+
+        return rv;
+    }
+
+    static inline uchar fromHex(const QString &s, int idx)
+    {
+        uchar c = s.at(idx).toAscii();
+        uchar c2 = s.at(idx + 1).toAscii();
+        return fromHex(c, c2);
+    }
+};
+
+
+class QQuickValueTypeProvider : public QQmlValueTypeProvider
+{
+public:
+    static QVector3D vector3DFromString(const QString &s, bool *ok)
+    {
+        if (s.count(QLatin1Char(',')) == 2) {
+            int index = s.indexOf(QLatin1Char(','));
+            int index2 = s.indexOf(QLatin1Char(','), index+1);
+
+            bool xGood, yGood, zGood;
+            qreal xCoord = s.left(index).toDouble(&xGood);
+            qreal yCoord = s.mid(index+1, index2-index-1).toDouble(&yGood);
+            qreal zCoord = s.mid(index2+1).toDouble(&zGood);
+
+            if (xGood && yGood && zGood) {
+                if (ok) *ok = true;
+                return QVector3D(xCoord, yCoord, zCoord);
+            }
+        }
+
+        if (ok) *ok = false;
+        return QVector3D();
+    }
+
+    static QVector4D vector4DFromString(const QString &s, bool *ok)
+    {
+        if (s.count(QLatin1Char(',')) == 3) {
+            int index = s.indexOf(QLatin1Char(','));
+            int index2 = s.indexOf(QLatin1Char(','), index+1);
+            int index3 = s.indexOf(QLatin1Char(','), index2+1);
+
+            bool xGood, yGood, zGood, wGood;
+            qreal xCoord = s.left(index).toDouble(&xGood);
+            qreal yCoord = s.mid(index+1, index2-index-1).toDouble(&yGood);
+            qreal zCoord = s.mid(index2+1, index3-index2-1).toDouble(&zGood);
+            qreal wCoord = s.mid(index3+1).toDouble(&wGood);
+
+            if (xGood && yGood && zGood && wGood) {
+                if (ok) *ok = true;
+                return QVector4D(xCoord, yCoord, zCoord, wCoord);
+            }
+        }
+
+        if (ok) *ok = false;
+        return QVector4D();
+    }
+
+    bool create(int type, QQmlValueType *&v)
+    {
+        switch (type) {
+        case QMetaType::QColor:
+            v = new QQuickColorValueType;
+            return true;
+        case QMetaType::QVector2D:
+            v = new QQuickVector2DValueType;
+            return true;
+        case QMetaType::QVector3D:
+            v = new QQuickVector3DValueType;
+            return true;
+        case QMetaType::QVector4D:
+            v = new QQuickVector4DValueType;
+            return true;
+        case QMetaType::QQuaternion:
+            v = new QQuickQuaternionValueType;
+            return true;
+        case QMetaType::QMatrix4x4:
+            v = new QQuickMatrix4x4ValueType;
+            return true;
+        case QMetaType::QFont:
+            v = new QQuickFontValueType;
+            return true;
+        default:
+            return false;
+        }
+    }
+
+    bool init(int type, void *data, size_t n)
+    {
+        if (type == QMetaType::QColor) {
+            Q_ASSERT(n >= sizeof(QColor));
+            QColor *color = reinterpret_cast<QColor *>(data);
+            new (color) QColor();
+            return true;
+        }
+
+        return false;
+    }
+
+    bool destroy(int type, void *data, size_t n)
+    {
+        if (type == QMetaType::QColor) {
+            Q_ASSERT(n >= sizeof(QColor));
+            QColor *color = reinterpret_cast<QColor *>(data);
+            color->~QColor();
+            return true;
+        }
+
+        return false;
+    }
+
+    bool copy(int type, const void *src, void *dst, size_t n)
+    {
+        if (type == QMetaType::QColor) {
+            Q_ASSERT(n >= sizeof(QColor));
+            const QColor *srcColor = reinterpret_cast<const QColor *>(src);
+            QColor *dstColor = reinterpret_cast<QColor *>(dst);
+            new (dstColor) QColor(*srcColor);
+            return true;
+        }
+
+        return false;
+    }
+
+    bool create(int type, int argc, const void *argv[], QVariant *v)
+    {
+        switch (type) {
+        case QMetaType::QVector3D:
+            if (argc == 1) {
+                const float *xyz = reinterpret_cast<const float*>(argv[0]);
+                QVector3D v3(xyz[0], xyz[1], xyz[2]);
+                *v = QVariant(v3);
+                return true;
+            }
+            break;
+        case QMetaType::QVector4D:
+            if (argc == 1) {
+                const float *xyzw = reinterpret_cast<const float*>(argv[0]);
+                QVector4D v4(xyzw[0], xyzw[1], xyzw[2], xyzw[3]);
+                *v = QVariant(v4);
+                return true;
+            }
+            break;
+        }
+
+        return false;
+    }
+
+    bool createFromString(int type, const QString &s, void *data, size_t n)
+    {
+        bool ok = false;
+
+        switch (type) {
+        case QMetaType::QColor:
+            {
+            Q_ASSERT(n >= sizeof(QColor));
+            QColor *color = reinterpret_cast<QColor *>(data);
+            new (color) QColor(QQuickColorProvider::QColorFromString(s));
+            return true;
+            }
+        case QMetaType::QVector3D:
+            {
+            Q_ASSERT(n >= sizeof(QVector3D));
+            QVector3D *v3 = reinterpret_cast<QVector3D *>(data);
+            new (v3) QVector3D(vector3DFromString(s, &ok));
+            return true;
+            }
+        case QMetaType::QVector4D:
+            {
+            Q_ASSERT(n >= sizeof(QVector4D));
+            QVector4D *v4 = reinterpret_cast<QVector4D *>(data);
+            new (v4) QVector4D(vector4DFromString(s, &ok));
+            return true;
+            }
+        }
+
+        return false;
+    }
+
+    bool createStringFrom(int type, const void *data, QString *s)
+    {
+        if (type == QMetaType::QColor) {
+            const QColor *color = reinterpret_cast<const QColor *>(data);
+            new (s) QString(QVariant(*color).toString());
+            return true;
+        }
+
+        return false;
+    }
+
+    bool variantFromString(const QString &s, QVariant *v)
+    {
+        QColor c(QQuickColorProvider::QColorFromString(s));
+        if (c.isValid()) {
+            *v = QVariant::fromValue(c);
+            return true;
+        }
+
+        bool ok = false;
+
+        QVector3D v3 = vector3DFromString(s, &ok);
+        if (ok) {
+            *v = QVariant::fromValue(v3);
+            return true;
+        }
+
+        QVector4D v4 = vector4DFromString(s, &ok);
+        if (ok) {
+            *v = QVariant::fromValue(v4);
+            return true;
+        }
+
+        return false;
+    }
+
+    bool variantFromString(int type, const QString &s, QVariant *v)
+    {
+        bool ok = false;
+
+        switch (type) {
+        case QMetaType::QColor:
+            {
+            QColor c(QQuickColorProvider::QColorFromString(s));
+            *v = QVariant::fromValue(c);
+            return true;
+            }
+        case QMetaType::QVector3D:
+            *v = QVariant::fromValue(vector3DFromString(s, &ok));
+            return true;
+        case QMetaType::QVector4D:
+            *v = QVariant::fromValue(vector4DFromString(s, &ok));
+            return true;
+        }
+
+        return false;
+    }
+
+    bool store(int type, const void *src, void *dst, size_t n)
+    {
+        switch (type) {
+        case QMetaType::QColor:
+            {
+            Q_ASSERT(n >= sizeof(QColor));
+            const QRgb *rgb = reinterpret_cast<const QRgb *>(src);
+            QColor *color = reinterpret_cast<QColor *>(dst);
+            new (color) QColor(QColor::fromRgba(*rgb));
+            return true;
+            }
+        case QMetaType::QVector3D:
+            {
+            Q_ASSERT(n >= sizeof(QVector3D));
+            const QVector3D *srcVector = reinterpret_cast<const QVector3D *>(src);
+            QVector3D *dstVector = reinterpret_cast<QVector3D *>(dst);
+            new (dstVector) QVector3D(*srcVector);
+            return true;
+            }
+        case QMetaType::QVector4D:
+            {
+            Q_ASSERT(n >= sizeof(QVector4D));
+            const QVector4D *srcVector = reinterpret_cast<const QVector4D *>(src);
+            QVector4D *dstVector = reinterpret_cast<QVector4D *>(dst);
+            new (dstVector) QVector4D(*srcVector);
+            return true;
+            }
+        }
+
+        return false;
+    }
+
+    bool read(int srcType, const void *src, int dstType, void *dst)
+    {
+        if (dstType == QMetaType::QColor) {
+            QColor *dstColor = reinterpret_cast<QColor *>(dst);
+            if (srcType == QMetaType::QColor) {
+                const QColor *srcColor = reinterpret_cast<const QColor *>(src);
+                *dstColor = *srcColor;
+            } else {
+                *dstColor = QColor();
+            }
+            return true;
+        }
+
+        return false;
+    }
+
+    bool write(int type, const void *src, void *dst, size_t n)
+    {
+        if (type == QMetaType::QColor) {
+            Q_ASSERT(n >= sizeof(QColor));
+            const QColor *srcColor = reinterpret_cast<const QColor *>(src);
+            QColor *dstColor = reinterpret_cast<QColor *>(dst);
+            if (*dstColor != *srcColor) {
+                *dstColor = *srcColor;
+                return true;
+            }
+        }
+
+        return false;
+    }
+};
+
+
+class QQuickGuiProvider : public QQmlGuiProvider
+{
+public:
+    QQuickApplication *application(QObject *parent)
+    {
+        return new QQuickApplication(parent);
+    }
+
+    QInputMethod *inputMethod()
+    {
+        return qGuiApp->inputMethod();
+    }
+
+    QStringList fontFamilies()
+    {
+        QFontDatabase database;
+        return database.families();
+    }
+
+    bool openUrlExternally(QUrl &url)
+    {
+#ifndef QT_NO_DESKTOPSERVICES
+        return QDesktopServices::openUrl(url);
+#else
+        return false;
+#endif
+    }
+};
+
+
+static QQuickValueTypeProvider *getValueTypeProvider()
+{
+    static QQuickValueTypeProvider valueTypeProvider;
+    return &valueTypeProvider;
+}
+
+static QQuickColorProvider *getColorProvider()
+{
+    static QQuickColorProvider colorProvider;
+    return &colorProvider;
+}
+
+static QQuickGuiProvider *getGuiProvider()
+{
+    static QQuickGuiProvider guiProvider;
+    return &guiProvider;
+}
+
+static bool initializeProviders()
+{
+    QQml_addValueTypeProvider(getValueTypeProvider());
+    QQml_setColorProvider(getColorProvider());
+    QQml_setGuiProvider(getGuiProvider());
+    return true;
+}
+
+static bool initialized = initializeProviders();
+
+QT_END_NAMESPACE
diff --git a/src/quick/util/qquickvaluetypes.cpp b/src/quick/util/qquickvaluetypes.cpp
new file mode 100644
index 0000000000..179f840acd
--- /dev/null
+++ b/src/quick/util/qquickvaluetypes.cpp
@@ -0,0 +1,468 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qquickvaluetypes_p.h>
+
+#include <qtquickglobal.h>
+#include <private/qqmlvaluetype_p.h>
+#include <private/qfont_p.h>
+
+
+QT_BEGIN_NAMESPACE
+
+namespace QQuickValueTypes {
+
+void registerValueTypes()
+{
+    QQmlValueTypeFactory::registerValueTypes();
+
+    qmlRegisterValueTypeEnums<QQuickFontValueType>("QtQuick", 2, 0, "Font");
+}
+
+}
+
+QQuickColorValueType::QQuickColorValueType(QObject *parent)
+    : QQmlValueTypeBase<QColor>(parent)
+{
+}
+
+QString QQuickColorValueType::toString() const
+{
+    // to maintain behaviour with QtQuick 1.0, we just output normal toString() value.
+    return QVariant(v).toString();
+}
+
+qreal QQuickColorValueType::r() const
+{
+    return v.redF();
+}
+
+qreal QQuickColorValueType::g() const
+{
+    return v.greenF();
+}
+
+qreal QQuickColorValueType::b() const
+{
+    return v.blueF();
+}
+
+qreal QQuickColorValueType::a() const
+{
+    return v.alphaF();
+}
+
+void QQuickColorValueType::setR(qreal r)
+{
+    v.setRedF(r);
+}
+
+void QQuickColorValueType::setG(qreal g)
+{
+    v.setGreenF(g);
+}
+
+void QQuickColorValueType::setB(qreal b)
+{
+    v.setBlueF(b);
+}
+
+void QQuickColorValueType::setA(qreal a)
+{
+    v.setAlphaF(a);
+}
+
+
+QQuickVector2DValueType::QQuickVector2DValueType(QObject *parent)
+    : QQmlValueTypeBase<QVector2D>(parent)
+{
+}
+
+QString QQuickVector2DValueType::toString() const
+{
+    return QString(QLatin1String("QVector2D(%1, %2)")).arg(v.x()).arg(v.y());
+}
+
+qreal QQuickVector2DValueType::x() const
+{
+    return v.x();
+}
+
+qreal QQuickVector2DValueType::y() const
+{
+    return v.y();
+}
+
+void QQuickVector2DValueType::setX(qreal x)
+{
+    v.setX(x);
+}
+
+void QQuickVector2DValueType::setY(qreal y)
+{
+    v.setY(y);
+}
+
+
+QQuickVector3DValueType::QQuickVector3DValueType(QObject *parent)
+    : QQmlValueTypeBase<QVector3D>(parent)
+{
+}
+
+QString QQuickVector3DValueType::toString() const
+{
+    return QString(QLatin1String("QVector3D(%1, %2, %3)")).arg(v.x()).arg(v.y()).arg(v.z());
+}
+
+qreal QQuickVector3DValueType::x() const
+{
+    return v.x();
+}
+
+qreal QQuickVector3DValueType::y() const
+{
+    return v.y();
+}
+
+qreal QQuickVector3DValueType::z() const
+{
+    return v.z();
+}
+
+void QQuickVector3DValueType::setX(qreal x)
+{
+    v.setX(x);
+}
+
+void QQuickVector3DValueType::setY(qreal y)
+{
+    v.setY(y);
+}
+
+void QQuickVector3DValueType::setZ(qreal z)
+{
+    v.setZ(z);
+}
+
+
+QQuickVector4DValueType::QQuickVector4DValueType(QObject *parent)
+    : QQmlValueTypeBase<QVector4D>(parent)
+{
+}
+
+QString QQuickVector4DValueType::toString() const
+{
+    return QString(QLatin1String("QVector4D(%1, %2, %3, %4)")).arg(v.x()).arg(v.y()).arg(v.z()).arg(v.w());
+}
+
+qreal QQuickVector4DValueType::x() const
+{
+    return v.x();
+}
+
+qreal QQuickVector4DValueType::y() const
+{
+    return v.y();
+}
+
+qreal QQuickVector4DValueType::z() const
+{
+    return v.z();
+}
+
+qreal QQuickVector4DValueType::w() const
+{
+    return v.w();
+}
+
+void QQuickVector4DValueType::setX(qreal x)
+{
+    v.setX(x);
+}
+
+void QQuickVector4DValueType::setY(qreal y)
+{
+    v.setY(y);
+}
+
+void QQuickVector4DValueType::setZ(qreal z)
+{
+    v.setZ(z);
+}
+
+void QQuickVector4DValueType::setW(qreal w)
+{
+    v.setW(w);
+}
+
+
+QQuickQuaternionValueType::QQuickQuaternionValueType(QObject *parent)
+    : QQmlValueTypeBase<QQuaternion>(parent)
+{
+}
+
+QString QQuickQuaternionValueType::toString() const
+{
+    return QString(QLatin1String("QQuaternion(%1, %2, %3, %4)")).arg(v.scalar()).arg(v.x()).arg(v.y()).arg(v.z());
+}
+
+qreal QQuickQuaternionValueType::scalar() const
+{
+    return v.scalar();
+}
+
+qreal QQuickQuaternionValueType::x() const
+{
+    return v.x();
+}
+
+qreal QQuickQuaternionValueType::y() const
+{
+    return v.y();
+}
+
+qreal QQuickQuaternionValueType::z() const
+{
+    return v.z();
+}
+
+void QQuickQuaternionValueType::setScalar(qreal scalar)
+{
+    v.setScalar(scalar);
+}
+
+void QQuickQuaternionValueType::setX(qreal x)
+{
+    v.setX(x);
+}
+
+void QQuickQuaternionValueType::setY(qreal y)
+{
+    v.setY(y);
+}
+
+void QQuickQuaternionValueType::setZ(qreal z)
+{
+    v.setZ(z);
+}
+
+
+QQuickMatrix4x4ValueType::QQuickMatrix4x4ValueType(QObject *parent)
+    : QQmlValueTypeBase<QMatrix4x4>(parent)
+{
+}
+
+QString QQuickMatrix4x4ValueType::toString() const
+{
+    return QString(QLatin1String("QMatrix4x4(%1, %2, %3, %4, %5, %6, %7, %8, %9, %10, %11, %12, %13, %14, %15, %16)"))
+            .arg(v(0, 0)).arg(v(0, 1)).arg(v(0, 2)).arg(v(0, 3))
+            .arg(v(1, 0)).arg(v(1, 1)).arg(v(1, 2)).arg(v(1, 3))
+            .arg(v(2, 0)).arg(v(2, 1)).arg(v(2, 2)).arg(v(2, 3))
+            .arg(v(3, 0)).arg(v(3, 1)).arg(v(3, 2)).arg(v(3, 3));
+}
+
+
+QQuickFontValueType::QQuickFontValueType(QObject *parent)
+    : QQmlValueTypeBase<QFont>(parent),
+      pixelSizeSet(false),
+      pointSizeSet(false)
+{
+}
+
+void QQuickFontValueType::onLoad()
+{
+    pixelSizeSet = false;
+    pointSizeSet = false;
+}
+
+QString QQuickFontValueType::toString() const
+{
+    return QString(QLatin1String("QFont(%1)")).arg(v.toString());
+}
+
+QString QQuickFontValueType::family() const
+{
+    return v.family();
+}
+
+void QQuickFontValueType::setFamily(const QString &family)
+{
+    v.setFamily(family);
+}
+
+bool QQuickFontValueType::bold() const
+{
+    return v.bold();
+}
+
+void QQuickFontValueType::setBold(bool b)
+{
+    v.setBold(b);
+}
+
+QQuickFontValueType::FontWeight QQuickFontValueType::weight() const
+{
+    return (QQuickFontValueType::FontWeight)v.weight();
+}
+
+void QQuickFontValueType::setWeight(QQuickFontValueType::FontWeight w)
+{
+    v.setWeight((QFont::Weight)w);
+}
+
+bool QQuickFontValueType::italic() const
+{
+    return v.italic();
+}
+
+void QQuickFontValueType::setItalic(bool b)
+{
+    v.setItalic(b);
+}
+
+bool QQuickFontValueType::underline() const
+{
+    return v.underline();
+}
+
+void QQuickFontValueType::setUnderline(bool b)
+{
+    v.setUnderline(b);
+}
+
+bool QQuickFontValueType::overline() const
+{
+    return v.overline();
+}
+
+void QQuickFontValueType::setOverline(bool b)
+{
+    v.setOverline(b);
+}
+
+bool QQuickFontValueType::strikeout() const
+{
+    return v.strikeOut();
+}
+
+void QQuickFontValueType::setStrikeout(bool b)
+{
+    v.setStrikeOut(b);
+}
+
+qreal QQuickFontValueType::pointSize() const
+{
+    if (v.pointSizeF() == -1) {
+        if (dpi.isNull)
+            dpi = qt_defaultDpi();
+        return v.pixelSize() * qreal(72.) / qreal(dpi);
+    }
+    return v.pointSizeF();
+}
+
+void QQuickFontValueType::setPointSize(qreal size)
+{
+    if (pixelSizeSet) {
+        qWarning() << "Both point size and pixel size set. Using pixel size.";
+        return;
+    }
+
+    if (size >= 0.0) {
+        pointSizeSet = true;
+        v.setPointSizeF(size);
+    } else {
+        pointSizeSet = false;
+    }
+}
+
+int QQuickFontValueType::pixelSize() const
+{
+    if (v.pixelSize() == -1) {
+        if (dpi.isNull)
+            dpi = qt_defaultDpi();
+        return (v.pointSizeF() * dpi) / qreal(72.);
+    }
+    return v.pixelSize();
+}
+
+void QQuickFontValueType::setPixelSize(int size)
+{
+    if (size >0) {
+        if (pointSizeSet)
+            qWarning() << "Both point size and pixel size set. Using pixel size.";
+        v.setPixelSize(size);
+        pixelSizeSet = true;
+    } else {
+        pixelSizeSet = false;
+    }
+}
+
+QQuickFontValueType::Capitalization QQuickFontValueType::capitalization() const
+{
+    return (QQuickFontValueType::Capitalization)v.capitalization();
+}
+
+void QQuickFontValueType::setCapitalization(QQuickFontValueType::Capitalization c)
+{
+    v.setCapitalization((QFont::Capitalization)c);
+}
+
+qreal QQuickFontValueType::letterSpacing() const
+{
+    return v.letterSpacing();
+}
+
+void QQuickFontValueType::setLetterSpacing(qreal size)
+{
+    v.setLetterSpacing(QFont::AbsoluteSpacing, size);
+}
+
+qreal QQuickFontValueType::wordSpacing() const
+{
+    return v.wordSpacing();
+}
+
+void QQuickFontValueType::setWordSpacing(qreal size)
+{
+    v.setWordSpacing(size);
+}
+
+QT_END_NAMESPACE
diff --git a/src/quick/util/qquickvaluetypes_p.h b/src/quick/util/qquickvaluetypes_p.h
new file mode 100644
index 0000000000..d2767db329
--- /dev/null
+++ b/src/quick/util/qquickvaluetypes_p.h
@@ -0,0 +1,310 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKVALUETYPES_P_H
+#define QQUICKVALUETYPES_P_H
+
+#include <qqml.h>
+#include <qtquickglobal.h>
+#include <private/qqmlvaluetype_p.h>
+
+#include <QtGui/QColor>
+#include <QtGui/QVector2D>
+#include <QtGui/QVector3D>
+#include <QtGui/QVector4D>
+#include <QtGui/QQuaternion>
+#include <QtGui/QMatrix4x4>
+#include <QtGui/QFont>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+namespace QQuickValueTypes {
+
+void registerValueTypes();
+
+}
+
+class Q_AUTOTEST_EXPORT QQuickColorValueType : public QQmlValueTypeBase<QColor>
+{
+    Q_PROPERTY(qreal r READ r WRITE setR)
+    Q_PROPERTY(qreal g READ g WRITE setG)
+    Q_PROPERTY(qreal b READ b WRITE setB)
+    Q_PROPERTY(qreal a READ a WRITE setA)
+    Q_OBJECT
+public:
+    QQuickColorValueType(QObject *parent = 0);
+
+    virtual QString toString() const;
+
+    qreal r() const;
+    qreal g() const;
+    qreal b() const;
+    qreal a() const;
+    void setR(qreal);
+    void setG(qreal);
+    void setB(qreal);
+    void setA(qreal);
+};
+
+class Q_AUTOTEST_EXPORT QQuickVector2DValueType : public QQmlValueTypeBase<QVector2D>
+{
+    Q_PROPERTY(qreal x READ x WRITE setX)
+    Q_PROPERTY(qreal y READ y WRITE setY)
+    Q_OBJECT
+public:
+    QQuickVector2DValueType(QObject *parent = 0);
+
+    virtual QString toString() const;
+
+    qreal x() const;
+    qreal y() const;
+    void setX(qreal);
+    void setY(qreal);
+};
+
+class Q_AUTOTEST_EXPORT QQuickVector3DValueType : public QQmlValueTypeBase<QVector3D>
+{
+    Q_PROPERTY(qreal x READ x WRITE setX)
+    Q_PROPERTY(qreal y READ y WRITE setY)
+    Q_PROPERTY(qreal z READ z WRITE setZ)
+    Q_OBJECT
+public:
+    QQuickVector3DValueType(QObject *parent = 0);
+
+    virtual QString toString() const;
+
+    qreal x() const;
+    qreal y() const;
+    qreal z() const;
+    void setX(qreal);
+    void setY(qreal);
+    void setZ(qreal);
+};
+
+class Q_AUTOTEST_EXPORT QQuickVector4DValueType : public QQmlValueTypeBase<QVector4D>
+{
+    Q_PROPERTY(qreal x READ x WRITE setX)
+    Q_PROPERTY(qreal y READ y WRITE setY)
+    Q_PROPERTY(qreal z READ z WRITE setZ)
+    Q_PROPERTY(qreal w READ w WRITE setW)
+    Q_OBJECT
+public:
+    QQuickVector4DValueType(QObject *parent = 0);
+
+    virtual QString toString() const;
+
+    qreal x() const;
+    qreal y() const;
+    qreal z() const;
+    qreal w() const;
+    void setX(qreal);
+    void setY(qreal);
+    void setZ(qreal);
+    void setW(qreal);
+};
+
+class Q_AUTOTEST_EXPORT QQuickQuaternionValueType : public QQmlValueTypeBase<QQuaternion>
+{
+    Q_PROPERTY(qreal scalar READ scalar WRITE setScalar)
+    Q_PROPERTY(qreal x READ x WRITE setX)
+    Q_PROPERTY(qreal y READ y WRITE setY)
+    Q_PROPERTY(qreal z READ z WRITE setZ)
+    Q_OBJECT
+public:
+    QQuickQuaternionValueType(QObject *parent = 0);
+
+    virtual QString toString() const;
+
+    qreal scalar() const;
+    qreal x() const;
+    qreal y() const;
+    qreal z() const;
+    void setScalar(qreal);
+    void setX(qreal);
+    void setY(qreal);
+    void setZ(qreal);
+};
+
+class Q_AUTOTEST_EXPORT QQuickMatrix4x4ValueType : public QQmlValueTypeBase<QMatrix4x4>
+{
+    Q_PROPERTY(qreal m11 READ m11 WRITE setM11)
+    Q_PROPERTY(qreal m12 READ m12 WRITE setM12)
+    Q_PROPERTY(qreal m13 READ m13 WRITE setM13)
+    Q_PROPERTY(qreal m14 READ m14 WRITE setM14)
+    Q_PROPERTY(qreal m21 READ m21 WRITE setM21)
+    Q_PROPERTY(qreal m22 READ m22 WRITE setM22)
+    Q_PROPERTY(qreal m23 READ m23 WRITE setM23)
+    Q_PROPERTY(qreal m24 READ m24 WRITE setM24)
+    Q_PROPERTY(qreal m31 READ m31 WRITE setM31)
+    Q_PROPERTY(qreal m32 READ m32 WRITE setM32)
+    Q_PROPERTY(qreal m33 READ m33 WRITE setM33)
+    Q_PROPERTY(qreal m34 READ m34 WRITE setM34)
+    Q_PROPERTY(qreal m41 READ m41 WRITE setM41)
+    Q_PROPERTY(qreal m42 READ m42 WRITE setM42)
+    Q_PROPERTY(qreal m43 READ m43 WRITE setM43)
+    Q_PROPERTY(qreal m44 READ m44 WRITE setM44)
+    Q_OBJECT
+public:
+    QQuickMatrix4x4ValueType(QObject *parent = 0);
+
+    virtual QString toString() const;
+
+    qreal m11() const { return v(0, 0); }
+    qreal m12() const { return v(0, 1); }
+    qreal m13() const { return v(0, 2); }
+    qreal m14() const { return v(0, 3); }
+    qreal m21() const { return v(1, 0); }
+    qreal m22() const { return v(1, 1); }
+    qreal m23() const { return v(1, 2); }
+    qreal m24() const { return v(1, 3); }
+    qreal m31() const { return v(2, 0); }
+    qreal m32() const { return v(2, 1); }
+    qreal m33() const { return v(2, 2); }
+    qreal m34() const { return v(2, 3); }
+    qreal m41() const { return v(3, 0); }
+    qreal m42() const { return v(3, 1); }
+    qreal m43() const { return v(3, 2); }
+    qreal m44() const { return v(3, 3); }
+
+    void setM11(qreal value) { v(0, 0) = value; }
+    void setM12(qreal value) { v(0, 1) = value; }
+    void setM13(qreal value) { v(0, 2) = value; }
+    void setM14(qreal value) { v(0, 3) = value; }
+    void setM21(qreal value) { v(1, 0) = value; }
+    void setM22(qreal value) { v(1, 1) = value; }
+    void setM23(qreal value) { v(1, 2) = value; }
+    void setM24(qreal value) { v(1, 3) = value; }
+    void setM31(qreal value) { v(2, 0) = value; }
+    void setM32(qreal value) { v(2, 1) = value; }
+    void setM33(qreal value) { v(2, 2) = value; }
+    void setM34(qreal value) { v(2, 3) = value; }
+    void setM41(qreal value) { v(3, 0) = value; }
+    void setM42(qreal value) { v(3, 1) = value; }
+    void setM43(qreal value) { v(3, 2) = value; }
+    void setM44(qreal value) { v(3, 3) = value; }
+};
+
+class Q_AUTOTEST_EXPORT QQuickFontValueType : public QQmlValueTypeBase<QFont>
+{
+    Q_OBJECT
+    Q_ENUMS(FontWeight)
+    Q_ENUMS(Capitalization)
+
+    Q_PROPERTY(QString family READ family WRITE setFamily)
+    Q_PROPERTY(bool bold READ bold WRITE setBold)
+    Q_PROPERTY(FontWeight weight READ weight WRITE setWeight)
+    Q_PROPERTY(bool italic READ italic WRITE setItalic)
+    Q_PROPERTY(bool underline READ underline WRITE setUnderline)
+    Q_PROPERTY(bool overline READ overline WRITE setOverline)
+    Q_PROPERTY(bool strikeout READ strikeout WRITE setStrikeout)
+    Q_PROPERTY(qreal pointSize READ pointSize WRITE setPointSize)
+    Q_PROPERTY(int pixelSize READ pixelSize WRITE setPixelSize)
+    Q_PROPERTY(Capitalization capitalization READ capitalization WRITE setCapitalization)
+    Q_PROPERTY(qreal letterSpacing READ letterSpacing WRITE setLetterSpacing)
+    Q_PROPERTY(qreal wordSpacing READ wordSpacing WRITE setWordSpacing)
+
+public:
+    enum FontWeight { Light = QFont::Light,
+                       Normal = QFont::Normal,
+                       DemiBold = QFont::DemiBold,
+                       Bold = QFont::Bold,
+                       Black = QFont::Black };
+    enum Capitalization { MixedCase = QFont::MixedCase,
+                           AllUppercase = QFont::AllUppercase,
+                           AllLowercase = QFont::AllLowercase,
+                           SmallCaps = QFont::SmallCaps,
+                           Capitalize = QFont::Capitalize };
+
+    QQuickFontValueType(QObject *parent = 0);
+
+    virtual QString toString() const;
+
+    QString family() const;
+    void setFamily(const QString &);
+
+    bool bold() const;
+    void setBold(bool b);
+
+    FontWeight weight() const;
+    void setWeight(FontWeight);
+
+    bool italic() const;
+    void setItalic(bool b);
+
+    bool underline() const;
+    void setUnderline(bool b);
+
+    bool overline() const;
+    void setOverline(bool b);
+
+    bool strikeout() const;
+    void setStrikeout(bool b);
+
+    qreal pointSize() const;
+    void setPointSize(qreal size);
+
+    int pixelSize() const;
+    void setPixelSize(int size);
+
+    Capitalization capitalization() const;
+    void setCapitalization(Capitalization);
+
+    qreal letterSpacing() const;
+    void setLetterSpacing(qreal spacing);
+
+    qreal wordSpacing() const;
+    void setWordSpacing(qreal spacing);
+
+    void onLoad();
+
+private:
+    bool pixelSizeSet;
+    bool pointSizeSet;
+    mutable QQmlNullableValue<int> dpi;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QQUICKVALUETYPES_P_H
diff --git a/src/quick/util/util.pri b/src/quick/util/util.pri
index d720ef02c9..3d93b9f2f5 100644
--- a/src/quick/util/util.pri
+++ b/src/quick/util/util.pri
@@ -1,4 +1,5 @@
 SOURCES += \
+    $$PWD/qquickapplication.cpp\
     $$PWD/qquickutilmodule.cpp\
     $$PWD/qquickconnections.cpp \
     $$PWD/qquickpackage.cpp \
@@ -26,9 +27,12 @@ SOURCES += \
     $$PWD/qquicklistcompositor.cpp \
     $$PWD/qquickpathinterpolator.cpp \
     $$PWD/qquickimageprovider.cpp \
-    $$PWD/qquicksvgparser.cpp
+    $$PWD/qquicksvgparser.cpp \
+    $$PWD/qquickvaluetypes.cpp \
+    $$PWD/qquickglobal.cpp
 
 HEADERS += \
+    $$PWD/qquickapplication_p.h\
     $$PWD/qquickutilmodule_p.h\
     $$PWD/qquickconnections_p.h \
     $$PWD/qquickpackage_p.h \
@@ -60,4 +64,5 @@ HEADERS += \
     $$PWD/qquicklistcompositor_p.h \
     $$PWD/qquickpathinterpolator_p.h \
     $$PWD/qquickimageprovider.h \
-    $$PWD/qquicksvgparser_p.h
+    $$PWD/qquicksvgparser_p.h \
+    $$PWD/qquickvaluetypes_p.h
diff --git a/tests/auto/qml/qml.pro b/tests/auto/qml/qml.pro
index 4d1644f6b3..0657ea891e 100644
--- a/tests/auto/qml/qml.pro
+++ b/tests/auto/qml/qml.pro
@@ -32,6 +32,7 @@ PRIVATETESTS += \
     qqmlecmascript \
     qqmlcontext \
     qqmlexpression \
+    qqmlglobal \
     qqmlinstruction \
     qqmllanguage \
     qqmlproperty \
diff --git a/tests/auto/qml/qqmlecmascript/testtypes.h b/tests/auto/qml/qqmlecmascript/testtypes.h
index 54fab26405..ab8f85baa3 100644
--- a/tests/auto/qml/qqmlecmascript/testtypes.h
+++ b/tests/auto/qml/qqmlecmascript/testtypes.h
@@ -51,6 +51,7 @@
 #include <QtGui/qmatrix.h>
 #include <QtGui/qcolor.h>
 #include <QtGui/qvector3d.h>
+#include <QtGui/QFont>
 #include <QtGui/QPixmap>
 #include <QtCore/qdatetime.h>
 #include <QtQml/qjsvalue.h>
diff --git a/tests/auto/qml/qqmlglobal/qqmlglobal.pro b/tests/auto/qml/qqmlglobal/qqmlglobal.pro
new file mode 100644
index 0000000000..b39c04500c
--- /dev/null
+++ b/tests/auto/qml/qqmlglobal/qqmlglobal.pro
@@ -0,0 +1,7 @@
+CONFIG += testcase
+TARGET = tst_qqmlglobal
+SOURCES += tst_qqmlglobal.cpp
+macx:CONFIG -= app_bundle
+
+CONFIG += parallel_test
+QT += qml-private testlib
diff --git a/tests/auto/qml/qqmlglobal/tst_qqmlglobal.cpp b/tests/auto/qml/qqmlglobal/tst_qqmlglobal.cpp
new file mode 100644
index 0000000000..e2cdd50883
--- /dev/null
+++ b/tests/auto/qml/qqmlglobal/tst_qqmlglobal.cpp
@@ -0,0 +1,88 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qtest.h>
+#include <qqml.h>
+
+#include <private/qqmlglobal_p.h>
+
+class tst_qqmlglobal : public QObject
+{
+    Q_OBJECT
+public:
+    tst_qqmlglobal() {}
+
+private slots:
+    void initTestCase();
+
+    void valueTypeProviderWarning();
+    void colorProviderWarning();
+    void guiProviderWarning();
+};
+
+void tst_qqmlglobal::initTestCase()
+{
+}
+
+void tst_qqmlglobal::valueTypeProviderWarning()
+{
+    const QLatin1String expected("Warning: QQml_valueTypeProvider: no value type provider has been set! ");
+    QTest::ignoreMessage(QtWarningMsg, expected.data());
+    QQml_valueTypeProvider();
+}
+
+void tst_qqmlglobal::colorProviderWarning()
+{
+    const QLatin1String expected("Warning: QQml_colorProvider: no color provider has been set! ");
+    QTest::ignoreMessage(QtWarningMsg, expected.data());
+    QQml_colorProvider();
+}
+
+void tst_qqmlglobal::guiProviderWarning()
+{
+    const QLatin1String expected("Warning: QQml_guiProvider: no GUI provider has been set! ");
+    QTest::ignoreMessage(QtWarningMsg, expected.data());
+    QQml_guiProvider();
+}
+
+QTEST_MAIN(tst_qqmlglobal)
+
+#include "tst_qqmlglobal.moc"
diff --git a/tests/auto/qml/qqmlinstruction/tst_qqmlinstruction.cpp b/tests/auto/qml/qqmlinstruction/tst_qqmlinstruction.cpp
index d076f038d3..d0e818f076 100644
--- a/tests/auto/qml/qqmlinstruction/tst_qqmlinstruction.cpp
+++ b/tests/auto/qml/qqmlinstruction/tst_qqmlinstruction.cpp
@@ -42,6 +42,9 @@
 #include <qtest.h>
 #include <private/qqmlcompiler_p.h>
 
+#include <QVector3D>
+#include <QVector4D>
+
 class tst_qqmlinstruction : public QObject
 {
     Q_OBJECT
diff --git a/tests/auto/qml/qqmllanguage/data/wrongType.7.errors.txt b/tests/auto/qml/qqmllanguage/data/wrongType.7.errors.txt
index 614346bd2b..8a168d2941 100644
--- a/tests/auto/qml/qqmllanguage/data/wrongType.7.errors.txt
+++ b/tests/auto/qml/qqmllanguage/data/wrongType.7.errors.txt
@@ -1 +1 @@
-3:20:Invalid property assignment: color expected
+4:20:Invalid property assignment: color expected
diff --git a/tests/auto/qml/qqmllanguage/data/wrongType.7.qml b/tests/auto/qml/qqmllanguage/data/wrongType.7.qml
index ddc3835199..e9dd71079a 100644
--- a/tests/auto/qml/qqmllanguage/data/wrongType.7.qml
+++ b/tests/auto/qml/qqmllanguage/data/wrongType.7.qml
@@ -1,4 +1,5 @@
 import Test 1.0
+import QtQuick 2.0
 MyTypeObject {
     colorProperty: 12
 }
diff --git a/tests/auto/qml/qqmlqt/qqmlqt.pro b/tests/auto/qml/qqmlqt/qqmlqt.pro
index 92fabf5882..012f58ae70 100644
--- a/tests/auto/qml/qqmlqt/qqmlqt.pro
+++ b/tests/auto/qml/qqmlqt/qqmlqt.pro
@@ -10,4 +10,4 @@ TESTDATA = data/*
 
 CONFIG += parallel_test
 
-QT += core-private gui-private v8-private qml-private quick-private testlib
+QT += core-private v8-private qml-private quick-private testlib gui
diff --git a/tests/auto/qml/qqmlqt/tst_qqmlqt.cpp b/tests/auto/qml/qqmlqt/tst_qqmlqt.cpp
index d3dc3e7343..a1d7291565 100644
--- a/tests/auto/qml/qqmlqt/tst_qqmlqt.cpp
+++ b/tests/auto/qml/qqmlqt/tst_qqmlqt.cpp
@@ -52,6 +52,8 @@
 #include <QCryptographicHash>
 #include <QtQuick/QQuickItem>
 #include <QSignalSpy>
+#include <QVector3D>
+#include <QVector4D>
 #include "../../shared/util.h"
 
 class tst_qqmlqt : public QQmlDataTest
diff --git a/tests/auto/qml/qqmlvaluetypes/qqmlvaluetypes.pro b/tests/auto/qml/qqmlvaluetypes/qqmlvaluetypes.pro
index 9155cbee96..8d9acb65b3 100644
--- a/tests/auto/qml/qqmlvaluetypes/qqmlvaluetypes.pro
+++ b/tests/auto/qml/qqmlvaluetypes/qqmlvaluetypes.pro
@@ -13,4 +13,4 @@ TESTDATA = data/*
 
 CONFIG += parallel_test
 
-QT += core-private gui-private v8-private qml-private testlib
+QT += core-private gui-private v8-private qml-private quick-private gui testlib
diff --git a/tests/auto/qml/qqmlvaluetypes/tst_qqmlvaluetypes.cpp b/tests/auto/qml/qqmlvaluetypes/tst_qqmlvaluetypes.cpp
index 54791fc340..359653caa4 100644
--- a/tests/auto/qml/qqmlvaluetypes/tst_qqmlvaluetypes.cpp
+++ b/tests/auto/qml/qqmlvaluetypes/tst_qqmlvaluetypes.cpp
@@ -43,12 +43,12 @@
 #include <QQmlEngine>
 #include <QQmlComponent>
 #include <QDebug>
-#include <private/qqmlvaluetype_p.h>
+#include <private/qquickvaluetypes_p.h>
 #include "../../shared/util.h"
 #include "testtypes.h"
 
 QT_BEGIN_NAMESPACE
-extern int qt_defaultDpi();
+extern int qt_defaultDpi(void);
 QT_END_NAMESPACE
 
 class tst_qqmlvaluetypes : public QQmlDataTest
@@ -1129,13 +1129,13 @@ void tst_qqmlvaluetypes::cppClasses()
     CPP_TEST(QQmlSizeFValueType, QSizeF(-100.7, 18.2));
     CPP_TEST(QQmlRectValueType, QRect(13, 39, 10928, 88));
     CPP_TEST(QQmlRectFValueType, QRectF(88.2, -90.1, 103.2, 118));
-    CPP_TEST(QQmlVector2DValueType, QVector2D(19.7, 1002));
-    CPP_TEST(QQmlVector3DValueType, QVector3D(18.2, 19.7, 1002));
-    CPP_TEST(QQmlVector4DValueType, QVector4D(18.2, 19.7, 1002, 54));
-    CPP_TEST(QQmlQuaternionValueType, QQuaternion(18.2, 19.7, 1002, 54));
-    CPP_TEST(QQmlMatrix4x4ValueType,
+    CPP_TEST(QQuickVector2DValueType, QVector2D(19.7, 1002));
+    CPP_TEST(QQuickVector3DValueType, QVector3D(18.2, 19.7, 1002));
+    CPP_TEST(QQuickVector4DValueType, QVector4D(18.2, 19.7, 1002, 54));
+    CPP_TEST(QQuickQuaternionValueType, QQuaternion(18.2, 19.7, 1002, 54));
+    CPP_TEST(QQuickMatrix4x4ValueType,
              QMatrix4x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16));
-    CPP_TEST(QQmlFontValueType, QFont("Helvetica"));
+    CPP_TEST(QQuickFontValueType, QFont("Helvetica"));
 
 }
 
diff --git a/tests/auto/quick/qquickapplication/tst_qquickapplication.cpp b/tests/auto/quick/qquickapplication/tst_qquickapplication.cpp
index 61675d980d..4dd7688f6a 100644
--- a/tests/auto/quick/qquickapplication/tst_qquickapplication.cpp
+++ b/tests/auto/quick/qquickapplication/tst_qquickapplication.cpp
@@ -69,7 +69,15 @@ tst_qquickapplication::tst_qquickapplication()
 void tst_qquickapplication::active()
 {
     QQmlComponent component(&engine);
-    component.setData("import QtQuick 2.0; Item { property bool active: Qt.application.active }", QUrl::fromLocalFile(""));
+    component.setData("import QtQuick 2.0; "
+                      "Item { "
+                      "    property bool active: Qt.application.active; "
+                      "    property bool active2: false; "
+                      "    Connections { "
+                      "        target: Qt.application; "
+                      "        onActiveChanged: active2 = Qt.application.active; "
+                      "    } "
+                      "}", QUrl::fromLocalFile(""));
     QQuickItem *item = qobject_cast<QQuickItem *>(component.create());
     QVERIFY(item);
     QQuickView view;
@@ -77,6 +85,7 @@ void tst_qquickapplication::active()
 
     // not active
     QVERIFY(!item->property("active").toBool());
+    QVERIFY(!item->property("active2").toBool());
     QCOMPARE(item->property("active").toBool(), QGuiApplication::activeWindow() != 0);
 
     // active
@@ -86,6 +95,7 @@ void tst_qquickapplication::active()
     QEXPECT_FAIL("", "QTBUG-21573", Abort);
     QTRY_COMPARE(view.status(), QQuickView::Ready);
     QCOMPARE(item->property("active").toBool(), QGuiApplication::activeWindow() != 0);
+    QCOMPARE(item->property("active2").toBool(), QGuiApplication::activeWindow() != 0);
 
 #if 0
     // QGuiApplication has no equivalent of setActiveWindow(0). QTBUG-21573
@@ -128,6 +138,9 @@ void tst_qquickapplication::layoutDirection()
 
 void tst_qquickapplication::inputPanel()
 {
+    const QLatin1String expected("Qt.application.inputPanel is deprecated, use Qt.inputMethod instead ");
+    QTest::ignoreMessage(QtWarningMsg, expected.data());
+
     QQmlComponent component(&engine);
     component.setData("import QtQuick 2.0; Item { property variant inputPanel: Qt.application.inputPanel }", QUrl::fromLocalFile(""));
     QQuickItem *item = qobject_cast<QQuickItem *>(component.create());
diff --git a/tests/auto/quick/qquicktext/tst_qquicktext.cpp b/tests/auto/quick/qquicktext/tst_qquicktext.cpp
index 92e8528a0d..77f0ec190d 100644
--- a/tests/auto/quick/qquicktext/tst_qquicktext.cpp
+++ b/tests/auto/quick/qquicktext/tst_qquicktext.cpp
@@ -45,7 +45,7 @@
 #include <QtQml/qqmlcomponent.h>
 #include <QtQuick/private/qquicktext_p.h>
 #include <private/qquicktext_p_p.h>
-#include <private/qqmlvaluetype_p.h>
+#include <private/qquickvaluetypes_p.h>
 #include <QFontMetrics>
 #include <qmath.h>
 #include <QtQuick/QQuickView>
@@ -93,7 +93,7 @@ private slots:
     void color();
     void smooth();
 
-    // QQmlFontValueType
+    // QQuickFontValueType
     void weight();
     void underline();
     void overline();
@@ -1119,7 +1119,7 @@ void tst_qquicktext::weight()
         QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
 
         QVERIFY(textObject != 0);
-        QCOMPARE((int)textObject->font().weight(), (int)QQmlFontValueType::Normal);
+        QCOMPARE((int)textObject->font().weight(), (int)QQuickFontValueType::Normal);
 
         delete textObject;
     }
@@ -1130,7 +1130,7 @@ void tst_qquicktext::weight()
         QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
 
         QVERIFY(textObject != 0);
-        QCOMPARE((int)textObject->font().weight(), (int)QQmlFontValueType::Bold);
+        QCOMPARE((int)textObject->font().weight(), (int)QQuickFontValueType::Bold);
 
         delete textObject;
     }
@@ -1223,7 +1223,7 @@ void tst_qquicktext::capitalization()
         QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
 
         QVERIFY(textObject != 0);
-        QCOMPARE((int)textObject->font().capitalization(), (int)QQmlFontValueType::MixedCase);
+        QCOMPARE((int)textObject->font().capitalization(), (int)QQuickFontValueType::MixedCase);
 
         delete textObject;
     }
@@ -1234,7 +1234,7 @@ void tst_qquicktext::capitalization()
         QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
 
         QVERIFY(textObject != 0);
-        QCOMPARE((int)textObject->font().capitalization(), (int)QQmlFontValueType::AllUppercase);
+        QCOMPARE((int)textObject->font().capitalization(), (int)QQuickFontValueType::AllUppercase);
 
         delete textObject;
     }
@@ -1245,7 +1245,7 @@ void tst_qquicktext::capitalization()
         QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
 
         QVERIFY(textObject != 0);
-        QCOMPARE((int)textObject->font().capitalization(), (int)QQmlFontValueType::AllLowercase);
+        QCOMPARE((int)textObject->font().capitalization(), (int)QQuickFontValueType::AllLowercase);
 
         delete textObject;
     }
@@ -1256,7 +1256,7 @@ void tst_qquicktext::capitalization()
         QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
 
         QVERIFY(textObject != 0);
-        QCOMPARE((int)textObject->font().capitalization(), (int)QQmlFontValueType::SmallCaps);
+        QCOMPARE((int)textObject->font().capitalization(), (int)QQuickFontValueType::SmallCaps);
 
         delete textObject;
     }
@@ -1267,7 +1267,7 @@ void tst_qquicktext::capitalization()
         QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
 
         QVERIFY(textObject != 0);
-        QCOMPARE((int)textObject->font().capitalization(), (int)QQmlFontValueType::Capitalize);
+        QCOMPARE((int)textObject->font().capitalization(), (int)QQuickFontValueType::Capitalize);
 
         delete textObject;
     }