Merge remote branch 'origin/4.8' into 4.8-from-4.7

Conflicts:
	src/gui/text/qtextengine_p.h
	src/network/ssl/qsslsocket_openssl.cpp

83 files changed, 2818 insertions, 596 deletions

diff --git a/src/declarative/debugger/debugger.pri b/src/declarative/debugger/debugger.pri
index 75287b4..3134c79 100644
--- a/src/declarative/debugger/debugger.pri
+++ b/src/declarative/debugger/debugger.pri
@@ -8,7 +8,10 @@ SOURCES += \
     $$PWD/qdeclarativedebug.cpp \
     $$PWD/qdeclarativedebugtrace.cpp \
     $$PWD/qdeclarativedebughelper.cpp \
-    $$PWD/qdeclarativedebugserver.cpp
+    $$PWD/qdeclarativedebugserver.cpp \
+    $$PWD/qdeclarativeinspectorservice.cpp \
+    $$PWD/qjsdebuggeragent.cpp \
+    $$PWD/qjsdebugservice.cpp
 
 HEADERS += \
     $$PWD/qdeclarativedebuggerstatus_p.h \
@@ -20,4 +23,8 @@ HEADERS += \
     $$PWD/qdeclarativedebugtrace_p.h \
     $$PWD/qdeclarativedebughelper_p.h \
     $$PWD/qdeclarativedebugserver_p.h \
-    debugger/qdeclarativedebugserverconnection_p.h
+    $$PWD/qdeclarativedebugserverconnection_p.h \
+    $$PWD/qdeclarativeinspectorservice_p.h \
+    $$PWD/qdeclarativeinspectorinterface_p.h \
+    $$PWD/qjsdebuggeragent_p.h \
+    $$PWD/qjsdebugservice_p.h
diff --git a/src/declarative/debugger/qdeclarativedebug.cpp b/src/declarative/debugger/qdeclarativedebug.cpp
index 0d2cb96..620ee1d 100644
--- a/src/declarative/debugger/qdeclarativedebug.cpp
+++ b/src/declarative/debugger/qdeclarativedebug.cpp
@@ -84,6 +84,7 @@ public:
     static void remove(QDeclarativeEngineDebug *, QDeclarativeDebugRootContextQuery *);
     static void remove(QDeclarativeEngineDebug *, QDeclarativeDebugObjectQuery *);
     static void remove(QDeclarativeEngineDebug *, QDeclarativeDebugExpressionQuery *);
+    static void remove(QDeclarativeEngineDebug *, QDeclarativeDebugWatch *);
 
     QHash<int, QDeclarativeDebugEnginesQuery *> enginesQuery;
     QHash<int, QDeclarativeDebugRootContextQuery *> rootContextQuery;
@@ -120,6 +121,41 @@ QDeclarativeEngineDebugPrivate::~QDeclarativeEngineDebugPrivate()
 {
     if (client)
         client->priv = 0;
+    delete client;
+
+    QHash<int, QDeclarativeDebugEnginesQuery*>::iterator enginesIter = enginesQuery.begin();
+    for (; enginesIter != enginesQuery.end(); ++enginesIter) {
+        enginesIter.value()->m_client = 0;
+        if (enginesIter.value()->state() == QDeclarativeDebugQuery::Waiting)
+            enginesIter.value()->setState(QDeclarativeDebugQuery::Error);
+    }
+
+    QHash<int, QDeclarativeDebugRootContextQuery*>::iterator rootContextIter = rootContextQuery.begin();
+    for (; rootContextIter != rootContextQuery.end(); ++rootContextIter) {
+        rootContextIter.value()->m_client = 0;
+        if (rootContextIter.value()->state() == QDeclarativeDebugQuery::Waiting)
+            rootContextIter.value()->setState(QDeclarativeDebugQuery::Error);
+    }
+
+    QHash<int, QDeclarativeDebugObjectQuery*>::iterator objectIter = objectQuery.begin();
+    for (; objectIter != objectQuery.end(); ++objectIter) {
+        objectIter.value()->m_client = 0;
+        if (objectIter.value()->state() == QDeclarativeDebugQuery::Waiting)
+            objectIter.value()->setState(QDeclarativeDebugQuery::Error);
+    }
+
+    QHash<int, QDeclarativeDebugExpressionQuery*>::iterator exprIter = expressionQuery.begin();
+    for (; exprIter != expressionQuery.end(); ++exprIter) {
+        exprIter.value()->m_client = 0;
+        if (exprIter.value()->state() == QDeclarativeDebugQuery::Waiting)
+            exprIter.value()->setState(QDeclarativeDebugQuery::Error);
+    }
+
+    QHash<int, QDeclarativeDebugWatch*>::iterator watchIter = watched.begin();
+    for (; watchIter != watched.end(); ++watchIter) {
+        watchIter.value()->m_client = 0;
+        watchIter.value()->setState(QDeclarativeDebugWatch::Dead);
+    }
 }
 
 int QDeclarativeEngineDebugPrivate::getId()
@@ -160,6 +196,14 @@ void QDeclarativeEngineDebugPrivate::remove(QDeclarativeEngineDebug *c, QDeclara
     }
 }
 
+void QDeclarativeEngineDebugPrivate::remove(QDeclarativeEngineDebug *c, QDeclarativeDebugWatch *w)
+{
+    if (c && w) {
+        QDeclarativeEngineDebugPrivate *p = (QDeclarativeEngineDebugPrivate *)QObjectPrivate::get(c);
+        p->watched.remove(w->m_queryId);
+    }
+}
+
 void QDeclarativeEngineDebugPrivate::decode(QDataStream &ds, QDeclarativeDebugObjectReference &o,
                                    bool simple)
 {
@@ -210,7 +254,7 @@ void QDeclarativeEngineDebugPrivate::decode(QDataStream &ds, QDeclarativeDebugOb
             {
                 QDeclarativeDebugObjectReference obj;
                 obj.m_debugId = prop.m_value.toInt();
-                prop.m_value = qVariantFromValue(obj);
+                prop.m_value = QVariant::fromValue(obj);
                 break;
             }
             case QDeclarativeEngineDebugServer::QDeclarativeObjectProperty::Unknown:
@@ -594,14 +638,15 @@ QDeclarativeDebugExpressionQuery *QDeclarativeEngineDebug::queryExpressionResult
 
 bool QDeclarativeEngineDebug::setBindingForObject(int objectDebugId, const QString &propertyName,
                                                   const QVariant &bindingExpression,
-                                                  bool isLiteralValue)
+                                                  bool isLiteralValue,
+                                                  QString source, int line)
 {
     Q_D(QDeclarativeEngineDebug);
 
     if (d->client->status() == QDeclarativeDebugClient::Enabled && objectDebugId != -1) {
         QByteArray message;
         QDataStream ds(&message, QIODevice::WriteOnly);
-        ds << QByteArray("SET_BINDING") << objectDebugId << propertyName << bindingExpression << isLiteralValue;
+        ds << QByteArray("SET_BINDING") << objectDebugId << propertyName << bindingExpression << isLiteralValue << source << line;
         d->client->sendMessage(message);
         return true;
     } else {
@@ -647,6 +692,8 @@ QDeclarativeDebugWatch::QDeclarativeDebugWatch(QObject *parent)
 
 QDeclarativeDebugWatch::~QDeclarativeDebugWatch()
 {
+    if (m_client && m_queryId != -1)
+        QDeclarativeEngineDebugPrivate::remove(m_client, this);
 }
 
 int QDeclarativeDebugWatch::queryId() const
diff --git a/src/declarative/debugger/qdeclarativedebug_p.h b/src/declarative/debugger/qdeclarativedebug_p.h
index ae92d6a..f822637 100644
--- a/src/declarative/debugger/qdeclarativedebug_p.h
+++ b/src/declarative/debugger/qdeclarativedebug_p.h
@@ -101,7 +101,8 @@ public:
                                                    const QString &expr,
                                                    QObject *parent = 0);
     bool setBindingForObject(int objectDebugId, const QString &propertyName,
-                             const QVariant &bindingExpression, bool isLiteralValue);
+                             const QVariant &bindingExpression, bool isLiteralValue,
+                             QString source = QString(), int line = -1);
     bool resetBindingForObject(int objectDebugId, const QString &propertyName);
     bool setMethodBody(int objectDebugId, const QString &methodName, const QString &methodBody);
 
diff --git a/src/declarative/debugger/qdeclarativedebugserver.cpp b/src/declarative/debugger/qdeclarativedebugserver.cpp
index 5e2b899..12691b2 100644
--- a/src/declarative/debugger/qdeclarativedebugserver.cpp
+++ b/src/declarative/debugger/qdeclarativedebugserver.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
@@ -90,7 +90,11 @@ public:
     QHash<QString, QDeclarativeDebugService *> plugins;
     QStringList clientPlugins;
     bool gotHello;
+    QString waitingForMsgFromService;
 
+private:
+    // private slot
+    void _q_deliverMessage(const QString &serviceName, const QByteArray &message);
     static QDeclarativeDebugServerConnection *loadConnectionPlugin(const QString &pluginName);
 };
 
@@ -116,6 +120,7 @@ void QDeclarativeDebugServerPrivate::advertisePlugins()
 QDeclarativeDebugServerConnection *QDeclarativeDebugServerPrivate::loadConnectionPlugin(
     const QString &pluginName)
 {
+#ifndef QT_NO_LIBRARY
     QStringList pluginCandidates;
     const QStringList paths = QCoreApplication::libraryPaths();
     foreach (const QString &libPath, paths) {
@@ -142,6 +147,7 @@ QDeclarativeDebugServerConnection *QDeclarativeDebugServerPrivate::loadConnectio
             return connection;
         loader.unload();
     }
+#endif
     return 0;
 }
 
@@ -184,7 +190,7 @@ QDeclarativeDebugServer *QDeclarativeDebugServer::instance()
                 int separatorIndex = appD->qmljsDebugArgumentsString().indexOf(QLatin1Char(','));
                 port = appD->qmljsDebugArgumentsString().mid(5, separatorIndex - 5).toInt(&ok);
                 pluginName = QLatin1String("qmldbg_tcp");
-            } else if (appD->qmljsDebugArgumentsString().contains("ost")) {
+            } else if (appD->qmljsDebugArgumentsString().contains(QLatin1String("ost"))) {
                 pluginName = QLatin1String("qmldbg_ost");
                 ok = true;
             }
@@ -235,7 +241,6 @@ void QDeclarativeDebugServer::receiveMessage(const QByteArray &message)
 
     QDataStream in(message);
     if (!d->gotHello) {
-
         QString name;
         int op;
         in >> name >> op;
@@ -250,6 +255,17 @@ void QDeclarativeDebugServer::receiveMessage(const QByteArray &message)
         int version;
         in >> version >> d->clientPlugins;
 
+        // Send the hello answer immediately, since it needs to arrive before
+        // the plugins below start sending messages.
+        QByteArray helloAnswer;
+        {
+            QDataStream out(&helloAnswer, QIODevice::WriteOnly);
+            out << QString(QLatin1String("QDeclarativeDebugClient")) << 0 << protocolVersion << d->plugins.keys();
+        }
+        d->connection->send(helloAnswer);
+
+        d->gotHello = true;
+
         QHash<QString, QDeclarativeDebugService*>::Iterator iter = d->plugins.begin();
         for (; iter != d->plugins.end(); ++iter) {
             QDeclarativeDebugService::Status newStatus = QDeclarativeDebugService::Unavailable;
@@ -259,14 +275,6 @@ void QDeclarativeDebugServer::receiveMessage(const QByteArray &message)
             iter.value()->statusChanged(newStatus);
         }
 
-        QByteArray helloAnswer;
-        {
-            QDataStream out(&helloAnswer, QIODevice::WriteOnly);
-            out << QString(QLatin1String("QDeclarativeDebugClient")) << 0 << protocolVersion << d->plugins.keys();
-        }
-        d->connection->send(helloAnswer);
-
-        d->gotHello = true;
         qWarning("QDeclarativeDebugServer: Connection established");
     } else {
 
@@ -304,17 +312,33 @@ void QDeclarativeDebugServer::receiveMessage(const QByteArray &message)
             QByteArray message;
             in >> message;
 
-            QHash<QString, QDeclarativeDebugService *>::Iterator iter =
-                d->plugins.find(name);
-            if (iter == d->plugins.end()) {
-                qWarning() << "QDeclarativeDebugServer: Message received for missing plugin" << name;
+            if (d->waitingForMsgFromService == name) {
+                // deliver directly so that it is delivered before waitForMessage is returning.
+                d->_q_deliverMessage(name, message);
+                d->waitingForMsgFromService.clear();
             } else {
-                (*iter)->messageReceived(message);
+                // deliver message in next event loop run.
+                // Fixes the case that the service does start it's own event loop ...,
+                // but the networking code doesn't deliver any new messages because readyRead
+                // hasn't returned.
+                QMetaObject::invokeMethod(this, "_q_deliverMessage", Qt::QueuedConnection,
+                                          Q_ARG(QString, name),
+                                          Q_ARG(QByteArray, message));
             }
         }
     }
 }
 
+void QDeclarativeDebugServerPrivate::_q_deliverMessage(const QString &serviceName, const QByteArray &message)
+{
+    QHash<QString, QDeclarativeDebugService *>::Iterator iter = plugins.find(serviceName);
+    if (iter == plugins.end()) {
+        qWarning() << "QDeclarativeDebugServer: Message received for missing plugin" << serviceName;
+    } else {
+        (*iter)->messageReceived(message);
+    }
+}
+
 QList<QDeclarativeDebugService*> QDeclarativeDebugServer::services() const
 {
     const Q_D(QDeclarativeDebugServer);
@@ -372,4 +396,23 @@ void QDeclarativeDebugServer::sendMessage(QDeclarativeDebugService *service,
     d->connection->send(msg);
 }
 
+bool QDeclarativeDebugServer::waitForMessage(QDeclarativeDebugService *service)
+{
+    Q_D(QDeclarativeDebugServer);
+
+    if (!service
+            || !d->plugins.contains(service->name())
+            || !d->waitingForMsgFromService.isEmpty())
+        return false;
+
+    d->waitingForMsgFromService = service->name();
+
+    do {
+        d->connection->waitForMessage();
+    } while (!d->waitingForMsgFromService.isEmpty());
+    return true;
+}
+
 QT_END_NAMESPACE
+
+#include "moc_qdeclarativedebugserver_p.cpp"
diff --git a/src/declarative/debugger/qdeclarativedebugserver_p.h b/src/declarative/debugger/qdeclarativedebugserver_p.h
index e39eaf3..53c1077 100644
--- a/src/declarative/debugger/qdeclarativedebugserver_p.h
+++ b/src/declarative/debugger/qdeclarativedebugserver_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
@@ -75,10 +75,13 @@ public:
     void sendMessage(QDeclarativeDebugService *service, const QByteArray &message);
     void receiveMessage(const QByteArray &message);
 
+    bool waitForMessage(QDeclarativeDebugService *service);
+
 private:
     friend class QDeclarativeDebugService;
     friend class QDeclarativeDebugServicePrivate;
     QDeclarativeDebugServer();
+    Q_PRIVATE_SLOT(d_func(), void _q_deliverMessage(QString, QByteArray))
 };
 
 QT_END_NAMESPACE
diff --git a/src/declarative/debugger/qdeclarativedebugserverconnection_p.h b/src/declarative/debugger/qdeclarativedebugserverconnection_p.h
index f48238d..d7f0de6 100644
--- a/src/declarative/debugger/qdeclarativedebugserverconnection_p.h
+++ b/src/declarative/debugger/qdeclarativedebugserverconnection_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
@@ -62,6 +62,7 @@ public:
     virtual bool isConnected() const = 0;
     virtual void send(const QByteArray &message) = 0;
     virtual void disconnect() = 0;
+    virtual bool waitForMessage() = 0;
 };
 
 Q_DECLARE_INTERFACE(QDeclarativeDebugServerConnection, "com.trolltech.Qt.QDeclarativeDebugServerConnection/1.0")
diff --git a/src/declarative/debugger/qdeclarativedebugservice.cpp b/src/declarative/debugger/qdeclarativedebugservice.cpp
index f8c238c..969ab35 100644
--- a/src/declarative/debugger/qdeclarativedebugservice.cpp
+++ b/src/declarative/debugger/qdeclarativedebugservice.cpp
@@ -209,6 +209,16 @@ void QDeclarativeDebugService::sendMessage(const QByteArray &message)
     d->server->sendMessage(this, message);
 }
 
+bool QDeclarativeDebugService::waitForMessage()
+{
+    Q_D(QDeclarativeDebugService);
+
+    if (status() != Enabled)
+        return false;
+
+    return d->server->waitForMessage(this);
+}
+
 void QDeclarativeDebugService::statusChanged(Status)
 {
 }
diff --git a/src/declarative/debugger/qdeclarativedebugservice_p.h b/src/declarative/debugger/qdeclarativedebugservice_p.h
index 9eeaa41..42d4482 100644
--- a/src/declarative/debugger/qdeclarativedebugservice_p.h
+++ b/src/declarative/debugger/qdeclarativedebugservice_p.h
@@ -69,6 +69,7 @@ public:
     Status status() const;
 
     void sendMessage(const QByteArray &);
+    bool waitForMessage();
 
     static int idForObject(QObject *);
     static QObject *objectForId(int);
@@ -84,6 +85,7 @@ protected:
 
 private:
     friend class QDeclarativeDebugServer;
+    friend class QDeclarativeDebugServerPrivate;
 };
 
 QT_END_NAMESPACE
diff --git a/src/declarative/debugger/qdeclarativedebugservice_p_p.h b/src/declarative/debugger/qdeclarativedebugservice_p_p.h
index 40aecbd..7807689 100644
--- a/src/declarative/debugger/qdeclarativedebugservice_p_p.h
+++ b/src/declarative/debugger/qdeclarativedebugservice_p_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/declarative/debugger/qdeclarativedebugtrace.cpp b/src/declarative/debugger/qdeclarativedebugtrace.cpp
index 738be9d..2772d38 100644
--- a/src/declarative/debugger/qdeclarativedebugtrace.cpp
+++ b/src/declarative/debugger/qdeclarativedebugtrace.cpp
@@ -65,9 +65,14 @@ QByteArray QDeclarativeDebugData::toByteArray() const
 
 QDeclarativeDebugTrace::QDeclarativeDebugTrace()
 : QDeclarativeDebugService(QLatin1String("CanvasFrameRate")),
-  m_enabled(false), m_deferredSend(true)
+  m_enabled(false), m_deferredSend(true), m_messageReceived(false)
 {
     m_timer.start();
+    if (status() == Enabled) {
+        // wait for first message indicating whether to trace or not
+        while (!m_messageReceived)
+            waitForMessage();
+    }
 }
 
 void QDeclarativeDebugTrace::addEvent(EventType t)
@@ -213,6 +218,8 @@ void QDeclarativeDebugTrace::messageReceived(const QByteArray &message)
 
     stream >> m_enabled;
 
+    m_messageReceived = true;
+
     if (!m_enabled)
         sendMessages();
 }
diff --git a/src/declarative/debugger/qdeclarativedebugtrace_p.h b/src/declarative/debugger/qdeclarativedebugtrace_p.h
index e97063e..30aa772 100644
--- a/src/declarative/debugger/qdeclarativedebugtrace_p.h
+++ b/src/declarative/debugger/qdeclarativedebugtrace_p.h
@@ -120,6 +120,7 @@ private:
     QPerformanceTimer m_timer;
     bool m_enabled;
     bool m_deferredSend;
+    bool m_messageReceived;
     QList<QDeclarativeDebugData> m_data;
 };
 
diff --git a/src/declarative/debugger/qdeclarativeinspectorinterface_p.h b/src/declarative/debugger/qdeclarativeinspectorinterface_p.h
new file mode 100644
index 0000000..aa29d68
--- /dev/null
+++ b/src/declarative/debugger/qdeclarativeinspectorinterface_p.h
@@ -0,0 +1,69 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 QDECLARATIVEOBSERVERINTERFACE_H
+#define QDECLARATIVEOBSERVERINTERFACE_H
+
+#include <QtDeclarative/private/qdeclarativeglobal_p.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class Q_DECLARATIVE_EXPORT QDeclarativeInspectorInterface
+{
+public:
+    QDeclarativeInspectorInterface() {}
+    virtual ~QDeclarativeInspectorInterface() {}
+
+    virtual void activate() = 0;
+    virtual void deactivate() = 0;
+};
+
+Q_DECLARE_INTERFACE(QDeclarativeInspectorInterface, "com.trolltech.Qt.QDeclarativeInspectorInterface/1.0")
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QDECLARATIVEOBSERVERINTERFACE_H
diff --git a/src/declarative/debugger/qdeclarativeinspectorservice.cpp b/src/declarative/debugger/qdeclarativeinspectorservice.cpp
new file mode 100644
index 0000000..15dbf58
--- /dev/null
+++ b/src/declarative/debugger/qdeclarativeinspectorservice.cpp
@@ -0,0 +1,147 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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/qdeclarativeinspectorservice_p.h"
+#include "private/qdeclarativeinspectorinterface_p.h"
+
+#include <QtCore/QCoreApplication>
+#include <QtCore/QDebug>
+#include <QtCore/QDir>
+#include <QtCore/QPluginLoader>
+
+#include <QtDeclarative/QDeclarativeView>
+
+QT_BEGIN_NAMESPACE
+
+Q_GLOBAL_STATIC(QDeclarativeInspectorService, serviceInstance)
+
+QDeclarativeInspectorService::QDeclarativeInspectorService()
+    : QDeclarativeDebugService(QLatin1String("QDeclarativeObserverMode"))
+    , m_inspectorPlugin(0)
+{
+}
+
+QDeclarativeInspectorService *QDeclarativeInspectorService::instance()
+{
+    return serviceInstance();
+}
+
+void QDeclarativeInspectorService::addView(QDeclarativeView *view)
+{
+    m_views.append(view);
+    updateStatus();
+}
+
+void QDeclarativeInspectorService::removeView(QDeclarativeView *view)
+{
+    m_views.removeAll(view);
+    updateStatus();
+}
+
+void QDeclarativeInspectorService::sendMessage(const QByteArray &message)
+{
+    if (status() != Enabled)
+        return;
+
+    QDeclarativeDebugService::sendMessage(message);
+}
+
+void QDeclarativeInspectorService::statusChanged(Status status)
+{
+    updateStatus();
+}
+
+void QDeclarativeInspectorService::updateStatus()
+{
+    if (m_views.isEmpty()) {
+        if (m_inspectorPlugin)
+            m_inspectorPlugin->deactivate();
+        return;
+    }
+
+    if (status() == Enabled) {
+        if (!m_inspectorPlugin)
+            m_inspectorPlugin = loadInspectorPlugin();
+
+        if (!m_inspectorPlugin) {
+            qWarning() << "Error while loading inspector plugin";
+            return;
+        }
+
+        m_inspectorPlugin->activate();
+    } else {
+        if (m_inspectorPlugin)
+            m_inspectorPlugin->deactivate();
+    }
+}
+
+void QDeclarativeInspectorService::messageReceived(const QByteArray &message)
+{
+    emit gotMessage(message);
+}
+
+QDeclarativeInspectorInterface *QDeclarativeInspectorService::loadInspectorPlugin()
+{
+    QStringList pluginCandidates;
+    const QStringList paths = QCoreApplication::libraryPaths();
+    foreach (const QString &libPath, paths) {
+        const QDir dir(libPath + QLatin1String("/qmltooling"));
+        if (dir.exists())
+            foreach (const QString &pluginPath, dir.entryList(QDir::Files))
+                pluginCandidates << dir.absoluteFilePath(pluginPath);
+    }
+
+    foreach (const QString &pluginPath, pluginCandidates) {
+        QPluginLoader loader(pluginPath);
+        if (!loader.load())
+            continue;
+
+        QDeclarativeInspectorInterface *inspector =
+                qobject_cast<QDeclarativeInspectorInterface*>(loader.instance());
+
+        if (inspector)
+            return inspector;
+        loader.unload();
+    }
+    return 0;
+}
+
+QT_END_NAMESPACE
diff --git a/src/declarative/debugger/qdeclarativeinspectorservice_p.h b/src/declarative/debugger/qdeclarativeinspectorservice_p.h
new file mode 100644
index 0000000..9a14155
--- /dev/null
+++ b/src/declarative/debugger/qdeclarativeinspectorservice_p.h
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 QDECLARATIVEOBSERVERSERVICE_H
+#define QDECLARATIVEOBSERVERSERVICE_H
+
+#include "private/qdeclarativedebugservice_p.h"
+#include <private/qdeclarativeglobal_p.h>
+
+#include <QtCore/QList>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class QDeclarativeView;
+class QDeclarativeInspectorInterface;
+
+class Q_DECLARATIVE_EXPORT QDeclarativeInspectorService : public QDeclarativeDebugService
+{
+    Q_OBJECT
+
+public:
+    QDeclarativeInspectorService();
+    static QDeclarativeInspectorService *instance();
+
+    void addView(QDeclarativeView *);
+    void removeView(QDeclarativeView *);
+    QList<QDeclarativeView*> views() const { return m_views; }
+
+    void sendMessage(const QByteArray &message);
+
+Q_SIGNALS:
+    void gotMessage(const QByteArray &message);
+
+protected:
+    virtual void statusChanged(Status status);
+    virtual void messageReceived(const QByteArray &);
+
+private:
+    void updateStatus();
+
+    static QDeclarativeInspectorInterface *loadInspectorPlugin();
+
+    QList<QDeclarativeView*> m_views;
+    QDeclarativeInspectorInterface *m_inspectorPlugin;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QDECLARATIVEOBSERVERSERVICE_H
diff --git a/src/declarative/debugger/qjsdebuggeragent.cpp b/src/declarative/debugger/qjsdebuggeragent.cpp
new file mode 100644
index 0000000..5fc64e1
--- /dev/null
+++ b/src/declarative/debugger/qjsdebuggeragent.cpp
@@ -0,0 +1,614 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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/qjsdebuggeragent_p.h"
+#include "private/qdeclarativedebughelper_p.h"
+#include "private/qjsdebugservice_p.h"
+
+#include <QtCore/qdatetime.h>
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qset.h>
+#include <QtCore/qurl.h>
+#include <QtScript/qscriptcontextinfo.h>
+#include <QtScript/qscriptengine.h>
+#include <QtScript/qscriptvalueiterator.h>
+
+QT_BEGIN_NAMESPACE
+
+class QJSDebuggerAgentPrivate
+{
+public:
+    QJSDebuggerAgentPrivate(QJSDebuggerAgent *q)
+        : q(q), state(NoState), isInitialized(false), coverageEnabled(false)
+    {}
+
+    void continueExec();
+    void recordKnownObjects(const QList<JSAgentWatchData> &);
+    QList<JSAgentWatchData> getLocals(QScriptContext *);
+    void positionChange(qint64 scriptId, int lineNumber, int columnNumber);
+    QScriptEngine *engine() { return q->engine(); }
+    void stopped();
+
+public:
+    QJSDebuggerAgent *q;
+    JSDebuggerState state;
+    int stepDepth;
+    int stepCount;
+
+    QEventLoop loop;
+    QHash<qint64, QString> filenames;
+    JSAgentBreakpoints breakpoints;
+    // breakpoints by filename (without path)
+    QHash<QString, JSAgentBreakpointData> fileNameToBreakpoints;
+    QStringList watchExpressions;
+    QSet<qint64> knownObjectIds;
+    bool isInitialized;
+    bool coverageEnabled;
+};
+
+namespace {
+
+class SetupExecEnv
+{
+public:
+    SetupExecEnv(QJSDebuggerAgentPrivate *a)
+        : agent(a),
+          previousState(a->state),
+          hadException(a->engine()->hasUncaughtException())
+    {
+        agent->state = StoppedState;
+    }
+
+    ~SetupExecEnv()
+    {
+        if (!hadException && agent->engine()->hasUncaughtException())
+            agent->engine()->clearExceptions();
+        agent->state = previousState;
+    }
+
+private:
+    QJSDebuggerAgentPrivate *agent;
+    JSDebuggerState previousState;
+    bool hadException;
+};
+
+} // anonymous namespace
+
+static JSAgentWatchData fromScriptValue(const QString &expression,
+                                        const QScriptValue &value)
+{
+    static const QString arrayStr = QCoreApplication::translate
+            ("Debugger::JSAgentWatchData", "[Array of length %1]");
+    static const QString undefinedStr = QCoreApplication::translate
+            ("Debugger::JSAgentWatchData", "<undefined>");
+
+    JSAgentWatchData data;
+    data.exp = expression.toUtf8();
+    data.name = data.exp;
+    data.hasChildren = false;
+    data.value = value.toString().toUtf8();
+    data.objectId = value.objectId();
+    if (value.isArray()) {
+        data.type = "Array";
+        data.value = arrayStr.arg(value.property(QLatin1String("length")).toString()).toUtf8();
+        data.hasChildren = true;
+    } else if (value.isBool()) {
+        data.type = "Bool";
+        // data.value = value.toBool() ? "true" : "false";
+    } else if (value.isDate()) {
+        data.type = "Date";
+        data.value = value.toDateTime().toString().toUtf8();
+    } else if (value.isError()) {
+        data.type = "Error";
+    } else if (value.isFunction()) {
+        data.type = "Function";
+    } else if (value.isUndefined()) {
+        data.type = undefinedStr.toUtf8();
+    } else if (value.isNumber()) {
+        data.type = "Number";
+    } else if (value.isRegExp()) {
+        data.type = "RegExp";
+    } else if (value.isString()) {
+        data.type = "String";
+    } else if (value.isVariant()) {
+        data.type = "Variant";
+    } else if (value.isQObject()) {
+        const QObject *obj = value.toQObject();
+        data.type = "Object";
+        data.value += '[';
+        data.value += obj->metaObject()->className();
+        data.value += ']';
+        data.hasChildren = true;
+    } else if (value.isObject()) {
+        data.type = "Object";
+        data.hasChildren = true;
+        data.value = "[Object]";
+    } else if (value.isNull()) {
+        data.type = "<null>";
+    } else {
+        data.type = "<unknown>";
+    }
+    return data;
+}
+
+static QList<JSAgentWatchData> expandObject(const QScriptValue &object)
+{
+    QList<JSAgentWatchData> result;
+    QScriptValueIterator it(object);
+    while (it.hasNext()) {
+        it.next();
+        if (it.flags() & QScriptValue::SkipInEnumeration)
+            continue;
+        if (/*object.isQObject() &&*/ it.value().isFunction()) {
+            // Cosmetics: skip all functions and slot, there are too many of them,
+            // and it is not useful information in the debugger.
+            continue;
+        }
+        JSAgentWatchData data = fromScriptValue(it.name(), it.value());
+        result.append(data);
+    }
+    if (result.isEmpty()) {
+        JSAgentWatchData data;
+        data.name = "<no initialized data>";
+        data.hasChildren = false;
+        data.value = " ";
+        data.objectId = 0;
+        result.append(data);
+    }
+    return result;
+}
+
+static QString fileName(const QString &fileUrl)
+{
+    int lastDelimiterPos = fileUrl.lastIndexOf(QLatin1Char('/'));
+    return fileUrl.mid(lastDelimiterPos, fileUrl.size() - lastDelimiterPos);
+}
+
+void QJSDebuggerAgentPrivate::recordKnownObjects(const QList<JSAgentWatchData>& list)
+{
+    foreach (const JSAgentWatchData &data, list)
+        knownObjectIds << data.objectId;
+}
+
+QList<JSAgentWatchData> QJSDebuggerAgentPrivate::getLocals(QScriptContext *ctx)
+{
+    QList<JSAgentWatchData> locals;
+    if (ctx) {
+        QScriptValue activationObject = ctx->activationObject();
+        QScriptValue thisObject = ctx->thisObject();
+        locals = expandObject(activationObject);
+        if (thisObject.isObject()
+                && thisObject.objectId() != engine()->globalObject().objectId()
+                && QScriptValueIterator(thisObject).hasNext())
+            locals.prepend(fromScriptValue(QLatin1String("this"), thisObject));
+        recordKnownObjects(locals);
+        knownObjectIds << activationObject.objectId();
+    }
+    return locals;
+}
+
+/*!
+  Constructs a new agent for the given \a engine. The agent will
+  report debugging-related events (e.g. step completion) to the given
+  \a backend.
+*/
+QJSDebuggerAgent::QJSDebuggerAgent(QScriptEngine *engine, QObject *parent)
+    : QObject(parent)
+    , QScriptEngineAgent(engine)
+    , d(new QJSDebuggerAgentPrivate(this))
+{
+    QJSDebuggerAgent::engine()->setAgent(this);
+}
+
+QJSDebuggerAgent::QJSDebuggerAgent(QDeclarativeEngine *engine, QObject *parent)
+    : QObject(parent)
+    , QScriptEngineAgent(QDeclarativeDebugHelper::getScriptEngine(engine))
+    , d(new QJSDebuggerAgentPrivate(this))
+{
+    QJSDebuggerAgent::engine()->setAgent(this);
+}
+
+/*!
+  Destroys this QJSDebuggerAgent.
+*/
+QJSDebuggerAgent::~QJSDebuggerAgent()
+{
+    engine()->setAgent(0);
+    delete d;
+}
+
+/*!
+  Indicates whether the agent got the list of breakpoints.
+  */
+bool QJSDebuggerAgent::isInitialized() const
+{
+    return d->isInitialized;
+}
+
+void QJSDebuggerAgent::setCoverageEnabled(bool enabled)
+{
+    d->isInitialized = true;
+    d->coverageEnabled = enabled;
+}
+
+void QJSDebuggerAgent::setBreakpoints(const JSAgentBreakpoints &breakpoints)
+{
+    d->breakpoints = breakpoints;
+
+    d->fileNameToBreakpoints.clear();
+    foreach (const JSAgentBreakpointData &bp, breakpoints)
+        d->fileNameToBreakpoints.insertMulti(fileName(QString::fromUtf8(bp.fileUrl)), bp);
+
+    d->isInitialized = true;
+}
+
+void QJSDebuggerAgent::setWatchExpressions(const QStringList &watchExpressions)
+{
+    d->watchExpressions = watchExpressions;
+}
+
+void QJSDebuggerAgent::stepOver()
+{
+    d->stepDepth = 0;
+    d->state = SteppingOverState;
+    d->continueExec();
+}
+
+void QJSDebuggerAgent::stepInto()
+{
+    d->stepDepth = 0;
+    d->state = SteppingIntoState;
+    d->continueExec();
+}
+
+void QJSDebuggerAgent::stepOut()
+{
+    d->stepDepth = 0;
+    d->state = SteppingOutState;
+    d->continueExec();
+}
+
+void QJSDebuggerAgent::continueExecution()
+{
+    d->state = NoState;
+    d->continueExec();
+}
+
+JSAgentWatchData QJSDebuggerAgent::executeExpression(const QString &expr)
+{
+    SetupExecEnv execEnv(d);
+
+    JSAgentWatchData data = fromScriptValue(expr, engine()->evaluate(expr));
+    d->knownObjectIds << data.objectId;
+    return data;
+}
+
+QList<JSAgentWatchData> QJSDebuggerAgent::expandObjectById(quint64 objectId)
+{
+    SetupExecEnv execEnv(d);
+
+    QScriptValue v;
+    if (d->knownObjectIds.contains(objectId))
+        v = engine()->objectById(objectId);
+
+    QList<JSAgentWatchData> result = expandObject(v);
+    d->recordKnownObjects(result);
+    return result;
+}
+
+QList<JSAgentWatchData> QJSDebuggerAgent::locals()
+{
+    SetupExecEnv execEnv(d);
+    return d->getLocals(engine()->currentContext());
+}
+
+QList<JSAgentWatchData> QJSDebuggerAgent::localsAtFrame(int frameId)
+{
+    SetupExecEnv execEnv(d);
+
+    int deep = 0;
+    QScriptContext *ctx = engine()->currentContext();
+    while (ctx && deep < frameId) {
+        ctx = ctx->parentContext();
+        deep++;
+    }
+
+    return d->getLocals(ctx);
+}
+
+QList<JSAgentStackData> QJSDebuggerAgent::backtrace()
+{
+    SetupExecEnv execEnv(d);
+
+    QList<JSAgentStackData> backtrace;
+
+    for (QScriptContext *ctx = engine()->currentContext(); ctx; ctx = ctx->parentContext()) {
+        QScriptContextInfo info(ctx);
+
+        JSAgentStackData frame;
+        frame.functionName = info.functionName().toUtf8();
+        if (frame.functionName.isEmpty()) {
+            if (ctx->parentContext()) {
+                switch (info.functionType()) {
+                case QScriptContextInfo::ScriptFunction:
+                    frame.functionName = "<anonymous>";
+                    break;
+                case QScriptContextInfo::NativeFunction:
+                    frame.functionName = "<native>";
+                    break;
+                case QScriptContextInfo::QtFunction:
+                case QScriptContextInfo::QtPropertyFunction:
+                    frame.functionName = "<native slot>";
+                    break;
+                }
+            } else {
+                frame.functionName = "<global>";
+            }
+        }
+        frame.lineNumber = info.lineNumber();
+        // if the line number is unknown, fallback to the function line number
+        if (frame.lineNumber == -1)
+            frame.lineNumber = info.functionStartLineNumber();
+
+        frame.fileUrl = info.fileName().toUtf8();
+        backtrace.append(frame);
+    }
+
+    return backtrace;
+}
+
+QList<JSAgentWatchData> QJSDebuggerAgent::watches()
+{
+    SetupExecEnv execEnv(d);
+
+    QList<JSAgentWatchData> watches;
+    foreach (const QString &expr, d->watchExpressions)
+        watches << fromScriptValue(expr, engine()->evaluate(expr));
+    d->recordKnownObjects(watches);
+    return watches;
+}
+
+void QJSDebuggerAgent::setProperty(qint64 objectId,
+                                   const QString &property,
+                                   const QString &value)
+{
+    SetupExecEnv execEnv(d);
+
+    if (d->knownObjectIds.contains(objectId)) {
+        QScriptValue object = engine()->objectById(objectId);
+        if (object.isObject()) {
+            QScriptValue result = engine()->evaluate(value);
+            object.setProperty(property, result);
+        }
+    }
+}
+
+/*!
+  \reimp
+*/
+void QJSDebuggerAgent::scriptLoad(qint64 id, const QString &program,
+                                  const QString &fileName, int baseLineNumber)
+{
+    d->filenames.insert(id, fileName);
+
+    if (d->coverageEnabled) {
+        JSAgentCoverageData rd = {"COVERAGE", QJSDebugService::instance()->m_timer.elapsed(), (int)CoverageScriptLoad,
+            id, program, fileName, baseLineNumber,
+            0, 0, QString()};
+        QJSDebugService::instance()->processMessage(rd);
+    }
+}
+
+/*!
+  \reimp
+*/
+void QJSDebuggerAgent::scriptUnload(qint64 id)
+{
+    d->filenames.remove(id);
+}
+
+/*!
+  \reimp
+*/
+void QJSDebuggerAgent::contextPush()
+{
+}
+
+/*!
+  \reimp
+*/
+void QJSDebuggerAgent::contextPop()
+{
+}
+
+/*!
+  \reimp
+*/
+void QJSDebuggerAgent::functionEntry(qint64 scriptId)
+{
+    d->stepDepth++;
+
+    if (d->coverageEnabled) {
+        JSAgentCoverageData rd = {"COVERAGE", QJSDebugService::instance()->m_timer.elapsed(), (int)CoverageFuncEntry,
+            scriptId, QString(), QString(), 0, 0, 0, QString()};
+        QJSDebugService::instance()->processMessage(rd);
+        QJSDebugService::instance()->m_timer.restart();
+    }
+}
+
+/*!
+  \reimp
+*/
+void QJSDebuggerAgent::functionExit(qint64 scriptId, const QScriptValue &returnValue)
+{
+    d->stepDepth--;
+
+    if (d->coverageEnabled) {
+        JSAgentCoverageData rd = {"COVERAGE", QJSDebugService::instance()->m_timer.elapsed(), (int)CoverageFuncExit,
+            scriptId, QString(), QString(), 0, 0, 0, returnValue.toString()};
+        QJSDebugService::instance()->processMessage(rd);
+    }
+}
+
+/*!
+  \reimp
+*/
+void QJSDebuggerAgent::positionChange(qint64 scriptId, int lineNumber, int columnNumber)
+{
+    d->positionChange(scriptId, lineNumber, columnNumber);
+
+    if (d->coverageEnabled) {
+        JSAgentCoverageData rd = {"COVERAGE", QJSDebugService::instance()->m_timer.elapsed(), (int)CoveragePosChange,
+            scriptId, QString(), QString(), 0, lineNumber, columnNumber, QString()};
+        QJSDebugService::instance()->processMessage(rd);
+    }
+}
+
+void QJSDebuggerAgentPrivate::positionChange(qint64 scriptId, int lineNumber, int columnNumber)
+{
+    Q_UNUSED(columnNumber);
+
+    if (state == StoppedState)
+        return; //no re-entrency
+
+    // check breakpoints
+    if (!breakpoints.isEmpty()) {
+        const QScriptContext *ctx = engine()->currentContext();
+        const QScriptContextInfo info(ctx);
+
+        if (info.functionType() == QScriptContextInfo::ScriptFunction) {
+            QHash<qint64, QString>::const_iterator it = filenames.constFind(scriptId);
+            // It is possible that the scripts are loaded before the agent is attached
+            if (it == filenames.constEnd()) {
+                it = filenames.insert(scriptId, info.fileName());
+            }
+
+            const QString filePath = it.value();
+            const JSAgentBreakpoints bps = fileNameToBreakpoints.values(fileName(filePath)).toSet();
+
+            foreach (const JSAgentBreakpointData &bp, bps) {
+                if (bp.lineNumber == lineNumber) {
+                    stopped();
+                    return;
+                }
+            }
+        }
+    }
+
+    switch (state) {
+    case NoState:
+    case StoppedState:
+        // Do nothing
+        break;
+    case SteppingOutState:
+        if (stepDepth >= 0)
+            break;
+        //fallthough
+    case SteppingOverState:
+        if (stepDepth > 0)
+            break;
+        //fallthough
+    case SteppingIntoState:
+        stopped();
+        break;
+    }
+
+}
+
+/*!
+  \reimp
+*/
+void QJSDebuggerAgent::exceptionThrow(qint64 scriptId,
+                                     const QScriptValue &exception,
+                                     bool hasHandler)
+{
+    Q_UNUSED(scriptId);
+    Q_UNUSED(exception);
+    Q_UNUSED(hasHandler);
+//    qDebug() << Q_FUNC_INFO << exception.toString() << hasHandler;
+#if 0 //sometimes, we get exceptions that we should just ignore.
+    if (!hasHandler && state != StoppedState)
+        stopped(true, exception);
+#endif
+}
+
+/*!
+  \reimp
+*/
+void QJSDebuggerAgent::exceptionCatch(qint64 scriptId, const QScriptValue &exception)
+{
+    Q_UNUSED(scriptId);
+    Q_UNUSED(exception);
+}
+
+bool QJSDebuggerAgent::supportsExtension(Extension extension) const
+{
+    return extension == QScriptEngineAgent::DebuggerInvocationRequest;
+}
+
+QVariant QJSDebuggerAgent::extension(Extension extension, const QVariant &argument)
+{
+    if (extension == QScriptEngineAgent::DebuggerInvocationRequest) {
+        d->stopped();
+        return QVariant();
+    }
+    return QScriptEngineAgent::extension(extension, argument);
+}
+
+void QJSDebuggerAgentPrivate::stopped()
+{
+    bool becauseOfException = false;
+    const QScriptValue &exception = QScriptValue();
+
+    knownObjectIds.clear();
+    state = StoppedState;
+
+    emit q->stopped(becauseOfException, exception.toString());
+
+    loop.exec(QEventLoop::ExcludeUserInputEvents);
+}
+
+void QJSDebuggerAgentPrivate::continueExec()
+{
+    loop.quit();
+}
+
+QT_END_NAMESPACE
diff --git a/src/declarative/debugger/qjsdebuggeragent_p.h b/src/declarative/debugger/qjsdebuggeragent_p.h
new file mode 100644
index 0000000..e999080
--- /dev/null
+++ b/src/declarative/debugger/qjsdebuggeragent_p.h
@@ -0,0 +1,229 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 QJSDEBUGGERAGENT_P_H
+#define QJSDEBUGGERAGENT_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtScript/qscriptengineagent.h>
+#include <QtCore/qset.h>
+
+QT_BEGIN_NAMESPACE
+class QScriptValue;
+class QDeclarativeEngine;
+QT_END_NAMESPACE
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class QJSDebuggerAgentPrivate;
+
+enum JSDebuggerState
+{
+    NoState,
+    SteppingIntoState,
+    SteppingOverState,
+    SteppingOutState,
+    StoppedState
+};
+
+enum JSCoverageMessage {
+    CoverageLocation,
+    CoverageScriptLoad,
+    CoveragePosChange,
+    CoverageFuncEntry,
+    CoverageFuncExit,
+    CoverageComplete,
+
+    CoverageMaximumMessage
+};
+
+struct JSAgentWatchData
+{
+    QByteArray exp;
+    QByteArray name;
+    QByteArray value;
+    QByteArray type;
+    bool hasChildren;
+    quint64 objectId;
+};
+
+inline QDataStream &operator<<(QDataStream &s, const JSAgentWatchData &data)
+{
+    return s << data.exp << data.name << data.value
+             << data.type << data.hasChildren << data.objectId;
+}
+
+inline QDataStream &operator>>(QDataStream &s, JSAgentWatchData &data)
+{
+    return s >> data.exp >> data.name >> data.value
+             >> data.type >> data.hasChildren >> data.objectId;
+}
+
+struct JSAgentStackData
+{
+    QByteArray functionName;
+    QByteArray fileUrl;
+    qint32 lineNumber;
+};
+
+inline QDataStream &operator<<(QDataStream &s, const JSAgentStackData &data)
+{
+    return s << data.functionName << data.fileUrl << data.lineNumber;
+}
+
+inline QDataStream &operator>>(QDataStream &s, JSAgentStackData &data)
+{
+    return s >> data.functionName >> data.fileUrl >> data.lineNumber;
+}
+
+struct JSAgentBreakpointData
+{
+    QByteArray functionName;
+    QByteArray fileUrl;
+    qint32 lineNumber;
+};
+
+typedef QSet<JSAgentBreakpointData> JSAgentBreakpoints;
+
+inline QDataStream &operator<<(QDataStream &s, const JSAgentBreakpointData &data)
+{
+    return s << data.functionName << data.fileUrl << data.lineNumber;
+}
+
+inline QDataStream &operator>>(QDataStream &s, JSAgentBreakpointData &data)
+{
+    return s >> data.functionName >> data.fileUrl >> data.lineNumber;
+}
+
+inline bool operator==(const JSAgentBreakpointData &b1, const JSAgentBreakpointData &b2)
+{
+    return b1.lineNumber == b2.lineNumber && b1.fileUrl == b2.fileUrl;
+}
+
+inline uint qHash(const JSAgentBreakpointData &b)
+{
+    return b.lineNumber ^ qHash(b.fileUrl);
+}
+
+
+class QJSDebuggerAgent : public QObject, public QScriptEngineAgent
+{
+    Q_OBJECT
+
+public:
+    QJSDebuggerAgent(QScriptEngine *engine, QObject *parent = 0);
+    QJSDebuggerAgent(QDeclarativeEngine *engine, QObject *parent = 0);
+    ~QJSDebuggerAgent();
+
+    bool isInitialized() const;
+
+    void setBreakpoints(const JSAgentBreakpoints &);
+    void setWatchExpressions(const QStringList &);
+
+    void stepOver();
+    void stepInto();
+    void stepOut();
+    void continueExecution();
+    void setCoverageEnabled(bool enabled);
+
+    JSAgentWatchData executeExpression(const QString &expr);
+    QList<JSAgentWatchData> expandObjectById(quint64 objectId);
+    QList<JSAgentWatchData> locals();
+    QList<JSAgentWatchData> localsAtFrame(int frameId);
+    QList<JSAgentStackData> backtrace();
+    QList<JSAgentWatchData> watches();
+    void setProperty(qint64 objectId,
+                     const QString &property,
+                     const QString &value);
+
+    // reimplemented
+    void scriptLoad(qint64 id, const QString &program,
+                    const QString &fileName, int baseLineNumber);
+    void scriptUnload(qint64 id);
+
+    void contextPush();
+    void contextPop();
+
+    void functionEntry(qint64 scriptId);
+    void functionExit(qint64 scriptId,
+                      const QScriptValue &returnValue);
+
+    void positionChange(qint64 scriptId,
+                        int lineNumber, int columnNumber);
+
+    void exceptionThrow(qint64 scriptId,
+                        const QScriptValue &exception,
+                        bool hasHandler);
+    void exceptionCatch(qint64 scriptId,
+                        const QScriptValue &exception);
+
+    bool supportsExtension(Extension extension) const;
+    QVariant extension(Extension extension,
+                       const QVariant &argument = QVariant());
+
+Q_SIGNALS:
+    void stopped(bool becauseOfException,
+                 const QString &exception);
+
+private:
+    friend class QJSDebuggerAgentPrivate;
+    QJSDebuggerAgentPrivate *d;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QJSDEBUGGERAGENT_P_H
diff --git a/src/declarative/debugger/qjsdebugservice.cpp b/src/declarative/debugger/qjsdebugservice.cpp
new file mode 100644
index 0000000..03d1f76
--- /dev/null
+++ b/src/declarative/debugger/qjsdebugservice.cpp
@@ -0,0 +1,259 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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/qjsdebugservice_p.h"
+#include "private/qjsdebuggeragent_p.h"
+
+#include <QtCore/qdatastream.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qstringlist.h>
+#include <QtDeclarative/qdeclarativeengine.h>
+
+Q_GLOBAL_STATIC(QJSDebugService, serviceInstance)
+
+// convert to a QByteArray that can be sent to the debug client
+QByteArray JSAgentCoverageData::toByteArray() const
+{
+    QByteArray data;
+    //### using QDataStream is relatively expensive
+    QDataStream ds(&data, QIODevice::WriteOnly);
+    ds << prefix << time << messageType << scriptId << program << fileName << baseLineNumber
+        << lineNumber << columnNumber << returnValue;
+    return data;
+}
+
+QJSDebugService::QJSDebugService(QObject *parent)
+    : QDeclarativeDebugService(QLatin1String("JSDebugger"), parent)
+    , m_agent(0), m_deferredSend(true)
+{
+    m_timer.start();
+}
+
+QJSDebugService::~QJSDebugService()
+{
+    delete m_agent;
+}
+
+QJSDebugService *QJSDebugService::instance()
+{
+    return serviceInstance();
+}
+
+void QJSDebugService::addEngine(QDeclarativeEngine *engine)
+{
+    Q_ASSERT(engine);
+    Q_ASSERT(!m_engines.contains(engine));
+
+    m_engines.append(engine);
+
+    if (status() == Enabled && !m_engines.isEmpty() && !m_agent) {
+        m_agent = new QJSDebuggerAgent(engine, engine);
+        connect(m_agent, SIGNAL(stopped(bool,QString)),
+                this, SLOT(executionStopped(bool,QString)));
+
+        while (!m_agent->isInitialized()) {
+            waitForMessage();
+        }
+    }
+}
+
+void QJSDebugService::removeEngine(QDeclarativeEngine *engine)
+{
+    Q_ASSERT(engine);
+    Q_ASSERT(m_engines.contains(engine));
+
+    m_engines.removeAll(engine);
+}
+
+void QJSDebugService::statusChanged(Status status)
+{
+    if (status == Enabled && !m_engines.isEmpty() && !m_agent) {
+        // Multiple engines are currently unsupported
+        QDeclarativeEngine *engine = m_engines.first();
+        m_agent = new QJSDebuggerAgent(engine, engine);
+
+        connect(m_agent, SIGNAL(stopped(bool,QString)),
+                this, SLOT(executionStopped(bool,QString)));
+
+    } else if (status != Enabled && m_agent) {
+        delete m_agent;
+        m_agent = 0;
+    }
+}
+
+void QJSDebugService::messageReceived(const QByteArray &message)
+{
+    if (!m_agent) {
+        qWarning() << "QJSDebugService::messageReceived: No QJSDebuggerAgent available";
+        return;
+    }
+
+    QDataStream ds(message);
+    QByteArray command;
+    ds >> command;
+    if (command == "BREAKPOINTS") {
+        JSAgentBreakpoints breakpoints;
+        ds >> breakpoints;
+        m_agent->setBreakpoints(breakpoints);
+
+        //qDebug() << "BREAKPOINTS";
+        //foreach (const JSAgentBreakpointData &bp, breakpoints)
+        //    qDebug() << "BREAKPOINT: " << bp.fileUrl << bp.lineNumber;
+    } else if (command == "WATCH_EXPRESSIONS") {
+        QStringList watchExpressions;
+        ds >> watchExpressions;
+        m_agent->setWatchExpressions(watchExpressions);
+    } else if (command == "STEPOVER") {
+        m_agent->stepOver();
+    } else if (command == "STEPINTO" || command == "INTERRUPT") {
+        m_agent->stepInto();
+    } else if (command == "STEPOUT") {
+        m_agent->stepOut();
+    } else if (command == "CONTINUE") {
+        m_agent->continueExecution();
+    } else if (command == "EXEC") {
+        QByteArray id;
+        QString expr;
+        ds >> id >> expr;
+
+        JSAgentWatchData data = m_agent->executeExpression(expr);
+
+        QByteArray reply;
+        QDataStream rs(&reply, QIODevice::WriteOnly);
+        rs << QByteArray("RESULT") << id << data;
+        sendMessage(reply);
+    } else if (command == "EXPAND") {
+        QByteArray requestId;
+        quint64 objectId;
+        ds >> requestId >> objectId;
+
+        QList<JSAgentWatchData> result = m_agent->expandObjectById(objectId);
+
+        QByteArray reply;
+        QDataStream rs(&reply, QIODevice::WriteOnly);
+        rs << QByteArray("EXPANDED") << requestId << result;
+        sendMessage(reply);
+    } else if (command == "ACTIVATE_FRAME") {
+        int frameId;
+        ds >> frameId;
+
+        QList<JSAgentWatchData> locals = m_agent->localsAtFrame(frameId);
+
+        QByteArray reply;
+        QDataStream rs(&reply, QIODevice::WriteOnly);
+        rs << QByteArray("LOCALS") << frameId << locals;
+        sendMessage(reply);
+    } else if (command == "SET_PROPERTY") {
+        QByteArray id;
+        qint64 objectId;
+        QString property;
+        QString value;
+        ds >> id >> objectId >> property >> value;
+
+        m_agent->setProperty(objectId, property, value);
+
+        //TODO: feedback
+    } else if (command == "PING") {
+        int ping;
+        ds >> ping;
+        QByteArray reply;
+        QDataStream rs(&reply, QIODevice::WriteOnly);
+        rs << QByteArray("PONG") << ping;
+        sendMessage(reply);
+    } else if (command == "COVERAGE") {
+        bool enabled;
+        ds >> enabled;
+        m_agent->setCoverageEnabled(enabled);
+        if (!enabled) {
+            sendMessages();
+        }
+    } else {
+        qDebug() << Q_FUNC_INFO << "Unknown command" << command;
+    }
+
+    QDeclarativeDebugService::messageReceived(message);
+}
+
+void QJSDebugService::executionStopped(bool becauseOfException,
+                                       const QString &exception)
+{
+    const QList<JSAgentStackData> backtrace = m_agent->backtrace();
+    const QList<JSAgentWatchData> watches = m_agent->watches();
+    const QList<JSAgentWatchData> locals = m_agent->locals();
+
+    QByteArray reply;
+    QDataStream rs(&reply, QIODevice::WriteOnly);
+    rs << QByteArray("STOPPED") << backtrace << watches << locals
+       << becauseOfException << exception;
+    sendMessage(reply);
+}
+
+/*
+    Either send the message directly, or queue up
+    a list of messages to send later (via sendMessages)
+*/
+void QJSDebugService::processMessage(const JSAgentCoverageData &message)
+{
+    if (m_deferredSend)
+        m_data.append(message);
+    else
+        sendMessage(message.toByteArray());
+}
+
+/*
+    Send the messages queued up by processMessage
+*/
+void QJSDebugService::sendMessages()
+{
+    if (m_deferredSend) {
+        //### this is a suboptimal way to send batched messages
+        for (int i = 0; i < m_data.count(); ++i)
+            sendMessage(m_data.at(i).toByteArray());
+        m_data.clear();
+
+        //indicate completion
+        QByteArray data;
+        QDataStream ds(&data, QIODevice::WriteOnly);
+        ds << QByteArray("COVERAGE") << (qint64)-1 << (int)CoverageComplete;
+        sendMessage(data);
+    }
+}
+
diff --git a/src/declarative/debugger/qjsdebugservice_p.h b/src/declarative/debugger/qjsdebugservice_p.h
new file mode 100644
index 0000000..4f99043
--- /dev/null
+++ b/src/declarative/debugger/qjsdebugservice_p.h
@@ -0,0 +1,123 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 QJSDEBUGSERVICE_P_H
+#define QJSDEBUGSERVICE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/QPointer>
+#include <QElapsedTimer>
+
+#include "private/qdeclarativedebugservice_p.h"
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class QDeclarativeEngine;
+class QJSDebuggerAgent;
+
+struct JSAgentCoverageData
+{
+    QByteArray prefix;
+    qint64 time;
+    int messageType;
+
+    qint64 scriptId;
+    QString program;
+    QString fileName;
+    int baseLineNumber;
+    int lineNumber;
+    int columnNumber;
+    QString returnValue;
+
+    QByteArray toByteArray() const;
+};
+
+class QJSDebugService : public QDeclarativeDebugService
+{
+    Q_OBJECT
+
+public:
+    QJSDebugService(QObject *parent = 0);
+    ~QJSDebugService();
+
+    static QJSDebugService *instance();
+
+    void addEngine(QDeclarativeEngine *);
+    void removeEngine(QDeclarativeEngine *);
+    void processMessage(const JSAgentCoverageData &message);
+
+    QElapsedTimer m_timer;
+
+protected:
+    void statusChanged(Status status);
+    void messageReceived(const QByteArray &);
+
+private Q_SLOTS:
+    void executionStopped(bool becauseOfException,
+                          const QString &exception);
+
+private:
+    void sendMessages();
+    QList<QDeclarativeEngine *> m_engines;
+    QPointer<QJSDebuggerAgent> m_agent;
+    bool m_deferredSend;
+    QList<JSAgentCoverageData> m_data;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QJSDEBUGSERVICE_P_H
diff --git a/src/declarative/debugger/qpacketprotocol.cpp b/src/declarative/debugger/qpacketprotocol.cpp
index 33bc588..f53d2a3 100644
--- a/src/declarative/debugger/qpacketprotocol.cpp
+++ b/src/declarative/debugger/qpacketprotocol.cpp
@@ -42,6 +42,7 @@
 #include "private/qpacketprotocol_p.h"
 
 #include <QBuffer>
+#include <QElapsedTimer>
 
 QT_BEGIN_NAMESPACE
 
@@ -114,7 +115,7 @@ Q_OBJECT
 public:
     QPacketProtocolPrivate(QPacketProtocol * parent, QIODevice * _dev)
     : QObject(parent), inProgressSize(-1), maxPacketSize(MAX_PACKET_SIZE),
-      dev(_dev)
+      waitingForPacket(false), dev(_dev)
     {
         Q_ASSERT(4 == sizeof(qint32));
 
@@ -125,7 +126,7 @@ public:
         QObject::connect(this, SIGNAL(invalidPacket()),
                          parent, SIGNAL(invalidPacket()));
         QObject::connect(dev, SIGNAL(readyRead()),
-                         this, SLOT(readyToRead()), Qt::QueuedConnection);
+                         this, SLOT(readyToRead()));
         QObject::connect(dev, SIGNAL(aboutToClose()),
                          this, SLOT(aboutToClose()));
         QObject::connect(dev, SIGNAL(bytesWritten(qint64)),
@@ -163,46 +164,52 @@ public Q_SLOTS:
 
     void readyToRead()
     {
-        if(-1 == inProgressSize) {
-            // We need a size header of sizeof(qint32)
-            if(sizeof(qint32) > (uint)dev->bytesAvailable())
-                return;
-
-            // Read size header
-            int read = dev->read((char *)&inProgressSize, sizeof(qint32));
-            Q_ASSERT(read == sizeof(qint32));
-            Q_UNUSED(read);
-
-            // Check sizing constraints
-            if(inProgressSize > maxPacketSize) {
-                QObject::disconnect(dev, SIGNAL(readyRead()),
-                                    this, SLOT(readyToRead()));
-                QObject::disconnect(dev, SIGNAL(aboutToClose()),
-                                    this, SLOT(aboutToClose()));
-                QObject::disconnect(dev, SIGNAL(bytesWritten(qint64)),
-                                    this, SLOT(bytesWritten(qint64)));
-                dev = 0;
-                emit invalidPacket();
-                return;
-            }
-
-            inProgressSize -= sizeof(qint32);
-
-            // Need to get trailing data
-            readyToRead();
-        } else {
-            inProgress.append(dev->read(inProgressSize - inProgress.size()));
-
-            if(inProgressSize == inProgress.size()) {
-                // Packet has arrived!
-                packets.append(inProgress);
-                inProgressSize = -1;
-                inProgress.clear();
-
-                emit readyRead();
-
-                // Need to get trailing data
-                readyToRead();
+        bool gotPackets = false;
+        while (true) {
+            // Get size header (if not in progress)
+            if (-1 == inProgressSize) {
+                // We need a size header of sizeof(qint32)
+                if (sizeof(qint32) > (uint)dev->bytesAvailable()) {
+                    if (gotPackets)
+                        emit readyRead();
+                    return; // no more data available
+                }
+
+                // Read size header
+                int read = dev->read((char *)&inProgressSize, sizeof(qint32));
+                Q_ASSERT(read == sizeof(qint32));
+                Q_UNUSED(read);
+
+                // Check sizing constraints
+                if (inProgressSize > maxPacketSize) {
+                    QObject::disconnect(dev, SIGNAL(readyRead()),
+                                        this, SLOT(readyToRead()));
+                    QObject::disconnect(dev, SIGNAL(aboutToClose()),
+                                        this, SLOT(aboutToClose()));
+                    QObject::disconnect(dev, SIGNAL(bytesWritten(qint64)),
+                                        this, SLOT(bytesWritten(qint64)));
+                    dev = 0;
+                    emit invalidPacket();
+                    return;
+                }
+
+                inProgressSize -= sizeof(qint32);
+            } else {
+                inProgress.append(dev->read(inProgressSize - inProgress.size()));
+
+                if (inProgressSize == inProgress.size()) {
+                    // Packet has arrived!
+                    packets.append(inProgress);
+                    inProgressSize = -1;
+                    inProgress.clear();
+
+                    waitingForPacket = false;
+                    gotPackets = true;
+                } else {
+                    if (gotPackets)
+                        emit readyRead();
+                    return; // packet in progress is not yet complete
+                }
             }
         }
     }
@@ -213,6 +220,7 @@ public:
     QByteArray inProgress;
     qint32 inProgressSize;
     qint32 maxPacketSize;
+    bool waitingForPacket;
     QIODevice * dev;
 };
 
@@ -324,6 +332,48 @@ QPacket QPacketProtocol::read()
     return rv;
 }
 
+/*
+   Returns the difference between msecs and elapsed. If msecs is -1,
+   however, -1 is returned.
+*/
+static int qt_timeout_value(int msecs, int elapsed)
+{
+    if (msecs == -1)
+        return -1;
+
+    int timeout = msecs - elapsed;
+    return timeout < 0 ? 0 : timeout;
+}
+
+/*!
+  This function locks until a new packet is available for reading and the
+  \l{QIODevice::}{readyRead()} signal has been emitted. The function
+  will timeout after \a msecs milliseconds; the default timeout is
+  30000 milliseconds.
+
+  The function returns true if the readyRead() signal is emitted and
+  there is new data available for reading; otherwise it returns false
+  (if an error occurred or the operation timed out).
+  */
+
+bool QPacketProtocol::waitForReadyRead(int msecs)
+{
+    if (!d->packets.isEmpty())
+        return true;
+
+    QElapsedTimer stopWatch;
+    stopWatch.start();
+
+    d->waitingForPacket = true;
+    do {
+        if (!d->dev->waitForReadyRead(msecs))
+            return false;
+        if (!d->waitingForPacket)
+            return true;
+        msecs = qt_timeout_value(msecs, stopWatch.elapsed());
+    } while (true);
+}
+
 /*!
   Return the QIODevice passed to the QPacketProtocol constructor.
 */
diff --git a/src/declarative/debugger/qpacketprotocol_p.h b/src/declarative/debugger/qpacketprotocol_p.h
index 8540828..49303e1 100644
--- a/src/declarative/debugger/qpacketprotocol_p.h
+++ b/src/declarative/debugger/qpacketprotocol_p.h
@@ -75,6 +75,8 @@ public:
     qint64 packetsAvailable() const;
     QPacket read();
 
+    bool waitForReadyRead(int msecs = 3000);
+
     void clear();
 
     QIODevice * device();
diff --git a/src/declarative/declarative.pro b/src/declarative/declarative.pro
index 27ceaf0..055e4b9 100644
--- a/src/declarative/declarative.pro
+++ b/src/declarative/declarative.pro
@@ -6,7 +6,7 @@ DEFINES   += QT_BUILD_DECLARATIVE_LIB QT_NO_URL_CAST_FROM_STRING
 win32-msvc*|win32-icc:QMAKE_LFLAGS += /BASE:0x66000000
 solaris-cc*:QMAKE_CXXFLAGS_RELEASE -= -O2
 
-unix:QMAKE_PKGCONFIG_REQUIRES = QtCore QtGui
+unix|win32-g++*:QMAKE_PKGCONFIG_REQUIRES = QtCore QtGui
 
 exists("qdeclarative_enable_gcov") {
     QMAKE_CXXFLAGS = -fprofile-arcs -ftest-coverage -fno-elide-constructors
@@ -27,6 +27,13 @@ include(debugger/debugger.pri)
 symbian: {
     TARGET.UID3=0x2001E623
     LIBS += -lefsrv -lhal
+
+    contains(QT_CONFIG, freetype) {
+        DEFINES += QT_NO_FONTCONFIG
+        INCLUDEPATH += \
+            ../3rdparty/freetype/src \
+            ../3rdparty/freetype/include
+    }
 }
 
 linux-g++-maemo:DEFINES += QDECLARATIVEVIEW_NOBACKGROUND
diff --git a/src/declarative/graphicsitems/qdeclarativeanimatedimage.cpp b/src/declarative/graphicsitems/qdeclarativeanimatedimage.cpp
index fb1bdf6..b1ebec8 100644
--- a/src/declarative/graphicsitems/qdeclarativeanimatedimage.cpp
+++ b/src/declarative/graphicsitems/qdeclarativeanimatedimage.cpp
@@ -87,6 +87,32 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
+    \qmlproperty url AnimatedImage::source
+
+    This property holds the URL that refers to the source image.
+
+    AnimatedImage can handle any image format supported by Qt, loaded from any
+    URL scheme supported by Qt.
+
+    \sa QDeclarativeImageProvider
+*/
+
+/*!
+    \qmlproperty bool AnimatedImage::asynchronous
+
+    Specifies that images on the local filesystem should be loaded
+    asynchronously in a separate thread.  The default value is
+    false, causing the user interface thread to block while the
+    image is loaded.  Setting \a asynchronous to true is useful where
+    maintaining a responsive user interface is more desirable
+    than having images immediately visible.
+
+    Note that this property is only valid for images read from the
+    local filesystem.  Images loaded via a network resource (e.g. HTTP)
+    are always loaded asynchonously.
+*/
+
+/*!
     \qmlproperty bool AnimatedImage::cache
     \since QtQuick 1.1
 
diff --git a/src/declarative/graphicsitems/qdeclarativeborderimage.cpp b/src/declarative/graphicsitems/qdeclarativeborderimage.cpp
index b696b9d..d3bab7a 100644
--- a/src/declarative/graphicsitems/qdeclarativeborderimage.cpp
+++ b/src/declarative/graphicsitems/qdeclarativeborderimage.cpp
@@ -240,22 +240,20 @@ QDeclarativeBorderImage::~QDeclarativeBorderImage()
     BorderImage can handle any image format supported by Qt, loaded from any
     URL scheme supported by Qt.
 
-    It can also handle .sci files, which are a QML-specific format. A .sci
-    file uses a simple text-based format that specifies the borders, the
-    image file and the tile rules.
+    This property can also be used to refer to .sci files, which are
+    written in a QML-specific, text-based format that specifies the
+    borders, the image file and the tile rules for a given border image.
 
     The following .sci file sets the borders to 10 on each side for the
     image \c picture.png:
 
-    \qml
-    BorderImage {
-        border.left: 10
-        border.top: 10
-        border.bottom: 10
-        border.right: 10
-        source: "picture.png"
-    }
-    \endqml
+    \code
+    border.left: 10
+    border.top: 10
+    border.bottom: 10
+    border.right: 10
+    source: "picture.png"
+    \endcode
 
     The URL may be absolute, or relative to the URL of the component.
 
diff --git a/src/declarative/graphicsitems/qdeclarativeflickable.cpp b/src/declarative/graphicsitems/qdeclarativeflickable.cpp
index ea7c366..ca6c496 100644
--- a/src/declarative/graphicsitems/qdeclarativeflickable.cpp
+++ b/src/declarative/graphicsitems/qdeclarativeflickable.cpp
@@ -264,7 +264,7 @@ void QDeclarativeFlickablePrivate::flickY(qreal velocity)
     flick(vData, q->minYExtent(), q->maxYExtent(), q->height(), fixupY_callback, velocity);
 }
 
-void QDeclarativeFlickablePrivate::flick(AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,
+void QDeclarativeFlickablePrivate::flick(AxisData &data, qreal minExtent, qreal maxExtent, qreal,
                                          QDeclarativeTimeLineCallback::Callback fixupCallback, qreal velocity)
 {
     Q_Q(QDeclarativeFlickable);
@@ -1235,71 +1235,50 @@ void QDeclarativeFlickablePrivate::data_append(QDeclarativeListProperty<QObject>
     }
 }
 
-static inline int children_count_helper(QGraphicsObject *object)
+int QDeclarativeFlickablePrivate::data_count(QDeclarativeListProperty<QObject> *property)
 {
-    QGraphicsItemPrivate *d = QGraphicsItemPrivate::get(object);
-    return d->children.count();
+    QDeclarativeItem *contentItem= static_cast<QDeclarativeFlickablePrivate*>(property->data)->contentItem;
+    return contentItem->childItems().count() + contentItem->children().count();
 }
 
-static inline QObject *children_at_helper(QGraphicsObject *object, int index)
+QObject *QDeclarativeFlickablePrivate::data_at(QDeclarativeListProperty<QObject> *property, int index)
 {
-    QGraphicsItemPrivate *d = QGraphicsItemPrivate::get(object);
-    if (index >= 0 && index < d->children.count())
-        return d->children.at(index)->toGraphicsObject();
-    else
+    QDeclarativeItem *contentItem = static_cast<QDeclarativeFlickablePrivate*>(property->data)->contentItem;
+
+    int childItemCount = contentItem->childItems().count();
+
+    if (index < 0)
         return 0;
-}
 
-static inline void children_clear_helper(QGraphicsObject *object)
-{
-    QGraphicsItemPrivate *d = QGraphicsItemPrivate::get(object);
-    int childCount = d->children.count();
-    if (static_cast<QDeclarativeItemPrivate*>(d)->componentComplete) {
-        for (int index = 0 ;index < childCount; index++) {
-            d->children.at(0)->setParentItem(0);
-        }
+    if (index < childItemCount) {
+        return contentItem->childItems().at(index)->toGraphicsObject();
     } else {
-        for (int index = 0 ;index < childCount; index++) {
-            QGraphicsItemPrivate::get(d->children.at(0))->setParentItemHelper(0, /*newParentVariant=*/0, /*thisPointerVariant=*/0);
-        }
+        return contentItem->children().at(index - childItemCount);
     }
 
+    return 0;
 }
 
-int QDeclarativeFlickablePrivate::data_count(QDeclarativeListProperty<QObject> *prop)
+void QDeclarativeFlickablePrivate::data_clear(QDeclarativeListProperty<QObject> *property)
 {
-    return QDeclarativeItemPrivate::resources_count(prop) +
-           children_count_helper(static_cast<QDeclarativeFlickablePrivate*>(prop->data)->contentItem);
-}
+    QDeclarativeItem *contentItem = static_cast<QDeclarativeFlickablePrivate*>(property->data)->contentItem;
 
-QObject *QDeclarativeFlickablePrivate::data_at(QDeclarativeListProperty<QObject> *prop, int i)
-{
-    int resourcesCount = QDeclarativeItemPrivate::resources_count(prop);
-    if (i < resourcesCount)
-        return QDeclarativeItemPrivate::resources_at(prop, i);
-    const int j = i - resourcesCount;
-    QGraphicsObject *contentObject = static_cast<QDeclarativeFlickablePrivate*>(prop->data)->contentItem;
-    if (j < children_count_helper(contentObject))
-        return children_at_helper(contentObject, j);
-    return 0;
-}
+    const QList<QGraphicsItem*> graphicsItems = contentItem->childItems();
+    for (int i = 0; i < graphicsItems.count(); i++)
+        contentItem->scene()->removeItem(graphicsItems[i]);
 
-void QDeclarativeFlickablePrivate::data_clear(QDeclarativeListProperty<QObject> *prop)
-{
-    QDeclarativeItemPrivate::resources_clear(prop);
-   QGraphicsObject *contentObject =
-            static_cast<QDeclarativeFlickablePrivate*>(prop->data)->contentItem;
-    children_clear_helper(contentObject);
+    const QList<QObject*> objects = contentItem->children();
+    for (int i = 0; i < objects.count(); i++)
+        objects[i]->setParent(0);
 }
 
 QDeclarativeListProperty<QObject> QDeclarativeFlickable::flickableData()
 {
     Q_D(QDeclarativeFlickable);
     return QDeclarativeListProperty<QObject>(this, (void *)d, QDeclarativeFlickablePrivate::data_append,
-                                             QDeclarativeFlickablePrivate::data_count,
-                                             QDeclarativeFlickablePrivate::data_at,
-                                             QDeclarativeFlickablePrivate::data_clear
-                                             );
+                                                              QDeclarativeFlickablePrivate::data_count,
+                                                              QDeclarativeFlickablePrivate::data_at,
+                                                              QDeclarativeFlickablePrivate::data_clear);
 }
 
 QDeclarativeListProperty<QGraphicsObject> QDeclarativeFlickable::flickableChildren()
diff --git a/src/declarative/graphicsitems/qdeclarativegridview.cpp b/src/declarative/graphicsitems/qdeclarativegridview.cpp
index 92b85f9..023737d 100644
--- a/src/declarative/graphicsitems/qdeclarativegridview.cpp
+++ b/src/declarative/graphicsitems/qdeclarativegridview.cpp
@@ -824,7 +824,9 @@ void QDeclarativeGridViewPrivate::createHighlight()
     if (highlight) {
         if (trackedItem == highlight)
             trackedItem = 0;
-        delete highlight->item;
+        if (highlight->item->scene())
+            highlight->item->scene()->removeItem(highlight->item);
+        highlight->item->deleteLater();
         delete highlight;
         highlight = 0;
         delete highlightXAnimator;
@@ -1830,7 +1832,7 @@ void QDeclarativeGridView::setHighlightRangeMode(HighlightRangeMode mode)
   \o Qt.LeftToRight (default) - Items will be laid out starting in the top, left corner. The flow is
   dependent on the \l GridView::flow property.
   \o Qt.RightToLeft - Items will be laid out starting in the top, right corner. The flow is dependent
-  on the \l GridView:flow property.
+  on the \l GridView::flow property.
   \endlist
 
   When using the attached property \l {LayoutMirroring::enabled} for locale layouts,
@@ -2284,6 +2286,7 @@ qreal QDeclarativeGridView::maxXExtent() const
     } else {
         highlightStart = d->highlightRangeStart;
         highlightEnd = d->highlightRangeEnd;
+        lastItemPosition = 0;
         if (d->model && d->model->count())
             lastItemPosition = d->rowPosAt(d->model->count()-1);
     }
diff --git a/src/declarative/graphicsitems/qdeclarativeitem.cpp b/src/declarative/graphicsitems/qdeclarativeitem.cpp
index ee2d19d..b9d231e 100644
--- a/src/declarative/graphicsitems/qdeclarativeitem.cpp
+++ b/src/declarative/graphicsitems/qdeclarativeitem.cpp
@@ -2604,6 +2604,17 @@ void QDeclarativeItem::setKeepMouseGrab(bool keep)
     If \a item is a \c null value, this maps the point from the coordinate
     system of the root QML view.
 */
+
+/*!
+    Maps the point (\a x, \a y), which is in \a item's coordinate system, to
+    this item's coordinate system, and returns a script value with \c x and \c y
+    properties matching the mapped cooordinate.
+
+    If \a item is a \c null value, this maps the point from the coordinate
+    system of the root QML view.
+
+    \sa Item::mapFromItem()
+*/
 QScriptValue QDeclarativeItem::mapFromItem(const QScriptValue &item, qreal x, qreal y) const
 {
     QScriptValue sv = QDeclarativeEnginePrivate::getScriptEngine(qmlEngine(this))->newObject();
@@ -2630,6 +2641,17 @@ QScriptValue QDeclarativeItem::mapFromItem(const QScriptValue &item, qreal x, qr
     If \a item is a \c null value, this maps \a x and \a y to the coordinate
     system of the root QML view.
 */
+
+/*!
+    Maps the point (\a x, \a y), which is in this item's coordinate system, to
+    \a item's coordinate system, and returns a script value with \c x and \c y
+    properties matching the mapped cooordinate.
+
+    If \a item is a \c null value, this maps \a x and \a y to the coordinate
+    system of the root QML view.
+
+    \sa Item::mapToItem()
+*/
 QScriptValue QDeclarativeItem::mapToItem(const QScriptValue &item, qreal x, qreal y) const
 {
     QScriptValue sv = QDeclarativeEnginePrivate::getScriptEngine(qmlEngine(this))->newObject();
@@ -2649,8 +2671,17 @@ QScriptValue QDeclarativeItem::mapToItem(const QScriptValue &item, qreal x, qrea
 /*!
     \qmlmethod Item::forceActiveFocus()
 
-    Force active focus on the item.
-    This method sets focus on the item and makes sure that all the focus scopes higher in the object hierarchy are also given focus.
+    Forces active focus on the item.
+
+    This method sets focus on the item and makes sure that all the focus scopes
+    higher in the object hierarchy are also given the focus.
+*/
+
+/*!
+    Forces active focus on the item.
+
+    This method sets focus on the item and makes sure that all the focus scopes
+    higher in the object hierarchy are also given the focus.
 */
 void QDeclarativeItem::forceActiveFocus()
 {
@@ -2669,7 +2700,12 @@ void QDeclarativeItem::forceActiveFocus()
 
   Returns the visible child item at point (\a x, \a y), which is in this
   item's coordinate system, or \c null if there is no such item.
-  */
+*/
+
+/*!
+  Returns the visible child item at point (\a x, \a y), which is in this
+  item's coordinate system, or 0 if there is no such item.
+*/
 QDeclarativeItem *QDeclarativeItem::childAt(qreal x, qreal y) const
 {
     const QList<QGraphicsItem *> children = childItems();
@@ -3564,8 +3600,8 @@ void QDeclarativeItem::setSize(const QSizeF &size)
 bool QDeclarativeItem::hasActiveFocus() const
 {
     Q_D(const QDeclarativeItem);
-    return focusItem() == this ||
-           (d->flags & QGraphicsItem::ItemIsFocusScope && focusItem() != 0);
+    return (focusItem() && focusItem()->isVisible()) && (focusItem() == this ||
+           (d->flags & QGraphicsItem::ItemIsFocusScope && focusItem() != 0));
 }
 
 /*!
diff --git a/src/declarative/graphicsitems/qdeclarativelistview.cpp b/src/declarative/graphicsitems/qdeclarativelistview.cpp
index b34dc43..6a91e5f 100644
--- a/src/declarative/graphicsitems/qdeclarativelistview.cpp
+++ b/src/declarative/graphicsitems/qdeclarativelistview.cpp
@@ -932,7 +932,9 @@ void QDeclarativeListViewPrivate::createHighlight()
     if (highlight) {
         if (trackedItem == highlight)
             trackedItem = 0;
-        delete highlight->item;
+        if (highlight->item->scene())
+            highlight->item->scene()->removeItem(highlight->item);
+        highlight->item->deleteLater();
         delete highlight;
         highlight = 0;
         delete highlightPosAnimator;
@@ -2852,7 +2854,7 @@ void QDeclarativeListView::geometryChanged(const QRectF &newGeometry,
     Q_D(QDeclarativeListView);
     d->maxExtentDirty = true;
     d->minExtentDirty = true;
-    if (d->isRightToLeft() && d->orient == Qt::Horizontal) {
+    if (d->isRightToLeft() && d->orient == QDeclarativeListView::Horizontal) {
         // maintain position relative to the right edge
         int dx = newGeometry.width() - oldGeometry.width();
         setContentX(contentX() - dx);
diff --git a/src/declarative/graphicsitems/qdeclarativepathview.cpp b/src/declarative/graphicsitems/qdeclarativepathview.cpp
index 79e52cd..94f128d 100644
--- a/src/declarative/graphicsitems/qdeclarativepathview.cpp
+++ b/src/declarative/graphicsitems/qdeclarativepathview.cpp
@@ -203,7 +203,9 @@ void QDeclarativePathViewPrivate::createHighlight()
 
     bool changed = false;
     if (highlightItem) {
-        delete highlightItem;
+        if (highlightItem->scene())
+            highlightItem->scene()->removeItem(highlightItem);
+        highlightItem->deleteLater();
         highlightItem = 0;
         changed = true;
     }
diff --git a/src/declarative/graphicsitems/qdeclarativepincharea.cpp b/src/declarative/graphicsitems/qdeclarativepincharea.cpp
index a84d63e..0e14ff1 100644
--- a/src/declarative/graphicsitems/qdeclarativepincharea.cpp
+++ b/src/declarative/graphicsitems/qdeclarativepincharea.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/declarative/graphicsitems/qdeclarativepincharea_p.h b/src/declarative/graphicsitems/qdeclarativepincharea_p.h
index c6b0275..357c060 100644
--- a/src/declarative/graphicsitems/qdeclarativepincharea_p.h
+++ b/src/declarative/graphicsitems/qdeclarativepincharea_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/declarative/graphicsitems/qdeclarativepincharea_p_p.h b/src/declarative/graphicsitems/qdeclarativepincharea_p_p.h
index ce67623..a01859c 100644
--- a/src/declarative/graphicsitems/qdeclarativepincharea_p_p.h
+++ b/src/declarative/graphicsitems/qdeclarativepincharea_p_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/declarative/graphicsitems/qdeclarativetext.cpp b/src/declarative/graphicsitems/qdeclarativetext.cpp
index 6d1b15d..20e4eef 100644
--- a/src/declarative/graphicsitems/qdeclarativetext.cpp
+++ b/src/declarative/graphicsitems/qdeclarativetext.cpp
@@ -41,7 +41,6 @@
 
 #include "private/qdeclarativetext_p.h"
 #include "private/qdeclarativetext_p_p.h"
-#include <private/qtextdocumentlayout_p.h>
 #include <qdeclarativestyledtext_p.h>
 #include <qdeclarativeinfo.h>
 #include <qdeclarativepixmapcache_p.h>
@@ -83,14 +82,6 @@ private:
     static QSet<QUrl> errors;
 };
 
-class QDeclarativeTextDocumentLayout : public QTextDocumentLayout
-{
-    Q_OBJECT
-public:
-    QDeclarativeTextDocumentLayout(QTextDocument *doc);
-    void setLineHeight(qreal lineHeight, QDeclarativeText::LineHeightMode mode);
-};
-
 DEFINE_BOOL_CONFIG_OPTION(enableImageCache, QML_ENABLE_TEXT_IMAGE_CACHE);
 
 QString QDeclarativeTextPrivate::elideChar = QString(0x2026);
@@ -185,15 +176,6 @@ void QTextDocumentWithImageResources::setText(const QString &text)
 
 QSet<QUrl> QTextDocumentWithImageResources::errors;
 
-QDeclarativeTextDocumentLayout::QDeclarativeTextDocumentLayout(QTextDocument *doc)
-    : QTextDocumentLayout(doc) {
-}
-
-void QDeclarativeTextDocumentLayout::setLineHeight(qreal lineHeight, QDeclarativeText::LineHeightMode mode = QDeclarativeText::ProportionalHeight)
-{
-    QTextDocumentLayout::setLineHeight(lineHeight, QTextDocumentLayout::LineHeightMode(mode));
-}
-
 QDeclarativeTextPrivate::~QDeclarativeTextPrivate()
 {
 }
@@ -243,11 +225,6 @@ void QDeclarativeTextPrivate::updateLayout()
             singleline = false;
             QDeclarativeStyledText::parse(text, layout);
         }
-    } else {
-        ensureDoc();
-        QDeclarativeTextDocumentLayout *layout = new QDeclarativeTextDocumentLayout(doc);
-        layout->setLineHeight(lineHeight, lineHeightMode);
-        doc->setDocumentLayout(layout);
     }
 
     updateSize();
diff --git a/src/declarative/graphicsitems/qdeclarativetextedit.cpp b/src/declarative/graphicsitems/qdeclarativetextedit.cpp
index a7444df..1e30e78 100644
--- a/src/declarative/graphicsitems/qdeclarativetextedit.cpp
+++ b/src/declarative/graphicsitems/qdeclarativetextedit.cpp
@@ -273,7 +273,6 @@ void QDeclarativeTextEdit::setText(const QString &text)
     \o TextEdit.AutoText
     \o TextEdit.PlainText
     \o TextEdit.RichText
-    \o TextEdit.StyledText
     \endlist
 
     The default is TextEdit.AutoText.  If the text format is TextEdit.AutoText the text edit
diff --git a/src/declarative/graphicsitems/qdeclarativetextinput.cpp b/src/declarative/graphicsitems/qdeclarativetextinput.cpp
index 231bd37..5928d31 100644
--- a/src/declarative/graphicsitems/qdeclarativetextinput.cpp
+++ b/src/declarative/graphicsitems/qdeclarativetextinput.cpp
@@ -564,13 +564,11 @@ QRect QDeclarativeTextInput::cursorRectangle() const
     \qmlproperty int TextInput::selectionStart
 
     The cursor position before the first character in the current selection.
-    Setting this and selectionEnd allows you to specify a selection in the
-    text edit.
 
-    Note that if selectionStart == selectionEnd then there is no current
-    selection.
+    This property is read-only. To change the selection, use select(start,end),
+    selectAll(), or selectWord().
 
-    \sa selectionEnd, cursorPosition, selectedText, select()
+    \sa selectionEnd, cursorPosition, selectedText
 */
 int QDeclarativeTextInput::selectionStart() const
 {
@@ -582,13 +580,11 @@ int QDeclarativeTextInput::selectionStart() const
     \qmlproperty int TextInput::selectionEnd
 
     The cursor position after the last character in the current selection.
-    Setting this and selectionStart allows you to specify a selection in the
-    text edit.
 
-    Note that if selectionStart == selectionEnd then there is no current
-    selection.
+    This property is read-only. To change the selection, use select(start,end),
+    selectAll(), or selectWord().
 
-    \sa selectionStart, cursorPosition, selectedText, select()
+    \sa selectionStart, cursorPosition, selectedText
 */
 int QDeclarativeTextInput::selectionEnd() const
 {
@@ -882,7 +878,8 @@ void QDeclarativeTextInputPrivate::updateInputMethodHints()
     \o TextInput.Normal - Displays the text as it is. (Default)
     \o TextInput.Password - Displays asterixes instead of characters.
     \o TextInput.NoEcho - Displays nothing.
-    \o TextInput.PasswordEchoOnEdit - Displays all but the current character as asterixes.
+    \o TextInput.PasswordEchoOnEdit - Displays characters as they are entered
+    while editing, otherwise displays asterisks.
     \endlist
 */
 QDeclarativeTextInput::EchoMode QDeclarativeTextInput::echoMode() const
@@ -1854,6 +1851,7 @@ bool QDeclarativeTextInput::isInputMethodComposing() const
 void QDeclarativeTextInputPrivate::init()
 {
     Q_Q(QDeclarativeTextInput);
+    control->setParent(q);
     control->setCursorWidth(1);
     control->setPasswordCharacter(QLatin1Char('*'));
     q->setSmooth(smooth);
diff --git a/src/declarative/graphicsitems/qdeclarativetextinput_p_p.h b/src/declarative/graphicsitems/qdeclarativetextinput_p_p.h
index 0ae984a..0325016 100644
--- a/src/declarative/graphicsitems/qdeclarativetextinput_p_p.h
+++ b/src/declarative/graphicsitems/qdeclarativetextinput_p_p.h
@@ -70,7 +70,7 @@ class Q_AUTOTEST_EXPORT QDeclarativeTextInputPrivate : public QDeclarativeImplic
 {
     Q_DECLARE_PUBLIC(QDeclarativeTextInput)
 public:
-    QDeclarativeTextInputPrivate() : control(new QLineControl(QString())),
+    QDeclarativeTextInputPrivate() : control(new QLineControl),
                  color((QRgb)0), style(QDeclarativeText::Normal),
                  styleColor((QRgb)0), hAlign(QDeclarativeTextInput::AlignLeft),
                  mouseSelectionMode(QDeclarativeTextInput::SelectCharacters), inputMethodHints(Qt::ImhNone),
@@ -89,7 +89,6 @@ public:
 
     ~QDeclarativeTextInputPrivate()
     {
-        delete control;
     }
 
     int xToPos(int x, QTextLine::CursorPosition betweenOrOn = QTextLine::CursorBetweenCharacters) const
diff --git a/src/declarative/graphicsitems/qdeclarativetextlayout.cpp b/src/declarative/graphicsitems/qdeclarativetextlayout.cpp
index 9aef504..e7bcf1f 100644
--- a/src/declarative/graphicsitems/qdeclarativetextlayout.cpp
+++ b/src/declarative/graphicsitems/qdeclarativetextlayout.cpp
@@ -63,9 +63,6 @@ public:
     QVector<QChar> chars;
 };
 
-Q_GUI_EXPORT extern int qt_defaultDpiX();
-Q_GUI_EXPORT extern int qt_defaultDpiY();
-
 namespace {
 class DrawTextItemRecorder: public QPaintEngine
 {
diff --git a/src/declarative/graphicsitems/qdeclarativevisualitemmodel.cpp b/src/declarative/graphicsitems/qdeclarativevisualitemmodel.cpp
index 26757b5..b896a77 100644
--- a/src/declarative/graphicsitems/qdeclarativevisualitemmodel.cpp
+++ b/src/declarative/graphicsitems/qdeclarativevisualitemmodel.cpp
@@ -1375,7 +1375,7 @@ void QDeclarativeVisualDataModel::_q_rowsMoved(const QModelIndex &sourceParent,
     Q_D(QDeclarativeVisualDataModel);
     const int count = sourceEnd - sourceStart + 1;
     if (destinationParent == d->m_root && sourceParent == d->m_root) {
-        _q_itemsMoved(sourceStart, sourceStart > destinationRow ? destinationRow : destinationRow-1, count);
+        _q_itemsMoved(sourceStart, sourceStart > destinationRow ? destinationRow : destinationRow-count, count);
     } else if (sourceParent == d->m_root) {
         _q_itemsRemoved(sourceStart, count);
     } else if (destinationParent == d->m_root) {
diff --git a/src/declarative/qml/parser/qdeclarativejsengine_p.h b/src/declarative/qml/parser/qdeclarativejsengine_p.h
index bf2d25b..409c2a3 100644
--- a/src/declarative/qml/parser/qdeclarativejsengine_p.h
+++ b/src/declarative/qml/parser/qdeclarativejsengine_p.h
@@ -88,12 +88,6 @@ uint qHash(const QDeclarativeJS::NameId &id);
 
 } // end of namespace QDeclarativeJS
 
-#if defined(Q_CC_MSVC) && _MSC_VER <= 1300
-//this ensures that code outside QDeclarativeJS can use the hash function
-//it also a workaround for some compilers
-inline uint qHash(const QDeclarativeJS::NameId &nameId) { return QDeclarativeJS::qHash(nameId); }
-#endif
-
 namespace QDeclarativeJS {
 
 class Lexer;
diff --git a/src/declarative/qml/qdeclarative.h b/src/declarative/qml/qdeclarative.h
index 399c207..5e8d0f4 100644
--- a/src/declarative/qml/qdeclarative.h
+++ b/src/declarative/qml/qdeclarative.h
@@ -405,6 +405,17 @@ QObject *qmlAttachedPropertiesObject(const QObject *obj, bool create = true)
     return qmlAttachedPropertiesObject(&idx, obj, &T::staticMetaObject, create);
 }
 
+// Enable debugging before any QDeclarativeEngine is created
+struct Q_DECLARATIVE_EXPORT QDeclarativeDebuggingEnabler
+{
+    QDeclarativeDebuggingEnabler();
+};
+
+// Execute code in constructor before first QDeclarativeEngine is instantiated
+#if defined(QT_DECLARATIVE_DEBUG)
+static QDeclarativeDebuggingEnabler qmlEnableDebuggingHelper;
+#endif
+
 QT_END_NAMESPACE
 
 QML_DECLARE_TYPE(QObject)
diff --git a/src/declarative/qml/qdeclarativecompiledbindings.cpp b/src/declarative/qml/qdeclarativecompiledbindings.cpp
index 313fe58..51ffc10 100644
--- a/src/declarative/qml/qdeclarativecompiledbindings.cpp
+++ b/src/declarative/qml/qdeclarativecompiledbindings.cpp
@@ -143,17 +143,17 @@ struct Register {
     void setNaN() { setqreal(qSNaN()); }
     bool isUndefined() const { return type == 0; }
 
-    void setQObject(QObject *o) { *((QObject **)data) = o; type = QMetaType::QObjectStar; }
-    QObject *getQObject() const { return *((QObject **)data); }
+    void setQObject(QObject *o) { qobjectValue = o; type = QMetaType::QObjectStar; }
+    QObject *getQObject() const { return qobjectValue; }
 
-    void setqreal(qreal v) { *((qreal *)data) = v; type = QMetaType::QReal; }
-    qreal getqreal() const { return *((qreal *)data); }
+    void setqreal(qreal v) { qrealValue = v; type = QMetaType::QReal; }
+    qreal getqreal() const { return qrealValue; }
 
-    void setint(int v) { *((int *)data) = v; type = QMetaType::Int; }
-    int getint() const { return *((int *)data); }
+    void setint(int v) { intValue = v; type = QMetaType::Int; }
+    int getint() const { return intValue; }
 
-    void setbool(bool v) { *((bool *)data) = v; type = QMetaType::Bool; }
-    bool getbool() const { return *((bool *)data); }
+    void setbool(bool v) { boolValue = v; type = QMetaType::Bool; }
+    bool getbool() const { return boolValue; }
 
     QVariant *getvariantptr() { return (QVariant *)typeDataPtr(); }
     QString *getstringptr() { return (QString *)typeDataPtr(); }
@@ -171,7 +171,15 @@ struct Register {
     void settype(int t) { type = t; }
 
     int type;          // Optional type
-    void *data[2];     // Object stored here
+    union {
+        QObject *qobjectValue;
+        qreal qrealValue;
+        int intValue;
+        bool boolValue;
+        char data[sizeof(QVariant)];
+        qint64 q_for_alignment_1;
+        double q_for_alignment_2;
+    };
 
 #ifdef REGISTER_CLEANUP_DEBUG
     Register() {
@@ -2388,7 +2396,7 @@ bool QDeclarativeBindingCompilerPrivate::parseConditional(QDeclarativeJS::AST::N
     skip.skip.reg = -1;
     bytecode << skip;
 
-    // Release to allow reuse of reg
+    // Release to allow reuse of reg in else path
     releaseReg(ok.reg);
     bytecode[skipIdx].skip.count = bytecode.count() - skipIdx - 1;
 
@@ -2398,8 +2406,7 @@ bool QDeclarativeBindingCompilerPrivate::parseConditional(QDeclarativeJS::AST::N
     if (!parseExpression(expression->ko, ko)) return false;
     if (ko.unknownType) return false;
 
-    // Release to allow reuse of reg
-    releaseReg(ko.reg);
+    // Do not release reg here, so that its ownership passes to the caller
     bytecode[skipIdx2].skip.count = bytecode.count() - skipIdx2 - 1;
 
     if (ok != ko)
diff --git a/src/declarative/qml/qdeclarativecompiler.cpp b/src/declarative/qml/qdeclarativecompiler.cpp
index f4cc47a..abde4ad 100644
--- a/src/declarative/qml/qdeclarativecompiler.cpp
+++ b/src/declarative/qml/qdeclarativecompiler.cpp
@@ -608,7 +608,7 @@ bool QDeclarativeCompiler::compile(QDeclarativeEngine *engine,
         out->types << ref;
     }
 
-    Object *root = unit->parser().tree();
+    QDeclarativeParser::Object *root = unit->parser().tree();
     Q_ASSERT(root);
 
     this->engine = engine;
@@ -622,6 +622,7 @@ bool QDeclarativeCompiler::compile(QDeclarativeEngine *engine,
             out->dumpInstructions();
         if (compilerStatDump())
             dumpStats();
+        Q_ASSERT(out->rootPropertyCache);
     } else {
         reset(out);
     }
@@ -637,7 +638,7 @@ bool QDeclarativeCompiler::compile(QDeclarativeEngine *engine,
     return !isError();
 }
 
-void QDeclarativeCompiler::compileTree(Object *tree)
+void QDeclarativeCompiler::compileTree(QDeclarativeParser::Object *tree)
 {
     compileState.root = tree;
     componentStat.lineNumber = tree->location.start.line;
@@ -715,14 +716,14 @@ void QDeclarativeCompiler::compileTree(Object *tree)
         enginePrivate->registerCompositeType(output);
 }
 
-static bool ValuePtrLessThan(const Value *t1, const Value *t2) 
+static bool ValuePtrLessThan(const QDeclarativeParser::Value *t1, const QDeclarativeParser::Value *t2)
 {
     return t1->location.start.line < t2->location.start.line ||
            (t1->location.start.line == t2->location.start.line &&
             t1->location.start.column < t2->location.start.column);
 }
 
-bool QDeclarativeCompiler::buildObject(Object *obj, const BindingContext &ctxt)
+bool QDeclarativeCompiler::buildObject(QDeclarativeParser::Object *obj, const BindingContext &ctxt)
 {
     componentStat.objects++;
 
@@ -799,7 +800,7 @@ bool QDeclarativeCompiler::buildObject(Object *obj, const BindingContext &ctxt)
 
                 defaultProperty->values  = obj->defaultProperty->values;
                 defaultProperty->values += explicitProperty->values;
-                foreach(Value *value, defaultProperty->values)
+                foreach(QDeclarativeParser::Value *value, defaultProperty->values)
                     value->addref();
                 qSort(defaultProperty->values.begin(), defaultProperty->values.end(), ValuePtrLessThan);
 
@@ -1218,6 +1219,11 @@ void QDeclarativeCompiler::genComponent(QDeclarativeParser::Object *obj)
         id.setId.index = obj->idIndex;
         output->bytecode << id;
     }
+
+    if (obj == unitRoot) {
+        output->rootPropertyCache = output->types[obj->type].createPropertyCache(engine);
+        output->rootPropertyCache->addref();
+    }
 }
 
 bool QDeclarativeCompiler::buildComponent(QDeclarativeParser::Object *obj,
@@ -1262,7 +1268,7 @@ bool QDeclarativeCompiler::buildComponent(QDeclarativeParser::Object *obj,
     if (!obj->dynamicSlots.isEmpty())
         COMPILE_EXCEPTION(obj, tr("Component objects cannot declare new functions."));
 
-    Object *root = 0;
+    QDeclarativeParser::Object *root = 0;
     if (obj->defaultProperty && obj->defaultProperty->values.count())
         root = obj->defaultProperty->values.first()->object;
 
@@ -1302,7 +1308,7 @@ bool QDeclarativeCompiler::buildComponentFromRoot(QDeclarativeParser::Object *ob
 // Build a sub-object.  A sub-object is one that was not created directly by
 // QML - such as a grouped property object, or an attached object.  Sub-object's
 // can't have an id, involve a custom parser, have attached properties etc.
-bool QDeclarativeCompiler::buildSubObject(Object *obj, const BindingContext &ctxt)
+bool QDeclarativeCompiler::buildSubObject(QDeclarativeParser::Object *obj, const BindingContext &ctxt)
 {
     Q_ASSERT(obj->metatype);
     Q_ASSERT(!obj->defaultProperty);
@@ -1615,7 +1621,7 @@ void QDeclarativeCompiler::genListProperty(QDeclarativeParser::Property *prop,
     output->bytecode << fetch;
 
     for (int ii = 0; ii < prop->values.count(); ++ii) {
-        Value *v = prop->values.at(ii);
+        QDeclarativeParser::Value *v = prop->values.at(ii);
 
         if (v->type == Value::CreatedObject) {
 
@@ -1903,7 +1909,7 @@ bool QDeclarativeCompiler::buildValueTypeProperty(QObject *type,
         if (prop->values.count() > 1) {
             COMPILE_EXCEPTION(prop, tr("Single property assignment expected"));
         } else if (prop->values.count()) {
-            Value *value = prop->values.at(0);
+            QDeclarativeParser::Value *value = prop->values.at(0);
 
             if (value->object) {
                 COMPILE_EXCEPTION(prop, tr("Unexpected object assignment"));
@@ -1932,7 +1938,7 @@ bool QDeclarativeCompiler::buildValueTypeProperty(QObject *type,
         }
 
         for (int ii = 0; ii < prop->onValues.count(); ++ii) {
-            Value *v = prop->onValues.at(ii);
+            QDeclarativeParser::Value *v = prop->onValues.at(ii);
             Q_ASSERT(v->object);
 
             COMPILE_CHECK(buildPropertyOnAssignment(prop, obj, baseObj, v, ctxt)); 
@@ -1962,7 +1968,7 @@ bool QDeclarativeCompiler::buildListProperty(QDeclarativeParser::Property *prop,
 
     bool assignedBinding = false;
     for (int ii = 0; ii < prop->values.count(); ++ii) {
-        Value *v = prop->values.at(ii);
+        QDeclarativeParser::Value *v = prop->values.at(ii);
         if (v->object) {
             v->type = Value::CreatedObject;
             COMPILE_CHECK(buildObject(v->object, ctxt));
@@ -2017,7 +2023,7 @@ bool QDeclarativeCompiler::buildPropertyAssignment(QDeclarativeParser::Property
         COMPILE_EXCEPTION(prop->values.at(0), tr( "Cannot assign multiple values to a singular property") );
 
     for (int ii = 0; ii < prop->values.count(); ++ii) {
-        Value *v = prop->values.at(ii);
+        QDeclarativeParser::Value *v = prop->values.at(ii);
         if (v->object) {
 
             COMPILE_CHECK(buildPropertyObjectAssignment(prop, obj, v, ctxt));
@@ -2030,7 +2036,7 @@ bool QDeclarativeCompiler::buildPropertyAssignment(QDeclarativeParser::Property
     }
 
     for (int ii = 0; ii < prop->onValues.count(); ++ii) {
-        Value *v = prop->onValues.at(ii);
+        QDeclarativeParser::Value *v = prop->onValues.at(ii);
 
         Q_ASSERT(v->object);
         COMPILE_CHECK(buildPropertyOnAssignment(prop, obj, obj, v, ctxt));
@@ -2385,7 +2391,7 @@ bool QDeclarativeCompiler::mergeDynamicMetaProperties(QDeclarativeParser::Object
             COMPILE_EXCEPTION(property, tr("Invalid property nesting"));
 
         for (int ii = 0; ii < p.defaultValue->values.count(); ++ii) {
-            Value *v = p.defaultValue->values.at(ii);
+            QDeclarativeParser::Value *v = p.defaultValue->values.at(ii);
             v->addref();
             property->values.append(v);
         }
@@ -2678,7 +2684,7 @@ static QStringList astNodeToStringList(QDeclarativeJS::AST::Node *node)
 
 bool QDeclarativeCompiler::compileAlias(QMetaObjectBuilder &builder,
                                         QByteArray &data,
-                                        Object *obj,
+                                        QDeclarativeParser::Object *obj,
                                         const Object::DynamicProperty &prop)
 {
     if (!prop.defaultValue)
@@ -2701,7 +2707,7 @@ bool QDeclarativeCompiler::compileAlias(QMetaObjectBuilder &builder,
     if (!compileState.ids.contains(alias.at(0)))
         COMPILE_EXCEPTION(prop.defaultValue, tr("Invalid alias reference. Unable to find id \"%1\"").arg(alias.at(0)));
 
-    Object *idObject = compileState.ids[alias.at(0)];
+    QDeclarativeParser::Object *idObject = compileState.ids[alias.at(0)];
 
     QByteArray typeName;
 
@@ -2884,7 +2890,7 @@ bool QDeclarativeCompiler::completeComponentBuild()
     componentStat.ids = compileState.ids.count();
 
     for (int ii = 0; ii < compileState.aliasingObjects.count(); ++ii) {
-        Object *aliasObject = compileState.aliasingObjects.at(ii);
+        QDeclarativeParser::Object *aliasObject = compileState.aliasingObjects.at(ii);
         COMPILE_CHECK(buildDynamicMeta(aliasObject, ResolveAliases));
     }
 
diff --git a/src/declarative/qml/qdeclarativecustomparser.cpp b/src/declarative/qml/qdeclarativecustomparser.cpp
index 1bb7b3f..e80d911 100644
--- a/src/declarative/qml/qdeclarativecustomparser.cpp
+++ b/src/declarative/qml/qdeclarativecustomparser.cpp
@@ -131,7 +131,7 @@ QDeclarativeCustomParserNodePrivate::fromProperty(QDeclarativeParser::Property *
             prop.d->values << QVariant::fromValue(props.at(ii));
     } else {
         for(int ii = 0; ii < p->values.count(); ++ii) {
-            Value *v = p->values.at(ii);
+            QDeclarativeParser::Value *v = p->values.at(ii);
             v->type = QDeclarativeParser::Value::Literal;
 
             if(v->object) {
diff --git a/src/declarative/qml/qdeclarativedata_p.h b/src/declarative/qml/qdeclarativedata_p.h
index 2a5eace..4f22b8f 100644
--- a/src/declarative/qml/qdeclarativedata_p.h
+++ b/src/declarative/qml/qdeclarativedata_p.h
@@ -55,10 +55,10 @@
 
 #include <QtScript/qscriptvalue.h>
 #include <private/qobject_p.h>
-#include "private/qdeclarativeguard_p.h"
 
 QT_BEGIN_NAMESPACE
 
+class QDeclarativeGuardImpl;
 class QDeclarativeCompiledData;
 class QDeclarativeAbstractBinding;
 class QDeclarativeContext;
@@ -134,7 +134,7 @@ public:
     quint32 objectDataRefCount;
     QDeclarativePropertyCache *propertyCache;
 
-    QDeclarativeGuard<QObject> *guards;
+    QDeclarativeGuardImpl *guards;
 
     static QDeclarativeData *get(const QObject *object, bool create = false) {
         QObjectPrivate *priv = QObjectPrivate::get(const_cast<QObject *>(object));
@@ -160,32 +160,6 @@ private:
     mutable QDeclarativeDataExtended *extendedData;
 };
 
-template<class T>
-void QDeclarativeGuard<T>::addGuard()
-{
-    Q_ASSERT(!prev);
-
-    if (QObjectPrivate::get(o)->wasDeleted) 
-        return;
-
-    QDeclarativeData *data = QDeclarativeData::get(o, true);
-    next = data->guards;
-    if (next) reinterpret_cast<QDeclarativeGuard<T> *>(next)->prev = &next;
-    data->guards = reinterpret_cast<QDeclarativeGuard<QObject> *>(this);
-    prev = &data->guards;
-}
-
-template<class T>
-void QDeclarativeGuard<T>::remGuard()
-{
-    Q_ASSERT(prev);
-
-    if (next) reinterpret_cast<QDeclarativeGuard<T> *>(next)->prev = prev;
-    *prev = next;
-    next = 0;
-    prev = 0;
-}
-
 QT_END_NAMESPACE
 
 #endif // QDECLARATIVEDATA_P_H
diff --git a/src/declarative/qml/qdeclarativedirparser.cpp b/src/declarative/qml/qdeclarativedirparser.cpp
index 0a7a749..1d4db40 100644
--- a/src/declarative/qml/qdeclarativedirparser.cpp
+++ b/src/declarative/qml/qdeclarativedirparser.cpp
@@ -160,6 +160,16 @@ bool QDeclarativeDirParser::parse()
             Component entry(sections[1], sections[2], -1, -1);
             entry.internal = true;
             _components.append(entry);
+        } else if (sections[0] == QLatin1String("typeinfo")) {
+            if (sectionCount != 2) {
+                reportError(lineNumber, -1,
+                            QString::fromUtf8("typeinfo requires 1 argument, but %1 were provided").arg(sectionCount - 1));
+                continue;
+            }
+#ifdef QT_CREATOR
+            TypeInfo typeInfo(sections[1]);
+            _typeInfos.append(typeInfo);
+#endif
 
         } else if (sectionCount == 2) {
             // No version specified (should only be used for relative qmldir files)
@@ -229,4 +239,11 @@ QList<QDeclarativeDirParser::Component> QDeclarativeDirParser::components() cons
     return _components;
 }
 
+#ifdef QT_CREATOR
+QList<QDeclarativeDirParser::TypeInfo> QDeclarativeDirParser::typeInfos() const
+{
+    return _typeInfos;
+}
+#endif
+
 QT_END_NAMESPACE
diff --git a/src/declarative/qml/qdeclarativedirparser_p.h b/src/declarative/qml/qdeclarativedirparser_p.h
index 7db7d8c..d40833a 100644
--- a/src/declarative/qml/qdeclarativedirparser_p.h
+++ b/src/declarative/qml/qdeclarativedirparser_p.h
@@ -109,6 +109,19 @@ public:
     QList<Component> components() const;
     QList<Plugin> plugins() const;
 
+#ifdef QT_CREATOR
+    struct TypeInfo
+    {
+        TypeInfo() {}
+        TypeInfo(const QString &fileName)
+            : fileName(fileName) {}
+
+        QString fileName;
+    };
+
+    QList<TypeInfo> typeInfos() const;
+#endif
+
 private:
     void reportError(int line, int column, const QString &message);
 
@@ -118,6 +131,9 @@ private:
     QString _source;
     QList<Component> _components;
     QList<Plugin> _plugins;
+#ifdef QT_CREATOR
+    QList<TypeInfo> _typeInfos;
+#endif
     unsigned _isParsed: 1;
 };
 
diff --git a/src/declarative/qml/qdeclarativeengine.cpp b/src/declarative/qml/qdeclarativeengine.cpp
index e28b95e..34014f7 100644
--- a/src/declarative/qml/qdeclarativeengine.cpp
+++ b/src/declarative/qml/qdeclarativeengine.cpp
@@ -71,6 +71,7 @@
 #include "private/qdeclarativenotifier_p.h"
 #include "private/qdeclarativedebugtrace_p.h"
 #include "private/qdeclarativeapplication_p.h"
+#include "private/qjsdebugservice_p.h"
 
 #include <QtCore/qmetaobject.h>
 #include <QScriptClass>
@@ -123,7 +124,7 @@ QT_BEGIN_NAMESPACE
   \brief The QtObject element is the most basic element in QML.
 
   The QtObject element is a non-visual element which contains only the
-  objectName property. 
+  objectName property.
 
   It can be useful to create a QtObject if you need an extremely
   lightweight element to enclose a set of custom properties:
@@ -138,7 +139,7 @@ QT_BEGIN_NAMESPACE
   This property holds the QObject::objectName for this specific object instance.
 
   This allows a C++ application to locate an item within a QML component
-  using the QObject::findChild() method. For example, the following C++ 
+  using the QObject::findChild() method. For example, the following C++
   application locates the child \l Rectangle item and dynamically changes its
   \c color value:
 
@@ -152,7 +153,7 @@ QT_BEGIN_NAMESPACE
 
         Rectangle {
             anchors.fill: parent
-            color: "red" 
+            color: "red"
             objectName: "myRect"
         }
     }
@@ -166,7 +167,7 @@ QT_BEGIN_NAMESPACE
     view.show();
 
     QDeclarativeItem *item = view.rootObject()->findChild<QDeclarativeItem*>("myRect");
-    if (item) 
+    if (item)
         item->setProperty("color", QColor(Qt::yellow));
     \endcode
 */
@@ -202,7 +203,7 @@ void QDeclarativeEnginePrivate::defineModule()
 
 \keyword QmlGlobalQtObject
 
-\brief The \c Qt object provides useful enums and functions from Qt, for use in all QML files. 
+\brief The \c Qt object provides useful enums and functions from Qt, for use in all QML files.
 
 The \c Qt object is a global object with utility functions, properties and enums.
 
@@ -583,6 +584,7 @@ void QDeclarativeEnginePrivate::init()
         QDeclarativeEngineDebugServer::isDebuggingEnabled()) {
         isDebugging = true;
         QDeclarativeEngineDebugServer::instance()->addEngine(q);
+        QJSDebugService::instance()->addEngine(q);
     }
 }
 
@@ -645,8 +647,10 @@ QDeclarativeEngine::QDeclarativeEngine(QObject *parent)
 QDeclarativeEngine::~QDeclarativeEngine()
 {
     Q_D(QDeclarativeEngine);
-    if (d->isDebugging)
+    if (d->isDebugging) {
         QDeclarativeEngineDebugServer::instance()->remEngine(this);
+        QJSDebugService::instance()->removeEngine(this);
+    }
 }
 
 /*! \fn void QDeclarativeEngine::quit()
@@ -757,7 +761,7 @@ QNetworkAccessManager *QDeclarativeEngine::networkAccessManager() const
 /*!
 
   Sets the \a provider to use for images requested via the \e
-  image: url scheme, with host \a providerId. The QDeclarativeEngine 
+  image: url scheme, with host \a providerId. The QDeclarativeEngine
   takes ownership of \a provider.
 
   Image providers enable support for pixmap and threaded image
@@ -767,9 +771,6 @@ QNetworkAccessManager *QDeclarativeEngine::networkAccessManager() const
   All required image providers should be added to the engine before any
   QML sources files are loaded.
 
-  Note that images loaded from a QDeclarativeImageProvider are cached
-  by QPixmapCache, similar to any image loaded by QML.
-
   \sa removeImageProvider()
 */
 void QDeclarativeEngine::addImageProvider(const QString &providerId, QDeclarativeImageProvider *provider)
@@ -1066,7 +1067,7 @@ QObject *qmlAttachedPropertiesObjectById(int id, const QObject *object, bool cre
 
     rv = pf(const_cast<QObject *>(object));
 
-    if (rv) 
+    if (rv)
         data->attachedProperties()->insert(id, rv);
 
     return rv;
@@ -1084,6 +1085,17 @@ QObject *qmlAttachedPropertiesObject(int *idCache, const QObject *object,
     return qmlAttachedPropertiesObjectById(*idCache, object, create);
 }
 
+QDeclarativeDebuggingEnabler::QDeclarativeDebuggingEnabler()
+{
+#ifndef QDECLARATIVE_NO_DEBUG_PROTOCOL
+    if (!QDeclarativeEnginePrivate::qml_debugging_enabled) {
+        qWarning("Qml debugging is enabled. Only use this in a safe environment!");
+    }
+    QDeclarativeEnginePrivate::qml_debugging_enabled = true;
+#endif
+}
+
+
 class QDeclarativeDataExtended {
 public:
     QDeclarativeDataExtended();
@@ -1142,7 +1154,7 @@ void QDeclarativeData::destroyed(QObject *object)
         context->destroy();
 
     while (guards) {
-        QDeclarativeGuard<QObject> *guard = guards;
+        QDeclarativeGuard<QObject> *guard = static_cast<QDeclarativeGuard<QObject> *>(guards);
         *guard = (QObject *)0;
         guard->objectDestroyed(object);
     }
@@ -1258,7 +1270,7 @@ Returns a \l Component object created using the QML file at the specified \a url
 or \c null if an empty string was given.
 
 The returned component's \l Component::status property indicates whether the
-component was successfully created. If the status is \c Component.Error, 
+component was successfully created. If the status is \c Component.Error,
 see \l Component::errorString() for an error description.
 
 Call \l {Component::createObject()}{Component.createObject()} on the returned
@@ -1311,6 +1323,8 @@ Example (where \c parentItem is the id of an existing QML item):
 In the case of an error, a QtScript Error object is thrown. This object has an additional property,
 \c qmlErrors, which is an array of the errors encountered.
 Each object in this array has the members \c lineNumber, \c columnNumber, \c fileName and \c message.
+For example, if the above snippet had misspelled color as 'colro' then the array would contain an object like the following:
+{ "lineNumber" : 1, "columnNumber" : 32, "fileName" : "dynamicSnippet1", "message" : "Cannot assign to non-existent property \"colro\""}.
 
 Note that this function returns immediately, and therefore may not work if
 the \a qml string loads new components (that is, external QML files that have not yet been loaded).
@@ -1434,7 +1448,7 @@ QScriptValue QDeclarativeEnginePrivate::vector3d(QScriptContext *ctxt, QScriptEn
     qsreal x = ctxt->argument(0).toNumber();
     qsreal y = ctxt->argument(1).toNumber();
     qsreal z = ctxt->argument(2).toNumber();
-    return QDeclarativeEnginePrivate::get(engine)->scriptValueFromVariant(qVariantFromValue(QVector3D(x, y, z)));
+    return QDeclarativeEnginePrivate::get(engine)->scriptValueFromVariant(QVariant::fromValue(QVector3D(x, y, z)));
 }
 
 /*!
@@ -1464,14 +1478,14 @@ QScriptValue QDeclarativeEnginePrivate::formatDate(QScriptContext*ctxt, QScriptE
         QScriptValue formatArg = ctxt->argument(1);
         if (formatArg.isString()) {
             QString format = formatArg.toString();
-            return engine->newVariant(qVariantFromValue(date.toString(format)));
+            return engine->newVariant(QVariant::fromValue(date.toString(format)));
         } else if (formatArg.isNumber()) {
             enumFormat = Qt::DateFormat(formatArg.toUInt32());
         } else {
             return ctxt->throwError(QLatin1String("Qt.formatDate(): Invalid date format"));
         }
     }
-    return engine->newVariant(qVariantFromValue(date.toString(enumFormat)));
+    return engine->newVariant(QVariant::fromValue(date.toString(enumFormat)));
 }
 
 /*!
@@ -1505,14 +1519,14 @@ QScriptValue QDeclarativeEnginePrivate::formatTime(QScriptContext*ctxt, QScriptE
         QScriptValue formatArg = ctxt->argument(1);
         if (formatArg.isString()) {
             QString format = formatArg.toString();
-            return engine->newVariant(qVariantFromValue(time.toString(format)));
+            return engine->newVariant(QVariant::fromValue(time.toString(format)));
         } else if (formatArg.isNumber()) {
             enumFormat = Qt::DateFormat(formatArg.toUInt32());
         } else {
             return ctxt->throwError(QLatin1String("Qt.formatTime(): Invalid time format"));
         }
     }
-    return engine->newVariant(qVariantFromValue(time.toString(enumFormat)));
+    return engine->newVariant(QVariant::fromValue(time.toString(enumFormat)));
 }
 
 /*!
@@ -1615,14 +1629,14 @@ QScriptValue QDeclarativeEnginePrivate::formatDateTime(QScriptContext*ctxt, QScr
         QScriptValue formatArg = ctxt->argument(1);
         if (formatArg.isString()) {
             QString format = formatArg.toString();
-            return engine->newVariant(qVariantFromValue(date.toString(format)));
+            return engine->newVariant(QVariant::fromValue(date.toString(format)));
         } else if (formatArg.isNumber()) {
             enumFormat = Qt::DateFormat(formatArg.toUInt32());
-        } else { 
+        } else {
             return ctxt->throwError(QLatin1String("Qt.formatDateTime(): Invalid datetime format"));
         }
     }
-    return engine->newVariant(qVariantFromValue(date.toString(enumFormat)));
+    return engine->newVariant(QVariant::fromValue(date.toString(enumFormat)));
 }
 #endif // QT_NO_DATESTRING
 
@@ -1651,7 +1665,7 @@ QScriptValue QDeclarativeEnginePrivate::rgba(QScriptContext *ctxt, QScriptEngine
     if (a < 0.0) a=0.0;
     if (a > 1.0) a=1.0;
 
-    return qScriptValueFromValue(engine, qVariantFromValue(QColor::fromRgbF(r, g, b, a)));
+    return engine->toScriptValue(QVariant::fromValue(QColor::fromRgbF(r, g, b, a)));
 }
 
 /*!
@@ -1679,11 +1693,11 @@ QScriptValue QDeclarativeEnginePrivate::hsla(QScriptContext *ctxt, QScriptEngine
     if (a < 0.0) a=0.0;
     if (a > 1.0) a=1.0;
 
-    return qScriptValueFromValue(engine, qVariantFromValue(QColor::fromHslF(h, s, l, a)));
+    return engine->toScriptValue(QVariant::fromValue(QColor::fromHslF(h, s, l, a)));
 }
 
 /*!
-\qmlmethod rect Qt::rect(int x, int y, int width, int height) 
+\qmlmethod rect Qt::rect(int x, int y, int width, int height)
 
 Returns a \c rect with the top-left corner at \c x, \c y and the specified \c width and \c height.
 
@@ -1699,10 +1713,7 @@ QScriptValue QDeclarativeEnginePrivate::rect(QScriptContext *ctxt, QScriptEngine
     qsreal w = ctxt->argument(2).toNumber();
     qsreal h = ctxt->argument(3).toNumber();
 
-    if (w < 0 || h < 0)
-        return engine->nullValue();
-
-    return QDeclarativeEnginePrivate::get(engine)->scriptValueFromVariant(qVariantFromValue(QRectF(x, y, w, h)));
+    return QDeclarativeEnginePrivate::get(engine)->scriptValueFromVariant(QVariant::fromValue(QRectF(x, y, w, h)));
 }
 
 /*!
@@ -1715,7 +1726,7 @@ QScriptValue QDeclarativeEnginePrivate::point(QScriptContext *ctxt, QScriptEngin
         return ctxt->throwError(QLatin1String("Qt.point(): Invalid arguments"));
     qsreal x = ctxt->argument(0).toNumber();
     qsreal y = ctxt->argument(1).toNumber();
-    return QDeclarativeEnginePrivate::get(engine)->scriptValueFromVariant(qVariantFromValue(QPointF(x, y)));
+    return QDeclarativeEnginePrivate::get(engine)->scriptValueFromVariant(QVariant::fromValue(QPointF(x, y)));
 }
 
 /*!
@@ -1728,7 +1739,7 @@ QScriptValue QDeclarativeEnginePrivate::size(QScriptContext *ctxt, QScriptEngine
         return ctxt->throwError(QLatin1String("Qt.size(): Invalid arguments"));
     qsreal w = ctxt->argument(0).toNumber();
     qsreal h = ctxt->argument(1).toNumber();
-    return QDeclarativeEnginePrivate::get(engine)->scriptValueFromVariant(qVariantFromValue(QSizeF(w, h)));
+    return QDeclarativeEnginePrivate::get(engine)->scriptValueFromVariant(QVariant::fromValue(QSizeF(w, h)));
 }
 
 /*!
@@ -1764,7 +1775,7 @@ QScriptValue QDeclarativeEnginePrivate::lighter(QScriptContext *ctxt, QScriptEng
     if (ctxt->argumentCount() == 2)
         factor = ctxt->argument(1).toNumber();
     color = color.lighter(int(qRound(factor*100.)));
-    return qScriptValueFromValue(engine, qVariantFromValue(color));
+    return engine->toScriptValue(QVariant::fromValue(color));
 }
 
 /*!
@@ -1801,7 +1812,7 @@ QScriptValue QDeclarativeEnginePrivate::darker(QScriptContext *ctxt, QScriptEngi
     if (ctxt->argumentCount() == 2)
         factor = ctxt->argument(1).toNumber();
     color = color.darker(int(qRound(factor*100.)));
-    return qScriptValueFromValue(engine, qVariantFromValue(color));
+    return engine->toScriptValue(QVariant::fromValue(color));
 }
 
 /*!
@@ -1855,7 +1866,7 @@ Binary to ASCII - this function returns a base64 encoding of \c data.
 */
 QScriptValue QDeclarativeEnginePrivate::btoa(QScriptContext *ctxt, QScriptEngine *)
 {
-    if (ctxt->argumentCount() != 1) 
+    if (ctxt->argumentCount() != 1)
         return ctxt->throwError(QLatin1String("Qt.btoa(): Invalid arguments"));
 
     QByteArray data = ctxt->argument(0).toString().toUtf8();
@@ -1870,7 +1881,7 @@ ASCII to binary - this function returns a base64 decoding of \c data.
 
 QScriptValue QDeclarativeEnginePrivate::atob(QScriptContext *ctxt, QScriptEngine *)
 {
-    if (ctxt->argumentCount() != 1) 
+    if (ctxt->argumentCount() != 1)
         return ctxt->throwError(QLatin1String("Qt.atob(): Invalid arguments"));
 
     QByteArray data = ctxt->argument(0).toString().toUtf8();
@@ -2051,7 +2062,7 @@ QScriptValue QDeclarativeEnginePrivate::tint(QScriptContext *ctxt, QScriptEngine
                            a + inv_a * color.alphaF());
     }
 
-    return qScriptValueFromValue(engine, qVariantFromValue(finalColor));
+    return engine->toScriptValue(QVariant::fromValue(finalColor));
 }
 
 QScriptValue QDeclarativeEnginePrivate::scriptValueFromVariant(const QVariant &val)
@@ -2081,7 +2092,7 @@ QScriptValue QDeclarativeEnginePrivate::scriptValueFromVariant(const QVariant &v
     if (objOk) {
         return objectClass->newQObject(obj);
     } else {
-        return qScriptValueFromValue(&scriptEngine, val);
+        return scriptEngine.toScriptValue(val);
     }
 }
 
@@ -2289,7 +2300,7 @@ QDeclarativePropertyCache *QDeclarativeEnginePrivate::createCache(const QMetaObj
     }
 }
 
-QDeclarativePropertyCache *QDeclarativeEnginePrivate::createCache(QDeclarativeType *type, int minorVersion, 
+QDeclarativePropertyCache *QDeclarativeEnginePrivate::createCache(QDeclarativeType *type, int minorVersion,
                                                                   QDeclarativeError &error)
 {
     QList<QDeclarativeType *> types;
@@ -2298,7 +2309,7 @@ QDeclarativePropertyCache *QDeclarativeEnginePrivate::createCache(QDeclarativeTy
 
     const QMetaObject *metaObject = type->metaObject();
     while (metaObject) {
-        QDeclarativeType *t = QDeclarativeMetaType::qmlType(metaObject, type->module(), 
+        QDeclarativeType *t = QDeclarativeMetaType::qmlType(metaObject, type->module(),
                                                             type->majorVersion(), minorVersion);
         if (t) {
             maxMinorVersion = qMax(maxMinorVersion, t->minorVersion());
@@ -2342,7 +2353,7 @@ QDeclarativePropertyCache *QDeclarativeEnginePrivate::createCache(QDeclarativeTy
 
     // Signals override:
     //    * other signals and methods of the same name.
-    //    * properties named on<Signal Name> 
+    //    * properties named on<Signal Name>
     //    * automatic <property name>Changed notify signals
 
     // Methods override:
@@ -2367,7 +2378,7 @@ QDeclarativePropertyCache *QDeclarativeEnginePrivate::createCache(QDeclarativeTy
         QDeclarativePropertyCache::Data *current = d;
         while (!overloadError && current) {
             current = d->overrideData(current);
-            if (current && raw->isAllowedInRevision(current)) 
+            if (current && raw->isAllowedInRevision(current))
                 overloadError = true;
         }
     }
@@ -2375,7 +2386,7 @@ QDeclarativePropertyCache *QDeclarativeEnginePrivate::createCache(QDeclarativeTy
 
     if (overloadError) {
         if (hasCopied) raw->release();
-            
+
         error.setDescription(QLatin1String("Type ") + QString::fromUtf8(type->qmlTypeName()) + QLatin1String(" ") + QString::number(type->majorVersion()) + QLatin1String(".") + QString::number(minorVersion) + QLatin1String(" contains an illegal property \"") + overloadName + QLatin1String("\".  This is an error in the type's implementation."));
         return 0;
     }
diff --git a/src/declarative/qml/qdeclarativeengine_p.h b/src/declarative/qml/qdeclarativeengine_p.h
index 7bfcfac..0a3fe5d 100644
--- a/src/declarative/qml/qdeclarativeengine_p.h
+++ b/src/declarative/qml/qdeclarativeengine_p.h
@@ -95,7 +95,6 @@ class QDeclarativeImportDatabase;
 class QDeclarativeObjectScriptClass;
 class QDeclarativeTypeNameScriptClass;
 class QDeclarativeValueTypeScriptClass;
-class QScriptEngineDebugger;
 class QNetworkReply;
 class QNetworkAccessManager;
 class QDeclarativeNetworkAccessManagerFactory;
@@ -332,14 +331,14 @@ public:
 /*!
 Returns a QDeclarativePropertyCache for \a obj if one is available.
 
-If \a obj is null, being deleted or contains a dynamic meta object 0 
+If \a obj is null, being deleted or contains a dynamic meta object 0
 is returned.
 
 The returned cache is not referenced, so if it is to be stored, call addref().
 */
-QDeclarativePropertyCache *QDeclarativeEnginePrivate::cache(QObject *obj) 
+QDeclarativePropertyCache *QDeclarativeEnginePrivate::cache(QObject *obj)
 {
-    if (!obj || QObjectPrivate::get(obj)->metaObject || QObjectPrivate::get(obj)->wasDeleted) 
+    if (!obj || QObjectPrivate::get(obj)->metaObject || QObjectPrivate::get(obj)->wasDeleted)
         return 0;
 
     const QMetaObject *mo = obj->metaObject();
@@ -349,10 +348,10 @@ QDeclarativePropertyCache *QDeclarativeEnginePrivate::cache(QObject *obj)
 }
 
 /*!
-Returns a QDeclarativePropertyCache for \a metaObject.  
+Returns a QDeclarativePropertyCache for \a metaObject.
 
 As the cache is persisted for the life of the engine, \a metaObject must be
-a static "compile time" meta-object, or a meta-object that is otherwise known to 
+a static "compile time" meta-object, or a meta-object that is otherwise known to
 exist for the lifetime of the QDeclarativeEngine.
 
 The returned cache is not referenced, so if it is to be stored, call addref().
diff --git a/src/declarative/qml/qdeclarativeenginedebug.cpp b/src/declarative/qml/qdeclarativeenginedebug.cpp
index e878f19..8707a7f 100644
--- a/src/declarative/qml/qdeclarativeenginedebug.cpp
+++ b/src/declarative/qml/qdeclarativeenginedebug.cpp
@@ -147,12 +147,6 @@ QDeclarativeEngineDebugServer::propertyData(QObject *obj, int propIdx)
     if (binding)
         rv.binding = binding->expression();
 
-    QVariant value;
-    if (prop.userType() != 0) {
-        value = prop.read(obj);
-    }
-    rv.value = valueContents(value);
-
     if (QDeclarativeValueTypeFactory::isValueType(prop.userType())) {
         rv.type = QDeclarativeObjectProperty::Basic;
     } else if (QDeclarativeMetaType::isQObject(prop.userType()))  {
@@ -161,6 +155,12 @@ QDeclarativeEngineDebugServer::propertyData(QObject *obj, int propIdx)
         rv.type = QDeclarativeObjectProperty::List;
     }
 
+    QVariant value;
+    if (rv.type != QDeclarativeObjectProperty::Unknown && prop.userType() != 0) {
+        value = prop.read(obj);
+    }
+    rv.value = valueContents(value);
+
     return rv;
 }
 
@@ -524,8 +524,13 @@ void QDeclarativeEngineDebugServer::messageReceived(const QByteArray &message)
         QString propertyName;
         QVariant expr;
         bool isLiteralValue;
+        QString filename;
+        int line;
         ds >> objectId >> propertyName >> expr >> isLiteralValue;
-        setBinding(objectId, propertyName, expr, isLiteralValue);
+        if (!ds.atEnd()) { // backward compatibility from 2.1, 2.2
+            ds >> filename >> line;
+        }
+        setBinding(objectId, propertyName, expr, isLiteralValue, filename, line);
     } else if (type == "RESET_BINDING") {
         int objectId;
         QString propertyName;
@@ -543,7 +548,9 @@ void QDeclarativeEngineDebugServer::messageReceived(const QByteArray &message)
 void QDeclarativeEngineDebugServer::setBinding(int objectId,
                                                const QString &propertyName,
                                                const QVariant &expression,
-                                               bool isLiteralValue)
+                                               bool isLiteralValue,
+                                               QString filename,
+                                               int line)
 {
     QObject *object = objectForId(objectId);
     QDeclarativeContext *context = qmlContext(object);
@@ -565,6 +572,7 @@ void QDeclarativeEngineDebugServer::setBinding(int objectId,
                             newBinding = new QDeclarativeBinding(expression.toString(), object, context);
                             newBinding->setTarget(property);
                             newBinding->setNotifyOnValueChanged(true);
+                            newBinding->setSourceLocation(filename, line);
                         }
 
                         state->changeBindingInRevertList(object, propertyName, newBinding);
@@ -580,11 +588,12 @@ void QDeclarativeEngineDebugServer::setBinding(int objectId,
                     property.write(expression);
                 } else if (hasValidSignal(object, propertyName)) {
                     QDeclarativeExpression *declarativeExpression = new QDeclarativeExpression(context, object, expression.toString());
-                    QDeclarativeExpression *oldExpression = QDeclarativePropertyPrivate::setSignalExpression(property, declarativeExpression);
-                    declarativeExpression->setSourceLocation(oldExpression->sourceFile(), oldExpression->lineNumber());
+                    QDeclarativePropertyPrivate::setSignalExpression(property, declarativeExpression);
+                    declarativeExpression->setSourceLocation(filename, line);
                 } else if (property.isProperty()) {
                     QDeclarativeBinding *binding = new QDeclarativeBinding(expression.toString(), object, context);
                     binding->setTarget(property);
+                    binding->setSourceLocation(filename, line);
                     binding->setNotifyOnValueChanged(true);
                     QDeclarativeAbstractBinding *oldBinding = QDeclarativePropertyPrivate::setBinding(property, binding);
                     if (oldBinding)
@@ -644,7 +653,10 @@ void QDeclarativeEngineDebugServer::resetBinding(int objectId, const QString &pr
                     }
                 }
             }
-        } else {
+        } else if (hasValidSignal(object, propertyName)) {
+            QDeclarativeProperty property(object, propertyName, context);
+            QDeclarativePropertyPrivate::setSignalExpression(property, 0);
+    } else {
             if (QDeclarativePropertyChanges *propertyChanges = qobject_cast<QDeclarativePropertyChanges *>(object)) {
                 propertyChanges->removeProperty(propertyName);
             }
diff --git a/src/declarative/qml/qdeclarativeenginedebug_p.h b/src/declarative/qml/qdeclarativeenginedebug_p.h
index 7e7676b..804a043 100644
--- a/src/declarative/qml/qdeclarativeenginedebug_p.h
+++ b/src/declarative/qml/qdeclarativeenginedebug_p.h
@@ -115,7 +115,7 @@ private:
     QDeclarativeObjectData objectData(QObject *);
     QDeclarativeObjectProperty propertyData(QObject *, int);
     QVariant valueContents(const QVariant &defaultValue) const;
-    void setBinding(int objectId, const QString &propertyName, const QVariant &expression, bool isLiteralValue);
+    void setBinding(int objectId, const QString &propertyName, const QVariant &expression, bool isLiteralValue, QString filename = QString(), int line = -1);
     void resetBinding(int objectId, const QString &propertyName);
     void setMethodBody(int objectId, const QString &method, const QString &body);
 
diff --git a/src/declarative/qml/qdeclarativeguard_p.h b/src/declarative/qml/qdeclarativeguard_p.h
index a085258..4d84951 100644
--- a/src/declarative/qml/qdeclarativeguard_p.h
+++ b/src/declarative/qml/qdeclarativeguard_p.h
@@ -55,16 +55,30 @@
 
 #include <QtCore/qglobal.h>
 #include <QtCore/qvariant.h>
+#include <private/qdeclarativedata_p.h>
 
 QT_BEGIN_NAMESPACE
 
+class QDeclarativeGuardImpl 
+{
+public:
+    inline QDeclarativeGuardImpl();
+    inline QDeclarativeGuardImpl(QObject *);
+    inline QDeclarativeGuardImpl(const QDeclarativeGuardImpl &);
+    inline ~QDeclarativeGuardImpl();
+
+    QObject *o;
+    QDeclarativeGuardImpl  *next;
+    QDeclarativeGuardImpl **prev;
+
+    inline void addGuard();
+    inline void remGuard();
+};
+
 class QObject;
 template<class T>
-class QDeclarativeGuard
+class QDeclarativeGuard : private QDeclarativeGuardImpl
 {
-    QObject *o;
-    QDeclarativeGuard<QObject> *next;
-    QDeclarativeGuard<QObject> **prev;
     friend class QDeclarativeData;
 public:
     inline QDeclarativeGuard();
@@ -74,6 +88,9 @@ public:
 
     inline QDeclarativeGuard<T> &operator=(const QDeclarativeGuard<T> &o);
     inline QDeclarativeGuard<T> &operator=(T *);
+
+    inline T *object() const;
+    inline void setObject(T *g);
     
     inline bool isNull() const
         { return !o; }
@@ -89,69 +106,109 @@ public:
 
 protected:
     virtual void objectDestroyed(T *) {}
-
-private:
-    inline void addGuard();
-    inline void remGuard();
 };
 
-QT_END_NAMESPACE
+QDeclarativeGuardImpl::QDeclarativeGuardImpl()
+: o(0), next(0), prev(0)
+{
+}
 
-Q_DECLARE_METATYPE(QDeclarativeGuard<QObject>)
+QDeclarativeGuardImpl::QDeclarativeGuardImpl(QObject *g)
+: o(g), next(0), prev(0)
+{
+    if (o) addGuard();
+}
 
-#include "private/qdeclarativedata_p.h"
+QDeclarativeGuardImpl::QDeclarativeGuardImpl(const QDeclarativeGuardImpl &g)
+: o(g.o), next(0), prev(0)
+{
+    if (o) addGuard();
+}
 
-QT_BEGIN_NAMESPACE
+QDeclarativeGuardImpl::~QDeclarativeGuardImpl()
+{
+    if (prev) remGuard();
+    o = 0;
+}
+
+void QDeclarativeGuardImpl::addGuard()
+{
+    Q_ASSERT(!prev);
+
+    if (QObjectPrivate::get(o)->wasDeleted) 
+        return;
+
+    QDeclarativeData *data = QDeclarativeData::get(o, true);
+    next = data->guards;
+    if (next) next->prev = &next;
+    data->guards = this;
+    prev = &data->guards;
+}
+
+void QDeclarativeGuardImpl::remGuard()
+{
+    Q_ASSERT(prev);
+
+    if (next) next->prev = prev;
+    *prev = next;
+    next = 0;
+    prev = 0;
+}
 
 template<class T>
 QDeclarativeGuard<T>::QDeclarativeGuard()
-: o(0), next(0), prev(0)
 {
 }
 
 template<class T>
 QDeclarativeGuard<T>::QDeclarativeGuard(T *g)
-: o(g), next(0), prev(0)
+: QDeclarativeGuardImpl(g)
 {
-    if (o) addGuard();
 }
 
 template<class T>
 QDeclarativeGuard<T>::QDeclarativeGuard(const QDeclarativeGuard<T> &g)
-: o(g.o), next(0), prev(0)
+: QDeclarativeGuardImpl(g)
 {
-    if (o) addGuard();
 }
 
 template<class T>
 QDeclarativeGuard<T>::~QDeclarativeGuard()
 {
-    if (prev) remGuard();
-    o = 0;
 }
 
 template<class T>
 QDeclarativeGuard<T> &QDeclarativeGuard<T>::operator=(const QDeclarativeGuard<T> &g)
 {
-    if (g.o != o) {
-        if (prev) remGuard();
-        o = g.o;
-        if (o) addGuard();
-    }
+    setObject(g.object());
     return *this;
 }
 
 template<class T>
 QDeclarativeGuard<T> &QDeclarativeGuard<T>::operator=(T *g)
 {
+    setObject(g);
+    return *this;
+}
+
+template<class T>
+T *QDeclarativeGuard<T>::object() const 
+{ 
+    return static_cast<T *>(o); 
+};
+
+template<class T>
+void QDeclarativeGuard<T>::setObject(T *g) 
+{
     if (g != o) {
         if (prev) remGuard();
         o = g;
         if (o) addGuard();
     }
-    return *this;
 }
 
 QT_END_NAMESPACE
 
+Q_DECLARE_METATYPE(QDeclarativeGuard<QObject>)
+
 #endif // QDECLARATIVEGUARD_P_H
diff --git a/src/declarative/qml/qdeclarativeimageprovider.cpp b/src/declarative/qml/qdeclarativeimageprovider.cpp
index 559adf4..fa88c00 100644
--- a/src/declarative/qml/qdeclarativeimageprovider.cpp
+++ b/src/declarative/qml/qdeclarativeimageprovider.cpp
@@ -136,7 +136,8 @@ public:
 
     Image providers that support QImage loading automatically include support
     for asychronous loading of images. To enable asynchronous loading for an
-    \l Image source, set \l Image::asynchronous to \c true. When this is enabled, 
+    image source, set the \c asynchronous property to \c true for the relevant
+    \l Image, \l BorderImage or \l AnimatedImage object. When this is enabled, 
     the image request to the provider is run in a low priority thread,
     allowing image loading to be executed in the background, and reducing the
     performance impact on the user interface.
@@ -147,6 +148,17 @@ public:
     \c true, the value is ignored and the image is loaded
     synchronously.
 
+
+    \section2 Image caching
+
+    Images returned by a QDeclarativeImageProvider are automatically cached,
+    similar to any image loaded by the QML engine. When an image with a
+    "image://" prefix is loaded from cache, requestImage() and requestPixmap()
+    will not be called for the relevant image provider. If an image should always
+    be fetched from the image provider, and should not be cached at all, set the
+    \c cache property to \c false for the relevant \l Image, \l BorderImage or
+    \l AnimatedImage object.
+
     \sa QDeclarativeEngine::addImageProvider()
 */
 
diff --git a/src/declarative/qml/qdeclarativeimport.cpp b/src/declarative/qml/qdeclarativeimport.cpp
index 6e0b348..bf261ef 100644
--- a/src/declarative/qml/qdeclarativeimport.cpp
+++ b/src/declarative/qml/qdeclarativeimport.cpp
@@ -722,6 +722,7 @@ QDeclarativeImportDatabase::QDeclarativeImportDatabase(QDeclarativeEngine *e)
 
     // Search order is applicationDirPath(), $QML_IMPORT_PATH, QLibraryInfo::ImportsPath
 
+#ifndef QT_NO_SETTINGS
     QString installImportsPath =  QLibraryInfo::location(QLibraryInfo::ImportsPath);
 
 #if defined(Q_OS_SYMBIAN)
@@ -748,6 +749,9 @@ QDeclarativeImportDatabase::QDeclarativeImportDatabase(QDeclarativeEngine *e)
 #else
     addImportPath(installImportsPath);
 #endif
+
+#endif // QT_NO_SETTINGS
+
     // env import paths
     QByteArray envImportPath = qgetenv("QML_IMPORT_PATH");
     if (!envImportPath.isEmpty()) {
@@ -1014,6 +1018,7 @@ bool QDeclarativeImportDatabase::importPlugin(const QString &filePath, const QSt
     if (qmlImportTrace())
         qDebug().nospace() << "QDeclarativeImportDatabase::importPlugin: " << uri << " from " << filePath;
 
+#ifndef QT_NO_LIBRARY
     QFileInfo fileInfo(filePath);
     const QString absoluteFilePath = fileInfo.absoluteFilePath();
 
@@ -1065,6 +1070,9 @@ bool QDeclarativeImportDatabase::importPlugin(const QString &filePath, const QSt
     }
 
     return true;
+#else
+    return false;
+#endif
 }
 
 
diff --git a/src/declarative/qml/qdeclarativeobjectscriptclass.cpp b/src/declarative/qml/qdeclarativeobjectscriptclass.cpp
index 1ac5007..f6f593c 100644
--- a/src/declarative/qml/qdeclarativeobjectscriptclass.cpp
+++ b/src/declarative/qml/qdeclarativeobjectscriptclass.cpp
@@ -54,7 +54,15 @@
 #include <QtCore/qvarlengtharray.h>
 #include <QtScript/qscriptcontextinfo.h>
 
-Q_DECLARE_METATYPE(QScriptValue);
+Q_DECLARE_METATYPE(QScriptValue)
+
+#if defined(__GNUC__)
+# if (__GNUC__ * 100 + __GNUC_MINOR__) >= 405
+// The code in this file does not violate strict aliasing, but GCC thinks it does
+// so turn off the warnings for us to have a clean build
+#  pragma GCC diagnostic ignored "-Wstrict-aliasing"
+# endif
+#endif
 
 QT_BEGIN_NAMESPACE
 
@@ -395,6 +403,33 @@ void QDeclarativeObjectScriptClass::setProperty(QObject *obj,
     } else if (value.isFunction() && !value.isRegExp()) {
         // this is handled by the binding creation above
     } else {
+        //### expand optimization for other known types
+        if (lastData->propType == QMetaType::Int && value.isNumber()) {
+            int rawValue = qRound(value.toNumber());
+            int status = -1;
+            int flags = 0;
+            void *a[] = { (void *)&rawValue, 0, &status, &flags };
+            QMetaObject::metacall(obj, QMetaObject::WriteProperty,
+                                  lastData->coreIndex, a);
+            return;
+        } else if (lastData->propType == QMetaType::QReal && value.isNumber()) {
+            qreal rawValue = qreal(value.toNumber());
+            int status = -1;
+            int flags = 0;
+            void *a[] = { (void *)&rawValue, 0, &status, &flags };
+            QMetaObject::metacall(obj, QMetaObject::WriteProperty,
+                                  lastData->coreIndex, a);
+            return;
+        } else if (lastData->propType == QMetaType::QString && value.isString()) {
+            const QString &rawValue = value.toString();
+            int status = -1;
+            int flags = 0;
+            void *a[] = { (void *)&rawValue, 0, &status, &flags };
+            QMetaObject::metacall(obj, QMetaObject::WriteProperty,
+                                  lastData->coreIndex, a);
+            return;
+        }
+
         QVariant v;
         if (lastData->flags & QDeclarativePropertyCache::Data::IsQList)
             v = enginePriv->scriptValueToVariant(value, qMetaTypeId<QList<QObject *> >());
@@ -645,14 +680,30 @@ private:
 
     inline void cleanup();
 
-    char data[4 * sizeof(void *)];
+    union {
+        float floatValue;
+        double doubleValue;
+        quint32 intValue;
+        bool boolValue;
+        QObject *qobjectPtr;
+
+        char allocData[sizeof(QVariant)];
+    };
+
+    // Pointers to allocData
+    union {
+        QString *qstringPtr;
+        QVariant *qvariantPtr;
+        QList<QObject *> *qlistPtr;
+        QScriptValue *qscriptValuePtr;
+    };
+
     int type;
-    bool isObjectType;
 };
 }
 
 MetaCallArgument::MetaCallArgument()
-: type(QVariant::Invalid), isObjectType(false)
+: type(QVariant::Invalid)
 {
 }
 
@@ -664,22 +715,22 @@ MetaCallArgument::~MetaCallArgument()
 void MetaCallArgument::cleanup()
 {
     if (type == QMetaType::QString) {
-        ((QString *)&data)->~QString();
-    } else if (type == -1 || type == qMetaTypeId<QVariant>()) {
-        ((QVariant *)&data)->~QVariant();
+        qstringPtr->~QString();
+    } else if (type == -1 || type == QMetaType::QVariant) {
+        qvariantPtr->~QVariant();
     } else if (type == qMetaTypeId<QScriptValue>()) {
-        ((QScriptValue *)&data)->~QScriptValue();
+        qscriptValuePtr->~QScriptValue();
     } else if (type == qMetaTypeId<QList<QObject *> >()) {
-        ((QList<QObject *> *)&data)->~QList<QObject *>();
+        qlistPtr->~QList<QObject *>();
     }
 }
 
 void *MetaCallArgument::dataPtr()
 {
     if (type == -1)
-        return ((QVariant *)data)->data();
-    else
-        return (void *)&data;
+        return qvariantPtr->data();
+    else 
+        return (void *)&allocData;
 }
 
 void MetaCallArgument::initAsType(int callType, QDeclarativeEngine *e)
@@ -690,7 +741,7 @@ void MetaCallArgument::initAsType(int callType, QDeclarativeEngine *e)
     QScriptEngine *engine = QDeclarativeEnginePrivate::getScriptEngine(e);
 
     if (callType == qMetaTypeId<QScriptValue>()) {
-        new (&data) QScriptValue(engine->undefinedValue());
+        qscriptValuePtr = new (&allocData) QScriptValue(engine->undefinedValue());
         type = callType;
     } else if (callType == QMetaType::Int ||
                callType == QMetaType::UInt ||
@@ -699,20 +750,20 @@ void MetaCallArgument::initAsType(int callType, QDeclarativeEngine *e)
                callType == QMetaType::Float) {
         type = callType;
     } else if (callType == QMetaType::QObjectStar) {
-        *((QObject **)&data) = 0;
+        qobjectPtr = 0;
         type = callType;
     } else if (callType == QMetaType::QString) {
-        new (&data) QString();
+        qstringPtr = new (&allocData) QString();
         type = callType;
     } else if (callType == qMetaTypeId<QVariant>()) {
         type = callType;
-        new (&data) QVariant();
+        qvariantPtr = new (&allocData) QVariant();
     } else if (callType == qMetaTypeId<QList<QObject *> >()) {
         type = callType;
-        new (&data) QList<QObject *>();
+        qlistPtr = new (&allocData) QList<QObject *>();
     } else {
         type = -1;
-        new (&data) QVariant(callType, (void *)0);
+        qvariantPtr = new (&allocData) QVariant(callType, (void *)0);
     }
 }
 
@@ -721,59 +772,60 @@ void MetaCallArgument::fromScriptValue(int callType, QDeclarativeEngine *engine,
     if (type != 0) { cleanup(); type = 0; }
 
     if (callType == qMetaTypeId<QScriptValue>()) {
-        new (&data) QScriptValue(value);
+        qscriptValuePtr = new (&allocData) QScriptValue(value);
         type = qMetaTypeId<QScriptValue>();
     } else if (callType == QMetaType::Int) {
-        *((int *)&data) = int(value.toInt32());
+        intValue = quint32(value.toInt32());
         type = callType;
     } else if (callType == QMetaType::UInt) {
-        *((uint *)&data) = uint(value.toUInt32());
+        intValue = quint32(value.toUInt32());
         type = callType;
     } else if (callType == QMetaType::Bool) {
-        *((bool *)&data) = value.toBool();
+        boolValue = value.toBool();
         type = callType;
     } else if (callType == QMetaType::Double) {
-        *((double *)&data) = double(value.toNumber());
+        doubleValue = double(value.toNumber());
         type = callType;
     } else if (callType == QMetaType::Float) {
-        *((float *)&data) = float(value.toNumber());
+        floatValue = float(value.toNumber());
         type = callType;
     } else if (callType == QMetaType::QString) {
         if (value.isNull() || value.isUndefined())
-            new (&data) QString();
+            qstringPtr = new (&allocData) QString();
         else
-            new (&data) QString(value.toString());
+            qstringPtr = new (&allocData) QString(value.toString());
         type = callType;
     } else if (callType == QMetaType::QObjectStar) {
-        *((QObject **)&data) = value.toQObject();
+        qobjectPtr = value.toQObject();
         type = callType;
     } else if (callType == qMetaTypeId<QVariant>()) {
-        new (&data) QVariant(QDeclarativeEnginePrivate::get(engine)->scriptValueToVariant(value));
+        QVariant other = QDeclarativeEnginePrivate::get(engine)->scriptValueToVariant(value);
+        qvariantPtr = new (&allocData) QVariant(other);
         type = callType;
     } else if (callType == qMetaTypeId<QList<QObject*> >()) {
-        QList<QObject *> *list = new (&data) QList<QObject *>(); 
+        qlistPtr = new (&allocData) QList<QObject *>(); 
         if (value.isArray()) {
             int length = value.property(QLatin1String("length")).toInt32();
             for (int ii = 0; ii < length; ++ii) {
                 QScriptValue arrayItem = value.property(ii);
                 QObject *d = arrayItem.toQObject();
-                list->append(d);
+                qlistPtr->append(d);
             }
         } else if (QObject *d = value.toQObject()) {
-            list->append(d);
+            qlistPtr->append(d);
         }
         type = callType;
     } else {
-        new (&data) QVariant();
+        qvariantPtr = new (&allocData) QVariant();
         type = -1;
 
         QDeclarativeEnginePrivate *priv = QDeclarativeEnginePrivate::get(engine);
         QVariant v = priv->scriptValueToVariant(value);
         if (v.userType() == callType) {
-            *((QVariant *)&data) = v;
+            *qvariantPtr = v;
         } else if (v.canConvert((QVariant::Type)callType)) {
-            *((QVariant *)&data) = v;
-            ((QVariant *)&data)->convert((QVariant::Type)callType);
+            *qvariantPtr = v;
+            qvariantPtr->convert((QVariant::Type)callType);
         } else if (const QMetaObject *mo = priv->rawMetaObjectForType(callType)) {
             QObject *obj = priv->toQObject(v);
             
@@ -783,9 +835,9 @@ void MetaCallArgument::fromScriptValue(int callType, QDeclarativeEngine *engine,
                 if (!objMo) obj = 0;
             }
 
-            *((QVariant *)&data) = QVariant(callType, &obj);
+            *qvariantPtr = QVariant(callType, &obj);
         } else {
-            *((QVariant *)&data) = QVariant(callType, (void *)0);
+            *qvariantPtr = QVariant(callType, (void *)0);
         }
     }
 }
@@ -795,27 +847,26 @@ QScriptDeclarativeClass::Value MetaCallArgument::toValue(QDeclarativeEngine *e)
     QScriptEngine *engine = QDeclarativeEnginePrivate::getScriptEngine(e);
 
     if (type == qMetaTypeId<QScriptValue>()) {
-        return QScriptDeclarativeClass::Value(engine, *((QScriptValue *)&data));
+        return QScriptDeclarativeClass::Value(engine, *qscriptValuePtr);
     } else if (type == QMetaType::Int) {
-        return QScriptDeclarativeClass::Value(engine, *((int *)&data));
+        return QScriptDeclarativeClass::Value(engine, int(intValue));
     } else if (type == QMetaType::UInt) {
-        return QScriptDeclarativeClass::Value(engine, *((uint *)&data));
+        return QScriptDeclarativeClass::Value(engine, uint(intValue));
     } else if (type == QMetaType::Bool) {
-        return QScriptDeclarativeClass::Value(engine, *((bool *)&data));
+        return QScriptDeclarativeClass::Value(engine, boolValue);
     } else if (type == QMetaType::Double) {
-        return QScriptDeclarativeClass::Value(engine, *((double *)&data));
+        return QScriptDeclarativeClass::Value(engine, doubleValue);
     } else if (type == QMetaType::Float) {
-        return QScriptDeclarativeClass::Value(engine, *((float *)&data));
+        return QScriptDeclarativeClass::Value(engine, floatValue);
     } else if (type == QMetaType::QString) {
-        return QScriptDeclarativeClass::Value(engine, *((QString *)&data));
+        return QScriptDeclarativeClass::Value(engine, *qstringPtr);
     } else if (type == QMetaType::QObjectStar) {
-        QObject *object = *((QObject **)&data);
-        if (object)
-            QDeclarativeData::get(object, true)->setImplicitDestructible();
+        if (qobjectPtr)
+            QDeclarativeData::get(qobjectPtr, true)->setImplicitDestructible();
         QDeclarativeEnginePrivate *priv = QDeclarativeEnginePrivate::get(e);
-        return QScriptDeclarativeClass::Value(engine, priv->objectClass->newQObject(object));
+        return QScriptDeclarativeClass::Value(engine, priv->objectClass->newQObject(qobjectPtr));
     } else if (type == qMetaTypeId<QList<QObject *> >()) {
-        QList<QObject *> &list = *(QList<QObject *>*)&data;
+        QList<QObject *> &list = *qlistPtr;
         QScriptValue rv = engine->newArray(list.count());
         QDeclarativeEnginePrivate *priv = QDeclarativeEnginePrivate::get(e);
         for (int ii = 0; ii < list.count(); ++ii) {
@@ -826,7 +877,7 @@ QScriptDeclarativeClass::Value MetaCallArgument::toValue(QDeclarativeEngine *e)
         return QScriptDeclarativeClass::Value(engine, rv);
     } else if (type == -1 || type == qMetaTypeId<QVariant>()) {
         QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(e);
-        QScriptValue rv = ep->scriptValueFromVariant(*((QVariant *)&data));
+        QScriptValue rv = ep->scriptValueFromVariant(*qvariantPtr);
         if (rv.isQObject()) {
             QObject *object = rv.toQObject();
             if (object)
diff --git a/src/declarative/qml/qdeclarativeparser.cpp b/src/declarative/qml/qdeclarativeparser.cpp
index ff4a808..cd671bc 100644
--- a/src/declarative/qml/qdeclarativeparser.cpp
+++ b/src/declarative/qml/qdeclarativeparser.cpp
@@ -225,9 +225,9 @@ QDeclarativeParser::Property::~Property()
     if (value) value->release(); 
 }
 
-Object *QDeclarativeParser::Property::getValue(const LocationSpan &l)
+QDeclarativeParser::Object *QDeclarativeParser::Property::getValue(const LocationSpan &l)
 {
-    if (!value) { value = new Object; value->location = l; }
+    if (!value) { value = new QDeclarativeParser::Object; value->location = l; }
     return value;
 }
 
diff --git a/src/declarative/qml/qdeclarativeproperty.cpp b/src/declarative/qml/qdeclarativeproperty.cpp
index 2044586..ae28049 100644
--- a/src/declarative/qml/qdeclarativeproperty.cpp
+++ b/src/declarative/qml/qdeclarativeproperty.cpp
@@ -183,6 +183,9 @@ QDeclarativeProperty::QDeclarativeProperty(QObject *obj, const QString &name)
 /*!
     Creates a QDeclarativeProperty for the property \a name of \a obj
     using the \l{QDeclarativeContext} {context} \a ctxt.
+
+    Creating a QDeclarativeProperty without a context will render some 
+    properties - like attached properties - inaccessible.
 */
 QDeclarativeProperty::QDeclarativeProperty(QObject *obj, const QString &name, QDeclarativeContext *ctxt)
 : d(new QDeclarativePropertyPrivate)
@@ -1029,7 +1032,7 @@ bool QDeclarativePropertyPrivate::writeEnumProperty(const QMetaProperty &prop, i
             else
                 v = QVariant(menum.keyToValue(value.toByteArray()));
         } else if (v.userType() != QVariant::Int && v.userType() != QVariant::UInt) {
-            int enumMetaTypeId = QMetaType::type(QByteArray(menum.scope()) + "::" + menum.name());
+            int enumMetaTypeId = QMetaType::type(QByteArray(menum.scope() + QByteArray("::") + menum.name()));
             if ((enumMetaTypeId == 0) || (v.userType() != enumMetaTypeId) || !v.constData())
                 return false;
             v = QVariant(*reinterpret_cast<const int *>(v.constData()));
diff --git a/src/declarative/qml/qdeclarativescriptparser.cpp b/src/declarative/qml/qdeclarativescriptparser.cpp
index 11cb421..d87f8da 100644
--- a/src/declarative/qml/qdeclarativescriptparser.cpp
+++ b/src/declarative/qml/qdeclarativescriptparser.cpp
@@ -65,16 +65,16 @@ class ProcessAST: protected AST::Visitor
 {
     struct State {
         State() : object(0), property(0) {}
-        State(Object *o) : object(o), property(0) {}
-        State(Object *o, Property *p) : object(o), property(p) {}
+        State(QDeclarativeParser::Object *o) : object(o), property(0) {}
+        State(QDeclarativeParser::Object *o, Property *p) : object(o), property(p) {}
 
-        Object *object;
+        QDeclarativeParser::Object *object;
         Property *property;
     };
 
     struct StateStack : public QStack<State>
     {
-        void pushObject(Object *obj)
+        void pushObject(QDeclarativeParser::Object *obj)
         {
             push(State(obj));
         }
@@ -105,7 +105,7 @@ public:
 
 protected:
 
-    Object *defineObjectBinding(AST::UiQualifiedId *propertyName, bool onAssignment,
+    QDeclarativeParser::Object *defineObjectBinding(AST::UiQualifiedId *propertyName, bool onAssignment,
                                 const QString &objectType,
                                 AST::SourceLocation typeLocation,
                                 LocationSpan location,
@@ -134,7 +134,7 @@ protected:
     QString asString(AST::UiQualifiedId *node) const;
 
     const State state() const;
-    Object *currentObject() const;
+    QDeclarativeParser::Object *currentObject() const;
     Property *currentProperty() const;
 
     QString qualifiedNameId() const;
@@ -200,7 +200,7 @@ const ProcessAST::State ProcessAST::state() const
     return _stateStack.back();
 }
 
-Object *ProcessAST::currentObject() const
+QDeclarativeParser::Object *ProcessAST::currentObject() const
 {
     return state().object;
 }
@@ -229,7 +229,7 @@ QString ProcessAST::asString(AST::UiQualifiedId *node) const
     return s;
 }
 
-Object *
+QDeclarativeParser::Object *
 ProcessAST::defineObjectBinding(AST::UiQualifiedId *propertyName,
                                 bool onAssignment,
                                 const QString &objectType,
@@ -286,7 +286,7 @@ ProcessAST::defineObjectBinding(AST::UiQualifiedId *propertyName,
         if (lastTypeDot >= 0)
             resolvableObjectType.replace(QLatin1Char('.'),QLatin1Char('/'));
 
-        Object *obj = new Object;
+	QDeclarativeParser::Object *obj = new QDeclarativeParser::Object;
 
         QDeclarativeScriptParser::TypeReference *typeRef = _parser->findOrCreateType(resolvableObjectType);
         obj->type = typeRef->id;
@@ -302,7 +302,7 @@ ProcessAST::defineObjectBinding(AST::UiQualifiedId *propertyName,
 
         if (propertyCount) {
             Property *prop = currentProperty();
-            Value *v = new Value;
+            QDeclarativeParser::Value *v = new QDeclarativeParser::Value;
             v->object = obj;
             v->location = obj->location;
             if (onAssignment)
@@ -319,7 +319,7 @@ ProcessAST::defineObjectBinding(AST::UiQualifiedId *propertyName,
                 _parser->setTree(obj);
             } else {
                 const State state = _stateStack.top();
-                Value *v = new Value;
+                QDeclarativeParser::Value *v = new QDeclarativeParser::Value;
                 v->object = obj;
                 v->location = obj->location;
                 if (state.property) {
@@ -594,7 +594,7 @@ bool ProcessAST::visit(AST::UiPublicMember *node)
             property.defaultValue->location =
                     location(node->expression->firstSourceLocation(),
                              node->expression->lastSourceLocation());
-            Value *value = new Value;
+            QDeclarativeParser::Value *value = new QDeclarativeParser::Value;
             value->location = location(node->expression->firstSourceLocation(),
                                        node->expression->lastSourceLocation());
             value->value = getVariant(node->expression);
@@ -698,7 +698,7 @@ bool ProcessAST::visit(AST::UiScriptBinding *node)
 
     prop->location.range.length = prop->location.range.offset + prop->location.range.length - node->qualifiedId->identifierToken.offset;
     prop->location.range.offset = node->qualifiedId->identifierToken.offset;
-    Value *v = new Value;
+    QDeclarativeParser::Value *v = new QDeclarativeParser::Value;
     v->value = primitive;
     v->location = location(node->statement->firstSourceLocation(),
                            node->statement->lastSourceLocation());
@@ -873,7 +873,7 @@ QList<QDeclarativeScriptParser::TypeReference*> QDeclarativeScriptParser::refere
     return _refTypes;
 }
 
-Object *QDeclarativeScriptParser::tree() const
+QDeclarativeParser::Object *QDeclarativeScriptParser::tree() const
 {
     return root;
 }
@@ -1196,7 +1196,7 @@ QDeclarativeScriptParser::TypeReference *QDeclarativeScriptParser::findOrCreateT
     return type;
 }
 
-void QDeclarativeScriptParser::setTree(Object *tree)
+void QDeclarativeScriptParser::setTree(QDeclarativeParser::Object *tree)
 {
     Q_ASSERT(! root);
 
diff --git a/src/declarative/qml/qdeclarativesqldatabase.cpp b/src/declarative/qml/qdeclarativesqldatabase.cpp
index 8a7d854..588b6bf 100644
--- a/src/declarative/qml/qdeclarativesqldatabase.cpp
+++ b/src/declarative/qml/qdeclarativesqldatabase.cpp
@@ -244,7 +244,7 @@ static QScriptValue qmlsqldatabase_executeSql(QScriptContext *context, QScriptEn
             if (!qmlengine->sqlQueryClass)
                 qmlengine->sqlQueryClass = new QDeclarativeSqlQueryScriptClass(engine);
             QScriptValue rows = engine->newObject(qmlengine->sqlQueryClass);
-            rows.setData(engine->newVariant(qVariantFromValue(query)));
+            rows.setData(engine->newVariant(QVariant::fromValue(query)));
             rows.setProperty(QLatin1String("item"), engine->newFunction(qmlsqldatabase_item,1), QScriptValue::SkipInEnumeration);
             result.setProperty(QLatin1String("rows"),rows);
             result.setProperty(QLatin1String("rowsAffected"),query.numRowsAffected());
@@ -282,7 +282,7 @@ static QScriptValue qmlsqldatabase_change_version(QScriptContext *context, QScri
 
     QScriptValue instance = engine->newObject();
     instance.setProperty(QLatin1String("executeSql"), engine->newFunction(qmlsqldatabase_executeSql,1));
-    QScriptValue tx = engine->newVariant(instance,qVariantFromValue(db));
+    QScriptValue tx = engine->newVariant(instance,QVariant::fromValue(db));
 
     QString foundvers = context->thisObject().property(QLatin1String("version")).toString();
     if (from_version!=foundvers) {
@@ -309,8 +309,10 @@ static QScriptValue qmlsqldatabase_change_version(QScriptContext *context, QScri
 
     if (ok) {
         context->thisObject().setProperty(QLatin1String("version"), to_version, QScriptValue::ReadOnly);
+#ifndef QT_NO_SETTINGS
         QSettings ini(qmlsqldatabase_databaseFile(db.connectionName(),engine) + QLatin1String(".ini"), QSettings::IniFormat);
         ini.setValue(QLatin1String("Version"), to_version);
+#endif
     }
 
     return engine->undefinedValue();
@@ -326,7 +328,7 @@ static QScriptValue qmlsqldatabase_transaction_shared(QScriptContext *context, Q
     QScriptValue instance = engine->newObject();
     instance.setProperty(QLatin1String("executeSql"),
         engine->newFunction(readOnly ? qmlsqldatabase_executeSql_readonly : qmlsqldatabase_executeSql,1));
-    QScriptValue tx = engine->newVariant(instance,qVariantFromValue(db));
+    QScriptValue tx = engine->newVariant(instance,QVariant::fromValue(db));
 
     db.transaction();
     callback.call(QScriptValue(), QScriptValueList() << tx);
@@ -355,6 +357,7 @@ static QScriptValue qmlsqldatabase_read_transaction(QScriptContext *context, QSc
 */
 static QScriptValue qmlsqldatabase_open_sync(QScriptContext *context, QScriptEngine *engine)
 {
+#ifndef QT_NO_SETTINGS
     qmlsqldatabase_initDatabasesPath(engine);
 
     QSqlDatabase database;
@@ -411,13 +414,16 @@ static QScriptValue qmlsqldatabase_open_sync(QScriptContext *context, QScriptEng
     instance.setProperty(QLatin1String("version"), version, QScriptValue::ReadOnly);
     instance.setProperty(QLatin1String("changeVersion"), engine->newFunction(qmlsqldatabase_change_version,3));
 
-    QScriptValue result = engine->newVariant(instance,qVariantFromValue(database));
+    QScriptValue result = engine->newVariant(instance,QVariant::fromValue(database));
 
     if (created && dbcreationCallback.isFunction()) {
         dbcreationCallback.call(QScriptValue(), QScriptValueList() << result);
     }
 
     return result;
+#else
+    return engine->undefinedValue();
+#endif // QT_NO_SETTINGS
 }
 
 void qt_add_qmlsqldatabase(QScriptEngine *engine)
diff --git a/src/declarative/qml/qdeclarativestringconverters.cpp b/src/declarative/qml/qdeclarativestringconverters.cpp
index 4383ae2..d7cfe2e 100644
--- a/src/declarative/qml/qdeclarativestringconverters.cpp
+++ b/src/declarative/qml/qdeclarativestringconverters.cpp
@@ -92,7 +92,7 @@ QVariant QDeclarativeStringConverters::variantFromString(const QString &s)
     QSizeF sz = sizeFFromString(s, &ok);
     if (ok) return QVariant(sz);
     QVector3D v = vector3DFromString(s, &ok);
-    if (ok) return qVariantFromValue(v);
+    if (ok) return QVariant::fromValue(v);
 
     return QVariant(s);
 }
diff --git a/src/declarative/qml/qdeclarativetypeloader.cpp b/src/declarative/qml/qdeclarativetypeloader.cpp
index 77587a4..82197dc 100644
--- a/src/declarative/qml/qdeclarativetypeloader.cpp
+++ b/src/declarative/qml/qdeclarativetypeloader.cpp
@@ -65,6 +65,11 @@ The QDeclarativeDataLoader invokes callbacks on the QDeclarativeDataBlob as data
 */
 
 /*!
+    \class QDeclarativeTypeLoader
+    \internal
+*/
+
+/*!
 \enum QDeclarativeDataBlob::Status
 
 This enum describes the status of the data blob.
@@ -434,7 +439,7 @@ void QDeclarativeDataBlob::notifyComplete(QDeclarativeDataBlob *blob)
 
 /*!
 \class QDeclarativeDataLoader
-\brief The QDeclarativeDataLoader class abstracts loading files and their dependecies over the network.
+\brief The QDeclarativeDataLoader class abstracts loading files and their dependencies over the network.
 \internal
 
 The QDeclarativeDataLoader class is provided for the exclusive use of the QDeclarativeTypeLoader class.
@@ -453,9 +458,11 @@ are required before processing can fully complete.
 To complete processing, the QDeclarativeDataBlob::done() callback is invoked.  done() is called when
 one of these three preconditions are met.
 
-1.  The QDeclarativeDataBlob has no dependencies.
-2.  The QDeclarativeDataBlob has an error set.
-3.  All the QDeclarativeDataBlob's dependencies are themselves "done()".
+\list 1
+\o The QDeclarativeDataBlob has no dependencies.
+\o The QDeclarativeDataBlob has an error set.
+\o All the QDeclarativeDataBlob's dependencies are themselves "done()".
+\endlist
 
 Thus QDeclarativeDataBlob::done() will always eventually be called, even if the blob has an error set.
 */
@@ -616,13 +623,17 @@ void QDeclarativeDataLoader::setData(QDeclarativeDataBlob *blob, const QByteArra
 }
 
 /*!
-\class QDeclarativeTypeLoader
+Constructs a new type loader that uses the given \a engine.
 */
 QDeclarativeTypeLoader::QDeclarativeTypeLoader(QDeclarativeEngine *engine)
 : QDeclarativeDataLoader(engine)
 {
 }
 
+/*!
+Destroys the type loader, first clearing the cache of any information about
+loaded files.
+*/
 QDeclarativeTypeLoader::~QDeclarativeTypeLoader()
 {
     clearCache();
@@ -674,7 +685,7 @@ QDeclarativeTypeData *QDeclarativeTypeLoader::get(const QByteArray &data, const
 }
 
 /*!
-Return a QDeclarativeScriptData for \a url.  The QDeclarativeScriptData may be cached.
+Returns a QDeclarativeScriptData for \a url.  The QDeclarativeScriptData may be cached.
 */
 QDeclarativeScriptData *QDeclarativeTypeLoader::getScript(const QUrl &url)
 {
@@ -695,7 +706,7 @@ QDeclarativeScriptData *QDeclarativeTypeLoader::getScript(const QUrl &url)
 }
 
 /*!
-Return a QDeclarativeQmldirData for \a url.  The QDeclarativeQmldirData may be cached.
+Returns a QDeclarativeQmldirData for \a url.  The QDeclarativeQmldirData may be cached.
 */
 QDeclarativeQmldirData *QDeclarativeTypeLoader::getQmldir(const QUrl &url)
 {
@@ -715,6 +726,10 @@ QDeclarativeQmldirData *QDeclarativeTypeLoader::getQmldir(const QUrl &url)
     return qmldirData;
 }
 
+/*!
+Clears cached information about loaded files, including any type data, scripts
+and qmldir information.
+*/
 void QDeclarativeTypeLoader::clearCache()
 {
     for (TypeCache::Iterator iter = m_typeCache.begin(); iter != m_typeCache.end(); ++iter) 
diff --git a/src/declarative/qml/qdeclarativetypenamescriptclass.cpp b/src/declarative/qml/qdeclarativetypenamescriptclass.cpp
index 1335dd4..1cabff5 100644
--- a/src/declarative/qml/qdeclarativetypenamescriptclass.cpp
+++ b/src/declarative/qml/qdeclarativetypenamescriptclass.cpp
@@ -152,7 +152,7 @@ QDeclarativeTypeNameScriptClass::property(Object *obj, const Identifier &name)
     }
 }
 
-void QDeclarativeTypeNameScriptClass::setProperty(Object *o, const Identifier &n, const QScriptValue &v)
+void QDeclarativeTypeNameScriptClass::setProperty(Object *, const Identifier &n, const QScriptValue &v)
 {
     Q_ASSERT(object);
     Q_ASSERT(!type);
diff --git a/src/declarative/qml/qdeclarativevaluetype.cpp b/src/declarative/qml/qdeclarativevaluetype.cpp
index f049a05..8505cae 100644
--- a/src/declarative/qml/qdeclarativevaluetype.cpp
+++ b/src/declarative/qml/qdeclarativevaluetype.cpp
@@ -42,13 +42,12 @@
 #include "private/qdeclarativevaluetype_p.h"
 
 #include "private/qdeclarativemetatype_p.h"
+#include "private/qfont_p.h"
 
 #include <QtCore/qdebug.h>
 
 QT_BEGIN_NAMESPACE
 
-Q_GUI_EXPORT int qt_defaultDpi();
-
 template<typename T>
 int qmlRegisterValueTypeEnums(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
 {
diff --git a/src/declarative/qml/qdeclarativevme.cpp b/src/declarative/qml/qdeclarativevme.cpp
index 06aed98..a23f89d 100644
--- a/src/declarative/qml/qdeclarativevme.cpp
+++ b/src/declarative/qml/qdeclarativevme.cpp
@@ -74,6 +74,27 @@
 
 QT_BEGIN_NAMESPACE
 
+// A simple stack wrapper around QVarLengthArray
+template<typename T>
+class QDeclarativeVMEStack : private QVarLengthArray<T, 128>
+{
+private:
+    typedef QVarLengthArray<T, 128> VLA; 
+    int _index;
+
+public:
+    inline QDeclarativeVMEStack();
+    inline bool isEmpty() const;
+    inline const T &top() const;
+    inline void push(const T &o);
+    inline T pop();
+    inline int count() const;
+    inline const T &at(int index) const;
+};
+
+// We do this so we can forward declare the type in the qdeclarativevme_p.h header
+class QDeclarativeVMEObjectStack : public QDeclarativeVMEStack<QObject *> {};
+
 QDeclarativeVME::QDeclarativeVME()
 {
 }
@@ -99,10 +120,12 @@ struct ListInstance
     QDeclarativeListProperty<void> qListProperty;
 };
 
+Q_DECLARE_TYPEINFO(ListInstance, Q_PRIMITIVE_TYPE  | Q_MOVABLE_TYPE);
+
 QObject *QDeclarativeVME::run(QDeclarativeContextData *ctxt, QDeclarativeCompiledData *comp, 
                               int start, int count, const QBitField &bindingSkipList)
 {
-    QDeclarativeVMEStack<QObject *> stack;
+    QDeclarativeVMEObjectStack stack;
 
     if (start == -1) start = 0;
     if (count == -1) count = comp->bytecode.count();
@@ -121,7 +144,7 @@ void QDeclarativeVME::runDeferred(QObject *object)
     QDeclarativeCompiledData *comp = data->deferredComponent;
     int start = data->deferredIdx + 1;
     int count = data->deferredComponent->bytecode.at(data->deferredIdx).defer.deferCount;
-    QDeclarativeVMEStack<QObject *> stack;
+    QDeclarativeVMEObjectStack stack;
     stack.push(object);
 
     run(stack, ctxt, comp, start, count, QBitField());
@@ -143,7 +166,7 @@ static void removeBindingOnProperty(QObject *o, int index)
 
 #define CLEAN_PROPERTY(o, index) if (fastHasBinding(o, index)) removeBindingOnProperty(o, index)
 
-QObject *QDeclarativeVME::run(QDeclarativeVMEStack<QObject *> &stack, 
+QObject *QDeclarativeVME::run(QDeclarativeVMEObjectStack &stack, 
                               QDeclarativeContextData *ctxt, 
                               QDeclarativeCompiledData *comp, 
                               int start, int count, 
@@ -1054,5 +1077,48 @@ QDeclarativeCompiledData::TypeReference::createInstance(QDeclarativeContextData
     } 
 }
 
+template<typename T>
+QDeclarativeVMEStack<T>::QDeclarativeVMEStack()
+: _index(-1)
+{
+}
+
+template<typename T>
+bool QDeclarativeVMEStack<T>::isEmpty() const {
+    return _index == -1;
+}
+
+template<typename T>
+const T &QDeclarativeVMEStack<T>::top() const {
+    return at(_index);
+}
+
+template<typename T>
+void QDeclarativeVMEStack<T>::push(const T &o) {
+    _index++;
+
+    Q_ASSERT(_index <= VLA::size());
+    if (_index == VLA::size())
+        VLA::append(o);
+    else
+        VLA::data()[_index] = o;
+}
+
+template<typename T>
+T QDeclarativeVMEStack<T>::pop() {
+    Q_ASSERT(_index >= 0);
+    --_index;
+    return VLA::data()[_index + 1];
+}
+
+template<typename T>
+int QDeclarativeVMEStack<T>::count() const {
+    return _index + 1;
+}
+
+template<typename T>
+const T &QDeclarativeVMEStack<T>::at(int index) const {
+    return VLA::data()[index];
+}
 
 QT_END_NAMESPACE
diff --git a/src/declarative/qml/qdeclarativevme_p.h b/src/declarative/qml/qdeclarativevme_p.h
index 6b7b93f..b7f110f 100644
--- a/src/declarative/qml/qdeclarativevme_p.h
+++ b/src/declarative/qml/qdeclarativevme_p.h
@@ -58,6 +58,7 @@
 
 #include <QtCore/QString>
 #include <QtCore/QStack>
+#include <QtCore/QVarLengthArray>
 
 QT_BEGIN_NAMESPACE
 
@@ -67,34 +68,7 @@ class QDeclarativeCompiledData;
 class QDeclarativeCompiledData;
 class QDeclarativeContextData;
 
-template<typename T, int N = 128>
-class QDeclarativeVMEStack {
-public:
-    QDeclarativeVMEStack() : index(-1), maxSize(N), data((T *)fixedData) {}
-    ~QDeclarativeVMEStack() { if (data != (T *)fixedData) qFree(data); }
-
-    bool isEmpty() const { return index == -1; }
-    const T &top() const { return data[index]; }
-    void push(const T &i) { ++index; if (index == maxSize) realloc(); data[index] = i; }
-    const T &pop() { --index; return data[index + 1]; }
-    int count() const { return index + 1; }
-    const T &at(int idx) { return data[idx]; }
-
-private:
-    void realloc() {
-        maxSize += N;
-        if (data != (T *)fixedData) {
-            data = (T*)qRealloc(data, maxSize * sizeof(T));
-        } else {
-            data = (T*)qMalloc(maxSize * sizeof(T));
-        }
-    }
-    int index;
-    int maxSize;
-    T *data;
-    char fixedData[N * sizeof(T)];
-};
-
+class QDeclarativeVMEObjectStack;
 class QDeclarativeVME
 {
 public:
@@ -109,7 +83,7 @@ public:
     QList<QDeclarativeError> errors() const;
 
 private:
-    QObject *run(QDeclarativeVMEStack<QObject *> &, 
+    QObject *run(QDeclarativeVMEObjectStack &, 
                  QDeclarativeContextData *, QDeclarativeCompiledData *, 
                  int start, int count, 
                  const QBitField &);
diff --git a/src/declarative/qml/qdeclarativewatcher.cpp b/src/declarative/qml/qdeclarativewatcher.cpp
index c174998..33f0358 100644
--- a/src/declarative/qml/qdeclarativewatcher.cpp
+++ b/src/declarative/qml/qdeclarativewatcher.cpp
@@ -47,6 +47,7 @@
 
 #include <qdeclarativedebugservice_p.h>
 #include "private/qdeclarativeproperty_p.h"
+#include "private/qdeclarativevaluetype_p.h"
 
 #include <QtCore/qmetaobject.h>
 #include <QtCore/qdebug.h>
@@ -112,7 +113,7 @@ void QDeclarativeWatchProxy::notifyValueChanged()
     QVariant v;
     if (m_expr)
         v = m_expr->evaluate();
-    else
+    else if (QDeclarativeValueTypeFactory::isValueType(m_property.userType()))
         v = m_property.read(m_object);
 
     emit m_watch->propertyChanged(m_id, m_debugId, m_property, v);
diff --git a/src/declarative/qml/qdeclarativeworkerscript.cpp b/src/declarative/qml/qdeclarativeworkerscript.cpp
index 4a0591a..f887084 100644
--- a/src/declarative/qml/qdeclarativeworkerscript.cpp
+++ b/src/declarative/qml/qdeclarativeworkerscript.cpp
@@ -384,7 +384,7 @@ QVariant QDeclarativeWorkerScriptEnginePrivate::scriptValueToVariant(const QScri
             QDeclarativeListModelWorkerAgent *agent = lm->agent();
             if (agent) {
                 QDeclarativeListModelWorkerAgent::VariantRef v(agent);
-                return qVariantFromValue(v);
+                return QVariant::fromValue(v);
             } else {
                 return QVariant();
             }
diff --git a/src/declarative/qml/qdeclarativexmlhttprequest.cpp b/src/declarative/qml/qdeclarativexmlhttprequest.cpp
index 2ba7a36..3bc9100 100644
--- a/src/declarative/qml/qdeclarativexmlhttprequest.cpp
+++ b/src/declarative/qml/qdeclarativexmlhttprequest.cpp
@@ -58,6 +58,8 @@
 #include <QtCore/qstack.h>
 #include <QtCore/qdebug.h>
 
+#include <QtCore/QStringBuilder>
+
 #ifndef QT_NO_XMLSTREAMREADER
 
 // From DOM-Level-3-Core spec
@@ -510,7 +512,7 @@ QScriptValue Node::create(QScriptEngine *engine, NodeImpl *data)
     node.d = data;
     if (data) A(data);
 
-    return engine->newVariant(instance, qVariantFromValue(node));
+    return engine->newVariant(instance, QVariant::fromValue(node));
 }
 
 QScriptValue Element::prototype(QScriptEngine *engine)
@@ -710,7 +712,7 @@ QScriptValue Document::load(QScriptEngine *engine, const QByteArray &data)
     instance.setPrototype(Document::prototype(engine));
     Node documentNode;
     documentNode.d = document;
-    return engine->newVariant(instance, qVariantFromValue(documentNode));
+    return engine->newVariant(instance, QVariant::fromValue(documentNode));
 }
 
 Node::Node()
@@ -761,7 +763,7 @@ QScriptValue NamedNodeMap::create(QScriptEngine *engine, NodeImpl *data, QList<N
     map.list = list;
     if (data) A(data);
 
-    instance.setData(engine->newVariant(qVariantFromValue(map)));
+    instance.setData(engine->newVariant(QVariant::fromValue(map)));
 
     if (!QDeclarativeScriptEngine::get(engine)->namedNodeMapClass)
         QDeclarativeScriptEngine::get(engine)->namedNodeMapClass= new NamedNodeMapClass(engine);
@@ -818,7 +820,7 @@ QScriptValue NodeList::create(QScriptEngine *engine, NodeImpl *data)
     list.d = data;
     if (data) A(data);
 
-    instance.setData(engine->newVariant(qVariantFromValue(list)));
+    instance.setData(engine->newVariant(QVariant::fromValue(list)));
 
     if (!QDeclarativeScriptEngine::get(engine)->nodeListClass)
         QDeclarativeScriptEngine::get(engine)->nodeListClass= new NodeListClass(engine);
@@ -1090,10 +1092,9 @@ QString QDeclarativeXMLHttpRequest::headers()
 
     foreach (const HeaderPair &header, m_headersList) {
         if (ret.length())
-            ret.append(QString::fromUtf8("\r\n"));
-        ret.append(QString::fromUtf8(header.first));
-        ret.append(QString::fromUtf8(": "));
-        ret.append(QString::fromUtf8(header.second));
+            ret.append(QLatin1String("\r\n"));
+        ret = ret % QString::fromUtf8(header.first) % QLatin1String(": ")
+                % QString::fromUtf8(header.second);
     }
     return ret;
 }
@@ -1105,9 +1106,9 @@ void QDeclarativeXMLHttpRequest::fillHeadersList()
     m_headersList.clear();
     foreach (const QByteArray &header, headerList) {
         HeaderPair pair (header.toLower(), m_network->rawHeader(header));
-	if (pair.first == "set-cookie" ||
-	    pair.first == "set-cookie2") 
-	    continue;
+        if (pair.first == "set-cookie" ||
+            pair.first == "set-cookie2")
+            continue;
 
         m_headersList << pair;
     }
diff --git a/src/declarative/qml/qmetaobjectbuilder.cpp b/src/declarative/qml/qmetaobjectbuilder.cpp
index 533d250..f5e8369 100644
--- a/src/declarative/qml/qmetaobjectbuilder.cpp
+++ b/src/declarative/qml/qmetaobjectbuilder.cpp
@@ -101,7 +101,7 @@ bool isVariantType(const char* type)
     return qvariant_nameToType(type) != 0;
 }
 
-// copied from qmetaobject.cpp
+// copied from qmetaobject_p.h
 // do not touch without touching the moc as well
 enum PropertyFlags  {
     Invalid = 0x00000000,
@@ -111,6 +111,8 @@ enum PropertyFlags  {
     EnumOrFlag = 0x00000008,
     StdCppSet = 0x00000100,
 //    Override = 0x00000200,
+    Constant = 0x00000400,
+    Final = 0x00000800,
     Designable = 0x00001000,
     ResolveDesignable = 0x00002000,
     Scriptable = 0x00004000,
@@ -618,6 +620,8 @@ QMetaPropertyBuilder QMetaObjectBuilder::addProperty(const QMetaProperty& protot
     property.setUser(prototype.isUser());
     property.setStdCppSet(prototype.hasStdCppSet());
     property.setEnumOrFlag(prototype.isEnumType());
+    property.setConstant(prototype.isConstant());
+    property.setFinal(prototype.isFinal());
     if (prototype.hasNotifySignal()) {
         // Find an existing method for the notify signal, or add a new one.
         QMetaMethod method = prototype.notifySignal();
@@ -791,7 +795,7 @@ void QMetaObjectBuilder::addMetaObject
     }
 
     if ((members & StaticMetacall) != 0) {
-        if (priv(prototype->d.data)->revision >= 2) {
+        if (priv(prototype->d.data)->revision >= 6) {
             const QMetaObjectExtraData *extra =
                 (const QMetaObjectExtraData *)(prototype->d.extradata);
             if (extra && extra->static_metacall)
@@ -2280,6 +2284,32 @@ bool QMetaPropertyBuilder::isEnumOrFlag() const
 }
 
 /*!
+    Returns true if the property is constant; otherwise returns false.
+    The default value is false.
+*/
+bool QMetaPropertyBuilder::isConstant() const
+{
+    QMetaPropertyBuilderPrivate *d = d_func();
+    if (d)
+        return d->flag(Constant);
+    else
+        return false;
+}
+
+/*!
+    Returns true if the property is final; otherwise returns false.
+    The default value is false.
+*/
+bool QMetaPropertyBuilder::isFinal() const
+{
+    QMetaPropertyBuilderPrivate *d = d_func();
+    if (d)
+        return d->flag(Final);
+    else
+        return false;
+}
+
+/*!
     Sets this property to readable if \a value is true.
 
     \sa isReadable(), setWritable()
@@ -2403,6 +2433,31 @@ void QMetaPropertyBuilder::setEnumOrFlag(bool value)
 }
 
 /*!
+    Sets the \c CONSTANT flag on this property to \a value.
+
+    \sa isConstant()
+*/
+void QMetaPropertyBuilder::setConstant(bool value)
+{
+    QMetaPropertyBuilderPrivate *d = d_func();
+    if (d)
+        d->setFlag(Constant, value);
+}
+
+/*!
+    Sets the \c FINAL flag on this property to \a value.
+
+    \sa isFinal()
+*/
+void QMetaPropertyBuilder::setFinal(bool value)
+{
+    QMetaPropertyBuilderPrivate *d = d_func();
+    if (d)
+        d->setFlag(Final, value);
+}
+
+
+/*!
     \class QMetaEnumBuilder
     \internal
     \brief The QMetaEnumBuilder class enables modifications to an enumerator definition on a meta object builder.
diff --git a/src/declarative/qml/qmetaobjectbuilder_p.h b/src/declarative/qml/qmetaobjectbuilder_p.h
index 3d517d4..a80ba90 100644
--- a/src/declarative/qml/qmetaobjectbuilder_p.h
+++ b/src/declarative/qml/qmetaobjectbuilder_p.h
@@ -169,7 +169,7 @@ public:
     int indexOfEnumerator(const QByteArray& name);
     int indexOfClassInfo(const QByteArray& name);
 
-    typedef int (*StaticMetacallFunction)(QMetaObject::Call, int, void **);
+    typedef QMetaObjectExtraData::StaticMetacallFunction StaticMetacallFunction;
 
     QMetaObjectBuilder::StaticMetacallFunction staticMetacallFunction() const;
     void setStaticMetacallFunction(QMetaObjectBuilder::StaticMetacallFunction value);
@@ -258,6 +258,8 @@ public:
     bool isUser() const;
     bool hasStdCppSet() const;
     bool isEnumOrFlag() const;
+    bool isConstant() const;
+    bool isFinal() const;
 
     void setReadable(bool value);
     void setWritable(bool value);
@@ -269,6 +271,8 @@ public:
     void setUser(bool value);
     void setStdCppSet(bool value);
     void setEnumOrFlag(bool value);
+    void setConstant(bool value);
+    void setFinal(bool value);
 
 private:
     const QMetaObjectBuilder *_mobj;
diff --git a/src/declarative/qml/qperformancetimer.cpp b/src/declarative/qml/qperformancetimer.cpp
index 9d76b26..659a339 100644
--- a/src/declarative/qml/qperformancetimer.cpp
+++ b/src/declarative/qml/qperformancetimer.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/declarative/qml/qperformancetimer_p.h b/src/declarative/qml/qperformancetimer_p.h
index 9715feb..48b286e 100644
--- a/src/declarative/qml/qperformancetimer_p.h
+++ b/src/declarative/qml/qperformancetimer_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/declarative/util/qdeclarativeanimation.cpp b/src/declarative/util/qdeclarativeanimation.cpp
index 0ed4922..ce21bcd 100644
--- a/src/declarative/util/qdeclarativeanimation.cpp
+++ b/src/declarative/util/qdeclarativeanimation.cpp
@@ -1522,6 +1522,7 @@ void QDeclarativeAnimationGroupPrivate::append_animation(QDeclarativeListPropert
     QDeclarativeAnimationGroup *q = qobject_cast<QDeclarativeAnimationGroup *>(list->object);
     if (q) {
         a->setGroup(q);
+        // This is an optimization for the parenting that already occurs via addAnimation
         QDeclarative_setParent_noEvent(a->qtAnimation(), q->d_func()->ag);
         q->d_func()->ag->addAnimation(a->qtAnimation());
     }
@@ -1531,9 +1532,12 @@ void QDeclarativeAnimationGroupPrivate::clear_animation(QDeclarativeListProperty
 {
     QDeclarativeAnimationGroup *q = qobject_cast<QDeclarativeAnimationGroup *>(list->object);
     if (q) {
-        for (int i = 0; i < q->d_func()->animations.count(); ++i)
-            q->d_func()->animations.at(i)->setGroup(0);
-        q->d_func()->animations.clear();
+        while (q->d_func()->animations.count()) {
+            QDeclarativeAbstractAnimation *firstAnim = q->d_func()->animations.at(0);
+            QDeclarative_setParent_noEvent(firstAnim->qtAnimation(), 0);
+            q->d_func()->ag->removeAnimation(firstAnim->qtAnimation());
+            firstAnim->setGroup(0);
+        }
     }
 }
 
@@ -2941,4 +2945,8 @@ void QDeclarativeAnchorAnimation::transition(QDeclarativeStateActions &actions,
     }
 }
 
+QDeclarativeScriptActionPrivate::QDeclarativeScriptActionPrivate()
+    : QDeclarativeAbstractAnimationPrivate(), hasRunScriptScript(false), reversing(false), proxy(this), rsa(0) {}
+
+
 QT_END_NAMESPACE
diff --git a/src/declarative/util/qdeclarativeanimation_p_p.h b/src/declarative/util/qdeclarativeanimation_p_p.h
index 133fb6d..8e00b4b 100644
--- a/src/declarative/util/qdeclarativeanimation_p_p.h
+++ b/src/declarative/util/qdeclarativeanimation_p_p.h
@@ -248,8 +248,7 @@ class QDeclarativeScriptActionPrivate : public QDeclarativeAbstractAnimationPriv
 {
     Q_DECLARE_PUBLIC(QDeclarativeScriptAction)
 public:
-    QDeclarativeScriptActionPrivate()
-        : QDeclarativeAbstractAnimationPrivate(), hasRunScriptScript(false), reversing(false), proxy(this), rsa(0) {}
+    QDeclarativeScriptActionPrivate();
 
     void init();
 
diff --git a/src/declarative/util/qdeclarativeapplication.cpp b/src/declarative/util/qdeclarativeapplication.cpp
index 66e2461..11b0b63 100644
--- a/src/declarative/util/qdeclarativeapplication.cpp
+++ b/src/declarative/util/qdeclarativeapplication.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/declarative/util/qdeclarativeapplication_p.h b/src/declarative/util/qdeclarativeapplication_p.h
index f818adf..448d319 100644
--- a/src/declarative/util/qdeclarativeapplication_p.h
+++ b/src/declarative/util/qdeclarativeapplication_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/declarative/util/qdeclarativebind.cpp b/src/declarative/util/qdeclarativebind.cpp
index b7199ac..051df60 100644
--- a/src/declarative/util/qdeclarativebind.cpp
+++ b/src/declarative/util/qdeclarativebind.cpp
@@ -42,6 +42,7 @@
 #include "private/qdeclarativebind_p.h"
 
 #include "private/qdeclarativenullablevalue_p_p.h"
+#include "private/qdeclarativeguard_p.h"
 
 #include <qdeclarativeengine.h>
 #include <qdeclarativecontext.h>
@@ -64,7 +65,7 @@ public:
 
     bool when : 1;
     bool componentComplete : 1;
-    QObject *obj;
+    QDeclarativeGuard<QObject> obj;
     QString prop;
     QDeclarativeNullableValue<QVariant> value;
 };
diff --git a/src/declarative/util/qdeclarativelistmodel.cpp b/src/declarative/util/qdeclarativelistmodel.cpp
index 92aa6d0..9604117 100644
--- a/src/declarative/util/qdeclarativelistmodel.cpp
+++ b/src/declarative/util/qdeclarativelistmodel.cpp
@@ -802,7 +802,7 @@ void QDeclarativeListModelParser::setCustomData(QObject *obj, const QByteArray &
             {
                 ModelNode *n = nodes.top();
                 ModelNode *n2 = new ModelNode(rv->m_nested);
-                n->values << qVariantFromValue(n2);
+                n->values << QVariant::fromValue(n2);
                 nodes.push(n2);
                 if (processingSet)
                     n->isArray = true;
@@ -1326,7 +1326,7 @@ bool NestedListModel::insert(int index, const QScriptValue& valuemap)
     ModelNode *mn = new ModelNode(this);
     mn->listIndex = index;
     mn->setObjectValue(valuemap);
-    _root->values.insert(index,qVariantFromValue(mn));
+    _root->values.insert(index,QVariant::fromValue(mn));
     return true;
 }
 
@@ -1506,7 +1506,7 @@ void ModelNode::setListValue(const QScriptValue& valuelist) {
             value->listIndex = i;
             value->values << v.toVariant();
         }
-        values.append(qVariantFromValue(value));
+        values.append(QVariant::fromValue(value));
     }
 }
 
diff --git a/src/declarative/util/qdeclarativestate_p_p.h b/src/declarative/util/qdeclarativestate_p_p.h
index ec18f59..195b935 100644
--- a/src/declarative/util/qdeclarativestate_p_p.h
+++ b/src/declarative/util/qdeclarativestate_p_p.h
@@ -206,7 +206,9 @@ public:
 
     struct OperationGuard : public QDeclarativeGuard<QDeclarativeStateOperation>
     {
-        OperationGuard(QObject *obj, QList<OperationGuard> *l) : list(l) { (QDeclarativeGuard<QObject>&)*this = obj; }
+        OperationGuard(QObject *obj, QList<OperationGuard> *l) : list(l) { 
+            setObject(static_cast<QDeclarativeStateOperation *>(obj));
+        }
         QList<OperationGuard> *list;
         void objectDestroyed(QDeclarativeStateOperation *) {
             // we assume priv will always be destroyed after objectDestroyed calls
diff --git a/src/declarative/util/qdeclarativestategroup.cpp b/src/declarative/util/qdeclarativestategroup.cpp
index a3f57d4..c098a38 100644
--- a/src/declarative/util/qdeclarativestategroup.cpp
+++ b/src/declarative/util/qdeclarativestategroup.cpp
@@ -73,6 +73,11 @@ public:
     static QDeclarativeState *at_state(QDeclarativeListProperty<QDeclarativeState> *list, int index);
     static void clear_states(QDeclarativeListProperty<QDeclarativeState> *list);
 
+    static void append_transition(QDeclarativeListProperty<QDeclarativeTransition> *list, QDeclarativeTransition *state);
+    static int count_transitions(QDeclarativeListProperty<QDeclarativeTransition> *list);
+    static QDeclarativeTransition *at_transition(QDeclarativeListProperty<QDeclarativeTransition> *list, int index);
+    static void clear_transitions(QDeclarativeListProperty<QDeclarativeTransition> *list);
+
     QList<QDeclarativeState *> states;
     QList<QDeclarativeTransition *> transitions;
 
@@ -218,7 +223,35 @@ void QDeclarativeStateGroupPrivate::clear_states(QDeclarativeListProperty<QDecla
 QDeclarativeListProperty<QDeclarativeTransition> QDeclarativeStateGroup::transitionsProperty()
 {
     Q_D(QDeclarativeStateGroup);
-    return QDeclarativeListProperty<QDeclarativeTransition>(this, d->transitions);
+    return QDeclarativeListProperty<QDeclarativeTransition>(this, &d->transitions, &QDeclarativeStateGroupPrivate::append_transition,
+                                                       &QDeclarativeStateGroupPrivate::count_transitions,
+                                                       &QDeclarativeStateGroupPrivate::at_transition,
+                                                       &QDeclarativeStateGroupPrivate::clear_transitions);
+}
+
+void QDeclarativeStateGroupPrivate::append_transition(QDeclarativeListProperty<QDeclarativeTransition> *list, QDeclarativeTransition *trans)
+{
+    QDeclarativeStateGroup *_this = static_cast<QDeclarativeStateGroup *>(list->object);
+    if (trans)
+        _this->d_func()->transitions.append(trans);
+}
+
+int QDeclarativeStateGroupPrivate::count_transitions(QDeclarativeListProperty<QDeclarativeTransition> *list)
+{
+    QDeclarativeStateGroup *_this = static_cast<QDeclarativeStateGroup *>(list->object);
+    return _this->d_func()->transitions.count();
+}
+
+QDeclarativeTransition *QDeclarativeStateGroupPrivate::at_transition(QDeclarativeListProperty<QDeclarativeTransition> *list, int index)
+{
+    QDeclarativeStateGroup *_this = static_cast<QDeclarativeStateGroup *>(list->object);
+    return _this->d_func()->transitions.at(index);
+}
+
+void QDeclarativeStateGroupPrivate::clear_transitions(QDeclarativeListProperty<QDeclarativeTransition> *list)
+{
+    QDeclarativeStateGroup *_this = static_cast<QDeclarativeStateGroup *>(list->object);
+    _this->d_func()->transitions.clear();
 }
 
 /*!
diff --git a/src/declarative/util/qdeclarativestateoperations_p.h b/src/declarative/util/qdeclarativestateoperations_p.h
index 6a6dda6..a05edb8 100644
--- a/src/declarative/util/qdeclarativestateoperations_p.h
+++ b/src/declarative/util/qdeclarativestateoperations_p.h
@@ -55,7 +55,7 @@ QT_BEGIN_NAMESPACE
 QT_MODULE(Declarative)
 
 class QDeclarativeParentChangePrivate;
-class Q_AUTOTEST_EXPORT QDeclarativeParentChange : public QDeclarativeStateOperation, public QDeclarativeActionEvent
+class Q_DECLARATIVE_PRIVATE_EXPORT QDeclarativeParentChange : public QDeclarativeStateOperation, public QDeclarativeActionEvent
 {
     Q_OBJECT
     Q_DECLARE_PRIVATE(QDeclarativeParentChange)
@@ -251,7 +251,7 @@ private:
 };
 
 class QDeclarativeAnchorChangesPrivate;
-class Q_AUTOTEST_EXPORT QDeclarativeAnchorChanges : public QDeclarativeStateOperation, public QDeclarativeActionEvent
+class Q_DECLARATIVE_PRIVATE_EXPORT QDeclarativeAnchorChanges : public QDeclarativeStateOperation, public QDeclarativeActionEvent
 {
     Q_OBJECT
     Q_DECLARE_PRIVATE(QDeclarativeAnchorChanges)
diff --git a/src/declarative/util/qdeclarativetransition.cpp b/src/declarative/util/qdeclarativetransition.cpp
index 273060b..b63407c 100644
--- a/src/declarative/util/qdeclarativetransition.cpp
+++ b/src/declarative/util/qdeclarativetransition.cpp
@@ -130,6 +130,9 @@ public:
         endState->complete();
     }
     static void append_animation(QDeclarativeListProperty<QDeclarativeAbstractAnimation> *list, QDeclarativeAbstractAnimation *a);
+    static int animation_count(QDeclarativeListProperty<QDeclarativeAbstractAnimation> *list);
+    static QDeclarativeAbstractAnimation* animation_at(QDeclarativeListProperty<QDeclarativeAbstractAnimation> *list, int pos);
+    static void clear_animations(QDeclarativeListProperty<QDeclarativeAbstractAnimation> *list);
     QList<QDeclarativeAbstractAnimation *> animations;
 };
 
@@ -141,6 +144,28 @@ void QDeclarativeTransitionPrivate::append_animation(QDeclarativeListProperty<QD
     a->setDisableUserControl();
 }
 
+int QDeclarativeTransitionPrivate::animation_count(QDeclarativeListProperty<QDeclarativeAbstractAnimation> *list)
+{
+    QDeclarativeTransition *q = static_cast<QDeclarativeTransition *>(list->object);
+    return q->d_func()->animations.count();
+}
+
+QDeclarativeAbstractAnimation* QDeclarativeTransitionPrivate::animation_at(QDeclarativeListProperty<QDeclarativeAbstractAnimation> *list, int pos)
+{
+    QDeclarativeTransition *q = static_cast<QDeclarativeTransition *>(list->object);
+    return q->d_func()->animations.at(pos);
+}
+
+void QDeclarativeTransitionPrivate::clear_animations(QDeclarativeListProperty<QDeclarativeAbstractAnimation> *list)
+{
+    QDeclarativeTransition *q = static_cast<QDeclarativeTransition *>(list->object);
+    while (q->d_func()->animations.count()) {
+        QDeclarativeAbstractAnimation *firstAnim = q->d_func()->animations.at(0);
+        q->d_func()->group.removeAnimation(firstAnim->qtAnimation());
+        q->d_func()->animations.removeAll(firstAnim);
+    }
+}
+
 void ParallelAnimationWrapper::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
 {
     QParallelAnimationGroup::updateState(newState, oldState);
@@ -309,7 +334,10 @@ void QDeclarativeTransition::setToState(const QString &t)
 QDeclarativeListProperty<QDeclarativeAbstractAnimation> QDeclarativeTransition::animations()
 {
     Q_D(QDeclarativeTransition);
-    return QDeclarativeListProperty<QDeclarativeAbstractAnimation>(this, &d->animations, QDeclarativeTransitionPrivate::append_animation);
+    return QDeclarativeListProperty<QDeclarativeAbstractAnimation>(this, &d->animations, QDeclarativeTransitionPrivate::append_animation,
+                                                                   QDeclarativeTransitionPrivate::animation_count,
+                                                                   QDeclarativeTransitionPrivate::animation_at,
+                                                                   QDeclarativeTransitionPrivate::clear_animations);
 }
 
 QT_END_NAMESPACE
diff --git a/src/declarative/util/qdeclarativetransitionmanager.cpp b/src/declarative/util/qdeclarativetransitionmanager.cpp
index 944b37f..6e96ac9 100644
--- a/src/declarative/util/qdeclarativetransitionmanager.cpp
+++ b/src/declarative/util/qdeclarativetransitionmanager.cpp
@@ -56,12 +56,12 @@ class QDeclarativeTransitionManagerPrivate
 {
 public:
     QDeclarativeTransitionManagerPrivate()
-    : state(0), transition(0) {}
+        : state(0) {}
 
     void applyBindings();
     typedef QList<QDeclarativeSimpleAction> SimpleActionList;
     QDeclarativeState *state;
-    QDeclarativeTransition *transition;
+    QDeclarativeGuard<QDeclarativeTransition> transition;
     QDeclarativeStateOperation::ActionList bindingsList;
     SimpleActionList completeList;
 };
@@ -253,7 +253,7 @@ void QDeclarativeTransitionManager::cancel()
 {
     if (d->transition) {
         // ### this could potentially trigger a complete in rare circumstances
-        d->transition->stop();  
+        d->transition->stop();
         d->transition = 0;
     }
 
diff --git a/src/declarative/util/qdeclarativeview.cpp b/src/declarative/util/qdeclarativeview.cpp
index 5ee56a7..45995ce 100644
--- a/src/declarative/util/qdeclarativeview.cpp
+++ b/src/declarative/util/qdeclarativeview.cpp
@@ -49,6 +49,7 @@
 #include <qdeclarativeguard_p.h>
 
 #include <private/qdeclarativedebugtrace_p.h>
+#include <private/qdeclarativeinspectorservice_p.h>
 
 #include <qscriptvalueiterator.h>
 #include <qdebug.h>
@@ -72,7 +73,6 @@
 QT_BEGIN_NAMESPACE
 
 DEFINE_BOOL_CONFIG_OPTION(frameRateDebug, QML_SHOW_FRAMERATE)
-extern Q_GUI_EXPORT bool qt_applefontsmoothing_enabled;
 
 class QDeclarativeScene : public QGraphicsScene
 {
@@ -300,6 +300,8 @@ void QDeclarativeViewPrivate::init()
     q->viewport()->setAttribute(Qt::WA_OpaquePaintEvent);
     q->viewport()->setAttribute(Qt::WA_NoSystemBackground);
 #endif
+
+    QDeclarativeInspectorService::instance()->addView(q);
 }
 
 /*!
@@ -307,6 +309,7 @@ void QDeclarativeViewPrivate::init()
  */
 QDeclarativeView::~QDeclarativeView()
 {
+    QDeclarativeInspectorService::instance()->removeView(this);
 }
 
 /*! \property QDeclarativeView::source
@@ -316,6 +319,8 @@ QDeclarativeView::~QDeclarativeView()
 
     Ensure that the URL provided is full and correct, in particular, use
     \l QUrl::fromLocalFile() when loading a file from the local filesystem.
+
+    \sa {Network Transparency}{Loading Resources in QML}
  */
 
 /*!
@@ -559,7 +564,6 @@ void QDeclarativeView::continueExecute()
     emit statusChanged(status());
 }
 
-
 /*!
   \internal
 */
@@ -707,19 +711,29 @@ void QDeclarativeView::paintEvent(QPaintEvent *event)
     if (frameRateDebug())
         time = d->frameTimer.restart();
 
-#ifdef Q_WS_MAC
-    bool oldSmooth = qt_applefontsmoothing_enabled;
-    qt_applefontsmoothing_enabled = false;
-#endif
     QGraphicsView::paintEvent(event);
-#ifdef Q_WS_MAC
-    qt_applefontsmoothing_enabled = oldSmooth;
-#endif
 
     QDeclarativeDebugTrace::endRange(QDeclarativeDebugTrace::Painting);
 
     if (frameRateDebug())
         qDebug() << "paintEvent:" << d->frameTimer.elapsed() << "time since last frame:" << time;
+
+#if QT_SHOW_DECLARATIVEVIEW_FPS
+    static QTime timer;
+    static int frames;
+
+    if (frames == 0) {
+        timer.start();
+    } else if (timer.elapsed() > 5000) {
+        qreal avgtime = timer.elapsed() / (qreal) frames;
+        qDebug("Average time per frame: %f ms (%i fps)", avgtime, int(1000 / avgtime));
+        timer.start();
+        frames = 0;
+    }
+    ++frames;
+    scene()->update();
+#endif
+
 }
 
 QT_END_NAMESPACE
diff --git a/src/declarative/util/qdeclarativexmllistmodel.cpp b/src/declarative/util/qdeclarativexmllistmodel.cpp
index 983a25e..658dcad 100644
--- a/src/declarative/util/qdeclarativexmllistmodel.cpp
+++ b/src/declarative/util/qdeclarativexmllistmodel.cpp
@@ -147,114 +147,217 @@ struct XmlQueryJob
     QString prefix;
 };
 
-class QDeclarativeXmlQuery : public QObject
+
+class QDeclarativeXmlQueryEngine;
+class QDeclarativeXmlQueryThreadObject : public QObject
 {
     Q_OBJECT
 public:
-    QDeclarativeXmlQuery(QObject *parent=0)
-        : QObject(parent), m_queryIds(XMLLISTMODEL_CLEAR_ID + 1) {
-        qRegisterMetaType<QDeclarativeXmlQueryResult>("QDeclarativeXmlQueryResult");
-        moveToThread(&m_thread);
-        m_thread.start(QThread::IdlePriority);
-    }
+    QDeclarativeXmlQueryThreadObject(QDeclarativeXmlQueryEngine *);
 
-    ~QDeclarativeXmlQuery() {
-        if(m_thread.isRunning()) {
-            m_thread.quit();
-            m_thread.wait();
-        }
-    }
-
-    void abort(int id) {
-        QMutexLocker ml(&m_mutex);
-        if (id != -1) {
-            m_jobs.remove(id);
-        }
-    }
-
-    int doQuery(QString query, QString namespaces, QByteArray data, QList<QDeclarativeXmlListModelRole *>* roleObjects, QStringList keyRoleResultsCache) {
-        {
-            QMutexLocker m1(&m_mutex);
-            m_queryIds.ref();
-            if (m_queryIds <= 0)
-                m_queryIds = 1;
-        }
-
-        XmlQueryJob job;
-        job.queryId = m_queryIds;
-        job.data = data;
-        job.query = QLatin1String("doc($src)") + query;
-        job.namespaces = namespaces;
-        job.keyRoleResultsCache = keyRoleResultsCache;
-
-        for (int i=0; i<roleObjects->count(); i++) {
-            if (!roleObjects->at(i)->isValid()) {
-                job.roleQueries << QString();
-                continue;
-            }
-            job.roleQueries << roleObjects->at(i)->query();
-            job.roleQueryErrorId << static_cast<void*>(roleObjects->at(i));
-            if (roleObjects->at(i)->isKey())
-                job.keyRoleQueries << job.roleQueries.last();
-        }
+    void processJobs();
+    virtual bool event(QEvent *e);
 
-        {
-            QMutexLocker ml(&m_mutex);
-            m_jobs.insert(m_queryIds, job);
-        }
+private:
+    QDeclarativeXmlQueryEngine *m_queryEngine;
+};
 
-        QMetaObject::invokeMethod(this, "processQuery", Qt::QueuedConnection, Q_ARG(int, job.queryId));
-        return job.queryId;
-    }
 
-private slots:
-    void processQuery(int queryId) {
-        XmlQueryJob job;
+class QDeclarativeXmlQueryEngine : public QThread
+{
+    Q_OBJECT
+public:
+    QDeclarativeXmlQueryEngine(QDeclarativeEngine *eng);
+    ~QDeclarativeXmlQueryEngine();
 
-        {
-            QMutexLocker ml(&m_mutex);
-            if (!m_jobs.contains(queryId))
-                return;
-            job = m_jobs.value(queryId);
-        }
+    int doQuery(QString query, QString namespaces, QByteArray data, QList<QDeclarativeXmlListModelRole *>* roleObjects, QStringList keyRoleResultsCache);
+    void abort(int id);
 
-        QDeclarativeXmlQueryResult result;
-        result.queryId = job.queryId;
-        doQueryJob(&job, &result);
-        doSubQueryJob(&job, &result);
+    void processJobs();
 
-        {
-            QMutexLocker ml(&m_mutex);
-            if (m_jobs.contains(queryId)) {
-                emit queryCompleted(result);
-                m_jobs.remove(queryId);
-            }
-        }
-    }
+    static QDeclarativeXmlQueryEngine *instance(QDeclarativeEngine *engine);
 
-Q_SIGNALS:
+signals:
     void queryCompleted(const QDeclarativeXmlQueryResult &);
     void error(void*, const QString&);
 
 protected:
-
+    void run();
 
 private:
+    void processQuery(XmlQueryJob *job);
     void doQueryJob(XmlQueryJob *job, QDeclarativeXmlQueryResult *currentResult);
     void doSubQueryJob(XmlQueryJob *job, QDeclarativeXmlQueryResult *currentResult);
     void getValuesOfKeyRoles(const XmlQueryJob& currentJob, QStringList *values, QXmlQuery *query) const;
     void addIndexToRangeList(QList<QDeclarativeXmlListRange> *ranges, int index) const;
 
-private:
     QMutex m_mutex;
-    QThread m_thread;
-    QMap<int, XmlQueryJob> m_jobs;
+    QDeclarativeXmlQueryThreadObject *m_threadObject;
+    QList<XmlQueryJob> m_jobs;
+    QSet<int> m_cancelledJobs;
     QAtomicInt m_queryIds;
+
+    QDeclarativeEngine *m_engine;
+    QObject *m_eventLoopQuitHack;
+
+    static QHash<QDeclarativeEngine *,QDeclarativeXmlQueryEngine*> queryEngines;
+    static QMutex queryEnginesMutex;
 };
+QHash<QDeclarativeEngine *,QDeclarativeXmlQueryEngine*> QDeclarativeXmlQueryEngine::queryEngines;
+QMutex QDeclarativeXmlQueryEngine::queryEnginesMutex;
+
+
+QDeclarativeXmlQueryThreadObject::QDeclarativeXmlQueryThreadObject(QDeclarativeXmlQueryEngine *e)
+    : m_queryEngine(e)
+{
+}
+
+void QDeclarativeXmlQueryThreadObject::processJobs()
+{
+    QCoreApplication::postEvent(this, new QEvent(QEvent::User));
+}
+
+bool QDeclarativeXmlQueryThreadObject::event(QEvent *e)
+{
+    if (e->type() == QEvent::User) {
+        m_queryEngine->processJobs();
+        return true;
+    } else {
+        return QObject::event(e);
+    }
+}
+
+
+
+QDeclarativeXmlQueryEngine::QDeclarativeXmlQueryEngine(QDeclarativeEngine *eng)
+: QThread(eng), m_threadObject(0), m_queryIds(XMLLISTMODEL_CLEAR_ID + 1), m_engine(eng), m_eventLoopQuitHack(0)
+{
+    qRegisterMetaType<QDeclarativeXmlQueryResult>("QDeclarativeXmlQueryResult");
+
+    m_eventLoopQuitHack = new QObject;
+    m_eventLoopQuitHack->moveToThread(this);
+    connect(m_eventLoopQuitHack, SIGNAL(destroyed(QObject*)), SLOT(quit()), Qt::DirectConnection);
+    start(QThread::IdlePriority);
+}
+
+QDeclarativeXmlQueryEngine::~QDeclarativeXmlQueryEngine()
+{
+    queryEnginesMutex.lock();
+    queryEngines.remove(m_engine);
+    queryEnginesMutex.unlock();
+
+    m_eventLoopQuitHack->deleteLater();
+    wait();
+}
 
-Q_GLOBAL_STATIC(QDeclarativeXmlQuery, globalXmlQuery)
+int QDeclarativeXmlQueryEngine::doQuery(QString query, QString namespaces, QByteArray data, QList<QDeclarativeXmlListModelRole *>* roleObjects, QStringList keyRoleResultsCache) {
+    {
+        QMutexLocker m1(&m_mutex);
+        m_queryIds.ref();
+        if (m_queryIds <= 0)
+            m_queryIds = 1;
+    }
+
+    XmlQueryJob job;
+    job.queryId = m_queryIds;
+    job.data = data;
+    job.query = QLatin1String("doc($src)") + query;
+    job.namespaces = namespaces;
+    job.keyRoleResultsCache = keyRoleResultsCache;
+
+    for (int i=0; i<roleObjects->count(); i++) {
+        if (!roleObjects->at(i)->isValid()) {
+            job.roleQueries << QString();
+            continue;
+        }
+        job.roleQueries << roleObjects->at(i)->query();
+        job.roleQueryErrorId << static_cast<void*>(roleObjects->at(i));
+        if (roleObjects->at(i)->isKey())
+            job.keyRoleQueries << job.roleQueries.last();
+    }
+
+    {
+        QMutexLocker ml(&m_mutex);
+        m_jobs.append(job);
+        if (m_threadObject)
+            m_threadObject->processJobs();
+    }
+
+    return job.queryId;
+}
+
+void QDeclarativeXmlQueryEngine::abort(int id)
+{
+    QMutexLocker ml(&m_mutex);
+    if (id != -1)
+        m_cancelledJobs.insert(id);
+}
+
+void QDeclarativeXmlQueryEngine::run()
+{
+    m_mutex.lock();
+    m_threadObject = new QDeclarativeXmlQueryThreadObject(this);
+    m_mutex.unlock();
+
+    processJobs();
+    exec();
+
+    delete m_threadObject;
+    m_threadObject = 0;
+}
+
+void QDeclarativeXmlQueryEngine::processJobs()
+{
+    QMutexLocker locker(&m_mutex);
+
+    while (true) {
+        if (m_jobs.isEmpty())
+            return;
+
+        XmlQueryJob currentJob = m_jobs.takeLast();
+        while (m_cancelledJobs.remove(currentJob.queryId)) {
+            if (m_jobs.isEmpty())
+              return;
+            currentJob = m_jobs.takeLast();
+        }
+        
+        locker.unlock();
+        processQuery(&currentJob);
+        locker.relock();
+    }
+}
 
-void QDeclarativeXmlQuery::doQueryJob(XmlQueryJob *currentJob, QDeclarativeXmlQueryResult *currentResult)
+QDeclarativeXmlQueryEngine *QDeclarativeXmlQueryEngine::instance(QDeclarativeEngine *engine)
+{
+    queryEnginesMutex.lock();
+    QDeclarativeXmlQueryEngine *queryEng = queryEngines.value(engine);
+    if (!queryEng) {
+        queryEng = new QDeclarativeXmlQueryEngine(engine);
+        queryEngines.insert(engine, queryEng);
+    }
+    queryEnginesMutex.unlock();
+
+    return queryEng;
+}
+
+void QDeclarativeXmlQueryEngine::processQuery(XmlQueryJob *job)
+{
+    QDeclarativeXmlQueryResult result;
+    result.queryId = job->queryId;
+    doQueryJob(job, &result);
+    doSubQueryJob(job, &result);
+
+    {
+        QMutexLocker ml(&m_mutex);
+        if (m_cancelledJobs.contains(job->queryId)) {
+            m_cancelledJobs.remove(job->queryId);
+        } else {
+            emit queryCompleted(result);
+        }
+    }
+}
+
+void QDeclarativeXmlQueryEngine::doQueryJob(XmlQueryJob *currentJob, QDeclarativeXmlQueryResult *currentResult)
 {
     Q_ASSERT(currentJob->queryId != -1);
 
@@ -293,7 +396,7 @@ void QDeclarativeXmlQuery::doQueryJob(XmlQueryJob *currentJob, QDeclarativeXmlQu
     currentResult->size = (count > 0 ? count : 0);
 }
 
-void QDeclarativeXmlQuery::getValuesOfKeyRoles(const XmlQueryJob& currentJob, QStringList *values, QXmlQuery *query) const
+void QDeclarativeXmlQueryEngine::getValuesOfKeyRoles(const XmlQueryJob& currentJob, QStringList *values, QXmlQuery *query) const
 {
     const QStringList &keysQueries = currentJob.keyRoleQueries;
     QString keysQuery;
@@ -314,7 +417,7 @@ void QDeclarativeXmlQuery::getValuesOfKeyRoles(const XmlQueryJob& currentJob, QS
     }
 }
 
-void QDeclarativeXmlQuery::addIndexToRangeList(QList<QDeclarativeXmlListRange> *ranges, int index) const {
+void QDeclarativeXmlQueryEngine::addIndexToRangeList(QList<QDeclarativeXmlListRange> *ranges, int index) const {
     if (ranges->isEmpty())
         ranges->append(qMakePair(index, 1));
     else if (ranges->last().first + ranges->last().second == index)
@@ -323,7 +426,7 @@ void QDeclarativeXmlQuery::addIndexToRangeList(QList<QDeclarativeXmlListRange> *
         ranges->append(qMakePair(index, 1));
 }
 
-void QDeclarativeXmlQuery::doSubQueryJob(XmlQueryJob *currentJob, QDeclarativeXmlQueryResult *currentResult)
+void QDeclarativeXmlQueryEngine::doSubQueryJob(XmlQueryJob *currentJob, QDeclarativeXmlQueryResult *currentResult)
 {
     Q_ASSERT(currentJob->queryId != -1);
 
@@ -434,6 +537,15 @@ public:
         emit q->statusChanged(status);
     }
 
+    void deleteReply() {
+        Q_Q(QDeclarativeXmlListModel);
+        if (reply) {
+            QObject::disconnect(reply, 0, q, 0);
+            reply->deleteLater();
+            reply = 0;
+        }
+    }
+
     bool isComponentComplete;
     QUrl src;
     QString xml;
@@ -443,6 +555,7 @@ public:
     QList<int> roles;
     QStringList roleNames;
     int highestRole;
+
     QNetworkReply *reply;
     QDeclarativeXmlListModel::Status status;
     QString errorString;
@@ -450,6 +563,7 @@ public:
     int queryId;
     QStringList keyRoleResultsCache;
     QList<QDeclarativeXmlListModelRole *> roleObjects;
+
     static void append_role(QDeclarativeListProperty<QDeclarativeXmlListModelRole> *list, QDeclarativeXmlListModelRole *role);
     static void clear_role(QDeclarativeListProperty<QDeclarativeXmlListModelRole> *list);
     QList<QList<QVariant> > data;
@@ -583,10 +697,6 @@ void QDeclarativeXmlListModelPrivate::clear_role(QDeclarativeListProperty<QDecla
 QDeclarativeXmlListModel::QDeclarativeXmlListModel(QObject *parent)
     : QListModelInterface(*(new QDeclarativeXmlListModelPrivate), parent)
 {
-    connect(globalXmlQuery(), SIGNAL(queryCompleted(QDeclarativeXmlQueryResult)),
-            this, SLOT(queryCompleted(QDeclarativeXmlQueryResult)));
-    connect(globalXmlQuery(), SIGNAL(error(void*,QString)),
-            this, SLOT(queryError(void*,QString)));
 }
 
 QDeclarativeXmlListModel::~QDeclarativeXmlListModel()
@@ -790,7 +900,7 @@ QScriptValue QDeclarativeXmlListModel::get(int index) const
 
     QScriptValue sv = sengine->newObject();
     for (int i=0; i<d->roleObjects.count(); i++) 
-        sv.setProperty(d->roleObjects[i]->name(), qScriptValueFromValue(sengine, d->data.value(i).value(index)));
+        sv.setProperty(d->roleObjects[i]->name(), sengine->toScriptValue(d->data.value(i).value(index)));
     return sv;    
 }
 
@@ -852,6 +962,12 @@ void QDeclarativeXmlListModel::classBegin()
 {
     Q_D(QDeclarativeXmlListModel);
     d->isComponentComplete = false;
+
+    QDeclarativeXmlQueryEngine *queryEngine = QDeclarativeXmlQueryEngine::instance(qmlEngine(this));
+    connect(queryEngine, SIGNAL(queryCompleted(QDeclarativeXmlQueryResult)),
+            SLOT(queryCompleted(QDeclarativeXmlQueryResult)));
+    connect(queryEngine, SIGNAL(error(void*,QString)),
+            SLOT(queryError(void*,QString)));
 }
 
 void QDeclarativeXmlListModel::componentComplete()
@@ -881,7 +997,7 @@ void QDeclarativeXmlListModel::reload()
     if (!d->isComponentComplete)
         return;
 
-    globalXmlQuery()->abort(d->queryId);
+    QDeclarativeXmlQueryEngine::instance(qmlEngine(this))->abort(d->queryId);
     d->queryId = -1;
 
     if (d->size < 0)
@@ -889,15 +1005,11 @@ void QDeclarativeXmlListModel::reload()
 
     if (d->reply) {
         d->reply->abort();
-        if (d->reply) {
-            // abort will generally have already done this (and more)
-            d->reply->deleteLater();
-            d->reply = 0;
-        }
+        d->deleteReply();
     }
 
     if (!d->xml.isEmpty()) {
-        d->queryId = globalXmlQuery()->doQuery(d->query, d->namespaces, d->xml.toUtf8(), &d->roleObjects, d->keyRoleResultsCache);
+        d->queryId = QDeclarativeXmlQueryEngine::instance(qmlEngine(this))->doQuery(d->query, d->namespaces, d->xml.toUtf8(), &d->roleObjects, d->keyRoleResultsCache);
         d->notifyQueryStarted(false);
 
     } else if (d->src.isEmpty()) {
@@ -927,8 +1039,7 @@ void QDeclarativeXmlListModel::requestFinished()
         QVariant redirect = d->reply->attribute(QNetworkRequest::RedirectionTargetAttribute);
         if (redirect.isValid()) {
             QUrl url = d->reply->url().resolved(redirect.toUrl());
-            d->reply->deleteLater();
-            d->reply = 0;
+            d->deleteReply();
             setSource(url);
             return;
         }
@@ -937,9 +1048,7 @@ void QDeclarativeXmlListModel::requestFinished()
 
     if (d->reply->error() != QNetworkReply::NoError) {
         d->errorString = d->reply->errorString();
-        disconnect(d->reply, 0, this, 0);
-        d->reply->deleteLater();
-        d->reply = 0;
+        d->deleteReply();
 
         int count = this->count();
         d->data.clear();
@@ -958,11 +1067,9 @@ void QDeclarativeXmlListModel::requestFinished()
             d->queryId = XMLLISTMODEL_CLEAR_ID;
             QTimer::singleShot(0, this, SLOT(dataCleared()));
         } else {
-            d->queryId = globalXmlQuery()->doQuery(d->query, d->namespaces, data, &d->roleObjects, d->keyRoleResultsCache);
+            d->queryId = QDeclarativeXmlQueryEngine::instance(qmlEngine(this))->doQuery(d->query, d->namespaces, data, &d->roleObjects, d->keyRoleResultsCache);
         }
-        disconnect(d->reply, 0, this, 0);
-        d->reply->deleteLater();
-        d->reply = 0;
+        d->deleteReply();
 
         d->progress = 1.0;
         emit progressChanged(d->progress);