QmlEngineDebugClient: Simplify the client and utility classes

Change-Id: I86033bdbdef94c6f17e706f8e13ce390969171c6
Reviewed-by: Kai Koehne <kai.koehne@nokia.com>

src/libs/qmljsdebugclient/qmlenginedebugclient.h

@@ -40,256 +40,157 @@
 namespace QmlJsDebugClient {
 
 class QDeclarativeDebugConnection;
-class QDeclarativeDebugWatch;
+class QmlDebugPropertyReference;
-class QDeclarativeDebugPropertyWatch;
+class QmlDebugContextReference;
-class QDeclarativeDebugObjectExpressionWatch;
+class QmlDebugObjectReference;
-class QDeclarativeDebugEnginesQuery;
+class QmlDebugFileReference;
-class QDeclarativeDebugRootContextQuery;
+class QmlDebugEngineReference;
-class QDeclarativeDebugObjectQuery;
-class QDeclarativeDebugExpressionQuery;
-class QDeclarativeDebugPropertyReference;
-class QDeclarativeDebugContextReference;
-class QDeclarativeDebugObjectReference;
-class QDeclarativeDebugFileReference;
-class QDeclarativeDebugEngineReference;
-class QmlEngineDebugClientPrivate;
 
 class QMLJSDEBUGCLIENT_EXPORT QmlEngineDebugClient : public QDeclarativeDebugClient
 {
     Q_OBJECT
 public:
-    explicit QmlEngineDebugClient(QDeclarativeDebugConnection *);
+    QmlEngineDebugClient(QDeclarativeDebugConnection *conn);
-    ~QmlEngineDebugClient();
 
-    QDeclarativeDebugPropertyWatch *addWatch(const QDeclarativeDebugPropertyReference &,
+    quint32 addWatch(const QmlDebugPropertyReference &property);
-                                             QObject *parent = 0);
+    quint32 addWatch(const QmlDebugContextReference &context, const QString &id);
-    QDeclarativeDebugWatch *addWatch(const QDeclarativeDebugContextReference &, const QString &,
+    quint32 addWatch(const QmlDebugObjectReference &object, const QString &expr);
-                                     QObject *parent = 0);
+    quint32 addWatch(const QmlDebugObjectReference &object);
-    QDeclarativeDebugObjectExpressionWatch *addWatch(const QDeclarativeDebugObjectReference &, const QString &,
+    quint32 addWatch(const QmlDebugFileReference &file);
-                                                     QObject *parent = 0);
-    QDeclarativeDebugWatch *addWatch(const QDeclarativeDebugObjectReference &,
-                                     QObject *parent = 0);
-    QDeclarativeDebugWatch *addWatch(const QDeclarativeDebugFileReference &,
-                                     QObject *parent = 0);
 
-    void removeWatch(QDeclarativeDebugWatch *watch);
+    void removeWatch(quint32 watch);
 
-    QDeclarativeDebugEnginesQuery *queryAvailableEngines(QObject *parent = 0);
+    quint32 queryAvailableEngines();
-    QDeclarativeDebugRootContextQuery *queryRootContexts(const QDeclarativeDebugEngineReference &,
+    quint32 queryRootContexts(const QmlDebugEngineReference &context);
-                                                         QObject *parent = 0);
+    quint32 queryObject(const QmlDebugObjectReference &object);
-    QDeclarativeDebugObjectQuery *queryObject(const QDeclarativeDebugObjectReference &,
+    quint32 queryObjectRecursive(const QmlDebugObjectReference &object);
-                                              QObject *parent = 0);
+    quint32 queryExpressionResult(int objectDebugId,
-    QDeclarativeDebugObjectQuery *queryObjectRecursive(const QDeclarativeDebugObjectReference &,
+                                  const QString &expr);
-                                                       QObject *parent = 0);
+    quint32 setBindingForObject(int objectDebugId, const QString &propertyName,
-    QDeclarativeDebugExpressionQuery *queryExpressionResult(int objectDebugId,
+                                const QVariant &bindingExpression,
-                                                            const QString &expr,
+                                bool isLiteralValue,
-                                                            QObject *parent = 0);
+                                QString source, int line);
-    bool setBindingForObject(int objectDebugId, const QString &propertyName,
+    quint32 resetBindingForObject(int objectDebugId,
-                             const QVariant &bindingExpression, bool isLiteralValue,
+                                  const QString &propertyName);
-                             QString source = QString(), int line = -1);
+    quint32 setMethodBody(int objectDebugId, const QString &methodName,
-    bool resetBindingForObject(int objectDebugId, const QString &propertyName);
+                          const QString &methodBody);
-    bool setMethodBody(int objectDebugId, const QString &methodName, const QString &methodBody);
 
-    QmlEngineDebugClientPrivate *priv() const { return d; }
+signals:
-Q_SIGNALS:
-    void newObjects();
     void newStatus(QDeclarativeDebugClient::Status status);
+    void newObjects();
+    void valueChanged(int debugId, const QByteArray &name,
+                      const QVariant &value);
+    void result(quint32 queryId, const QVariant &result);
 
 protected:
     virtual void statusChanged(Status status);
     virtual void messageReceived(const QByteArray &);
 
 private:
-    friend class QmlEngineDebugClientPrivate;
+    quint32 getId() { return m_nextId++; }
-    QmlEngineDebugClientPrivate *d;
+
+    void decode(QDataStream &d, QmlDebugContextReference &context);
+    void decode(QDataStream &d, QmlDebugObjectReference &object, bool simple);
+
+private:
+    quint32 m_nextId;
 };
 
-class QMLJSDEBUGCLIENT_EXPORT QDeclarativeDebugWatch : public QObject
+class QmlDebugFileReference
 {
-    Q_OBJECT
 public:
-    enum State { Waiting, Active, Inactive, Dead };
+    QmlDebugFileReference() : m_lineNumber(-1), m_columnNumber(-1) {}
 
-    QDeclarativeDebugWatch(QObject *);
+    QUrl url() const { return m_url; }
-    ~QDeclarativeDebugWatch();
+    int lineNumber() const { return m_lineNumber; }
-
+    int columnNumber() const { return m_columnNumber; }
-    int queryId() const;
-    int objectDebugId() const;
-    State state() const;
-
-Q_SIGNALS:
-    void stateChanged(QDeclarativeDebugWatch::State);
-    //void objectChanged(int, const QDeclarativeDebugObjectReference &);
-    //void valueChanged(int, const QVariant &);
-
-    // Server sends value as string if it is a user-type variant
-    void valueChanged(const QByteArray &name, const QVariant &value);
 
 private:
     friend class QmlEngineDebugClient;
-    friend class QmlEngineDebugClientPrivate;
-    void setState(State);
-    State m_state;
-    int m_queryId;
-    QmlEngineDebugClient *m_client;
-    int m_objectDebugId;
-};
-
-class QMLJSDEBUGCLIENT_EXPORT QDeclarativeDebugPropertyWatch : public QDeclarativeDebugWatch
-{
-    Q_OBJECT
-public:
-    QDeclarativeDebugPropertyWatch(QObject *parent);
-
-    QString name() const;
-
-private:
-    friend class QmlEngineDebugClient;
-    QString m_name;
-};
-
-class QMLJSDEBUGCLIENT_EXPORT QDeclarativeDebugObjectExpressionWatch : public QDeclarativeDebugWatch
-{
-    Q_OBJECT
-public:
-    QDeclarativeDebugObjectExpressionWatch(QObject *parent);
-
-    QString expression() const;
-
-private:
-    friend class QmlEngineDebugClient;
-    QString m_expr;
-    int m_debugId;
-};
-
-class QMLJSDEBUGCLIENT_EXPORT QDeclarativeDebugQuery : public QObject
-{
-    Q_OBJECT
-public:
-    enum State { Waiting, Error, Completed };
-
-    State state() const;
-    bool isWaiting() const;
-
-Q_SIGNALS:
-    void stateChanged(QmlJsDebugClient::QDeclarativeDebugQuery::State);
-
-protected:
-    QDeclarativeDebugQuery(QObject *);
-
-private:
-    friend class QmlEngineDebugClient;
-    friend class QmlEngineDebugClientPrivate;
-    void setState(State);
-    State m_state;
-};
-
-class QMLJSDEBUGCLIENT_EXPORT QDeclarativeDebugFileReference
-{
-public:
-    QDeclarativeDebugFileReference();
-    QDeclarativeDebugFileReference(const QDeclarativeDebugFileReference &);
-    QDeclarativeDebugFileReference &operator=(const QDeclarativeDebugFileReference &);
-
-    QUrl url() const;
-    void setUrl(const QUrl &);
-    int lineNumber() const;
-    void setLineNumber(int);
-    int columnNumber() const;
-    void setColumnNumber(int);
-
-private:
-    friend class QmlEngineDebugClientPrivate;
     QUrl m_url;
     int m_lineNumber;
     int m_columnNumber;
 };
 
-class QMLJSDEBUGCLIENT_EXPORT QDeclarativeDebugEngineReference
+class QmlDebugEngineReference
 {
 public:
-    QDeclarativeDebugEngineReference();
+    QmlDebugEngineReference() : m_debugId(-1) {}
-    QDeclarativeDebugEngineReference(int);
+    QmlDebugEngineReference(int id) : m_debugId(id) {}
-    QDeclarativeDebugEngineReference(const QDeclarativeDebugEngineReference &);
-    QDeclarativeDebugEngineReference &operator=(const QDeclarativeDebugEngineReference &);
 
-    int debugId() const;
+    int debugId() const { return m_debugId; }
-    QString name() const;
+    QString name() const { return m_name; }
 
 private:
-    friend class QmlEngineDebugClientPrivate;
+    friend class QmlEngineDebugClient;
     int m_debugId;
     QString m_name;
 };
 
-class QMLJSDEBUGCLIENT_EXPORT QDeclarativeDebugObjectReference
+typedef QList<QmlDebugEngineReference> QmlDebugEngineReferenceList;
+
+class QmlDebugObjectReference
 {
 public:
-    QDeclarativeDebugObjectReference();
+    QmlDebugObjectReference() : m_debugId(-1), m_contextDebugId(-1) {}
-    QDeclarativeDebugObjectReference(int);
+    QmlDebugObjectReference(int id) : m_debugId(id), m_contextDebugId(-1) {}
-    QDeclarativeDebugObjectReference(const QDeclarativeDebugObjectReference &);
-    QDeclarativeDebugObjectReference &operator=(const QDeclarativeDebugObjectReference &);
 
-    int debugId() const;
+    int debugId() const { return m_debugId; }
-    QString className() const;
+    QString className() const { return m_className; }
-    QString idString() const;
+    QString idString() const { return m_idString; }
-    QString name() const;
+    QString name() const { return m_name; }
 
-    QDeclarativeDebugFileReference source() const;
+    QmlDebugFileReference source() const { return m_source; }
-    int contextDebugId() const;
+    int contextDebugId() const { return m_contextDebugId; }
 
-    QList<QDeclarativeDebugPropertyReference> properties() const;
+    QList<QmlDebugPropertyReference> properties() const { return m_properties; }
-    QList<QDeclarativeDebugObjectReference> children() const;
+    QList<QmlDebugObjectReference> children() const { return m_children; }
 
 private:
-    friend class QmlEngineDebugClientPrivate;
+    friend class QmlEngineDebugClient;
     int m_debugId;
-    QString m_class;
+    QString m_className;
     QString m_idString;
     QString m_name;
-    QDeclarativeDebugFileReference m_source;
+    QmlDebugFileReference m_source;
     int m_contextDebugId;
-    QList<QDeclarativeDebugPropertyReference> m_properties;
+    QList<QmlDebugPropertyReference> m_properties;
-    QList<QDeclarativeDebugObjectReference> m_children;
+    QList<QmlDebugObjectReference> m_children;
 };
 
-class QMLJSDEBUGCLIENT_EXPORT QDeclarativeDebugContextReference
+class QmlDebugContextReference
 {
 public:
-    QDeclarativeDebugContextReference();
+    QmlDebugContextReference() : m_debugId(-1) {}
-    QDeclarativeDebugContextReference(const QDeclarativeDebugContextReference &);
-    QDeclarativeDebugContextReference &operator=(const QDeclarativeDebugContextReference &);
 
-    int debugId() const;
+    int debugId() const { return m_debugId; }
-    QString name() const;
+    QString name() const { return m_name; }
 
-    QList<QDeclarativeDebugObjectReference> objects() const;
+    QList<QmlDebugObjectReference> objects() const { return m_objects; }
-    QList<QDeclarativeDebugContextReference> contexts() const;
+    QList<QmlDebugContextReference> contexts() const { return m_contexts; }
 
 private:
-    friend class QmlEngineDebugClientPrivate;
+    friend class QmlEngineDebugClient;
     int m_debugId;
     QString m_name;
-    QList<QDeclarativeDebugObjectReference> m_objects;
+    QList<QmlDebugObjectReference> m_objects;
-    QList<QDeclarativeDebugContextReference> m_contexts;
+    QList<QmlDebugContextReference> m_contexts;
 };
 
-class QMLJSDEBUGCLIENT_EXPORT QDeclarativeDebugPropertyReference
+class QmlDebugPropertyReference
 {
 public:
-    QDeclarativeDebugPropertyReference();
+    QmlDebugPropertyReference() : m_objectDebugId(-1), m_hasNotifySignal(false) {}
-    QDeclarativeDebugPropertyReference(const QDeclarativeDebugPropertyReference &);
-    QDeclarativeDebugPropertyReference &operator=(const QDeclarativeDebugPropertyReference &);
 
-    int objectDebugId() const;
+    int debugId() const { return m_objectDebugId; }
-    QString name() const;
+    QString name() const { return m_name; }
-    QVariant value() const;
+    QVariant value() const { return m_value; }
-    QString valueTypeName() const;
+    QString valueTypeName() const { return m_valueTypeName; }
-    QString binding() const;
+    QString binding() const { return m_binding; }
-    bool hasNotifySignal() const;
+    bool hasNotifySignal() const { return m_hasNotifySignal; }
 
 private:
-    friend class QmlEngineDebugClientPrivate;
+    friend class QmlEngineDebugClient;
     int m_objectDebugId;
     QString m_name;
     QVariant m_value;
@@ -298,75 +199,11 @@ private:
     bool m_hasNotifySignal;
 };
 
-
-class QMLJSDEBUGCLIENT_EXPORT QDeclarativeDebugEnginesQuery : public QDeclarativeDebugQuery
-{
-    Q_OBJECT
-public:
-    virtual ~QDeclarativeDebugEnginesQuery();
-    QList<QDeclarativeDebugEngineReference> engines() const;
-private:
-    friend class QmlEngineDebugClient;
-    friend class QmlEngineDebugClientPrivate;
-    QDeclarativeDebugEnginesQuery(QObject *);
-    QmlEngineDebugClient *m_client;
-    int m_queryId;
-    QList<QDeclarativeDebugEngineReference> m_engines;
-};
-
-class QMLJSDEBUGCLIENT_EXPORT QDeclarativeDebugRootContextQuery : public QDeclarativeDebugQuery
-{
-    Q_OBJECT
-public:
-    virtual ~QDeclarativeDebugRootContextQuery();
-    QDeclarativeDebugContextReference rootContext() const;
-private:
-    friend class QmlEngineDebugClient;
-    friend class QmlEngineDebugClientPrivate;
-    QDeclarativeDebugRootContextQuery(QObject *);
-    QmlEngineDebugClient *m_client;
-    int m_queryId;
-    QDeclarativeDebugContextReference m_context;
-};
-
-class QMLJSDEBUGCLIENT_EXPORT QDeclarativeDebugObjectQuery : public QDeclarativeDebugQuery
-{
-    Q_OBJECT
-public:
-    virtual ~QDeclarativeDebugObjectQuery();
-    QDeclarativeDebugObjectReference object() const;
-private:
-    friend class QmlEngineDebugClient;
-    friend class QmlEngineDebugClientPrivate;
-    QDeclarativeDebugObjectQuery(QObject *);
-    QmlEngineDebugClient *m_client;
-    int m_queryId;
-    QDeclarativeDebugObjectReference m_object;
-
-};
-
-class QMLJSDEBUGCLIENT_EXPORT QDeclarativeDebugExpressionQuery : public QDeclarativeDebugQuery
-{
-    Q_OBJECT
-public:
-    virtual ~QDeclarativeDebugExpressionQuery();
-    QVariant expression() const;
-    QVariant result() const;
-private:
-    friend class QmlEngineDebugClient;
-    friend class QmlEngineDebugClientPrivate;
-    QDeclarativeDebugExpressionQuery(QObject *);
-    QmlEngineDebugClient *m_client;
-    int m_queryId;
-    QVariant m_expr;
-    QVariant m_result;
-};
-
 } // namespace QmlJsDebugClient
 
-Q_DECLARE_METATYPE(QmlJsDebugClient::QDeclarativeDebugEngineReference)
+Q_DECLARE_METATYPE(QmlJsDebugClient::QmlDebugObjectReference)
-Q_DECLARE_METATYPE(QmlJsDebugClient::QDeclarativeDebugObjectReference)
+Q_DECLARE_METATYPE(QmlJsDebugClient::QmlDebugEngineReference)
-Q_DECLARE_METATYPE(QmlJsDebugClient::QDeclarativeDebugContextReference)
+Q_DECLARE_METATYPE(QmlJsDebugClient::QmlDebugEngineReferenceList)
-Q_DECLARE_METATYPE(QmlJsDebugClient::QDeclarativeDebugPropertyReference)
+Q_DECLARE_METATYPE(QmlJsDebugClient::QmlDebugContextReference)
 
 #endif // QMLENGINEDEBUGCLIENT_H

src/plugins/debugger/qml/qmladapter.cpp

@@ -311,7 +311,17 @@ QmlJsDebugClient::QmlEngineDebugClient *QmlAdapter::engineDebugClient() const
 
 void QmlAdapter::setEngineDebugClient(QmlJsDebugClient::QmlEngineDebugClient *client)
 {
+    Internal::QmlEngine *engine =
+            qobject_cast<Internal::QmlEngine *>(d->m_engine.data());
+    if (engine && d->m_engineDebugClient)
+        disconnect(d->m_engineDebugClient, SIGNAL(result(quint32,QVariant)),
+                engine,
+                SLOT(expressionEvaluated(quint32,QVariant)));
     d->m_engineDebugClient = client;
+    if (engine && d->m_engineDebugClient)
+        connect(d->m_engineDebugClient, SIGNAL(result(quint32,QVariant)),
+                engine,
+                SLOT(expressionEvaluated(quint32,QVariant)));
 }
 
 QmlJsDebugClient::QDebugMessageClient *QmlAdapter::messageClient() const

src/plugins/debugger/qml/qmlengine.cpp

@@ -57,6 +57,7 @@
 #include <extensionsystem/pluginmanager.h>
 #include <projectexplorer/applicationlauncher.h>
 #include <qmljsdebugclient/qdeclarativeoutputparser.h>
+#include <qmljsdebugclient/qmlenginedebugclient.h>
 #include <qmljseditor/qmljseditorconstants.h>
 #include <qmljs/parser/qmljsast_p.h>
 #include <qmljs/qmljsmodelmanagerinterface.h>
@@ -120,6 +121,7 @@ private:
     bool m_validContext;
     QHash<QString,BreakpointModelId> pendingBreakpoints;
     bool m_retryOnConnectFail;
+    QList<quint32> queryIds;
 };
 
 QmlEnginePrivate::QmlEnginePrivate(QmlEngine *q)
@@ -1038,21 +1040,14 @@ void QmlEngine::synchronizeWatchers()
     }
 }
 
-void QmlEngine::onDebugQueryStateChanged(
+void QmlEngine::expressionEvaluated(quint32 queryId, const QVariant &result)
-        QmlJsDebugClient::QDeclarativeDebugQuery::State state)
 {
-    QmlJsDebugClient::QDeclarativeDebugExpressionQuery *query =
+    if (d->queryIds.contains(queryId)) {
-            qobject_cast<QmlJsDebugClient::QDeclarativeDebugExpressionQuery *>(
+        d->queryIds.removeOne(queryId);
-                sender());
+        QtMessageLogItem *item = constructLogItemTree(result);
-    if (query && state != QmlJsDebugClient::QDeclarativeDebugQuery::Error) {
-        QtMessageLogItem *item = constructLogItemTree(query->result());
         if (item)
             qtMessageLogHandler()->appendItem(item);
-    } else
+    }
-        qtMessageLogHandler()->
-                appendItem(new QtMessageLogItem(QtMessageLogHandler::ErrorType,
-                                             _("Error evaluating expression.")));
-    delete query;
 }
 
 bool QmlEngine::hasCapability(unsigned cap) const
@@ -1154,16 +1149,19 @@ bool QmlEngine::evaluateScriptExpression(const QString& expression)
 
                     int id = d->m_adapter.currentSelectedDebugId();
                     if (engineDebug && id != -1) {
-                        QDeclarativeDebugExpressionQuery *query =
+                        quint32 queryId =
-                                engineDebug->queryExpressionResult(id, expression);
+                                engineDebug->queryExpressionResult(
-                        connect(query,
+                                    id, expression);
-                                SIGNAL(stateChanged(
+                        if (queryId) {
-                                           QmlJsDebugClient::QDeclarativeDebugQuery
+                            d->queryIds << queryId;
-                                           ::State)),
+                        } else {
-                                this,
+                            didEvaluate = false;
-                                SLOT(onDebugQueryStateChanged(
+                            qtMessageLogHandler()->
-                                         QmlJsDebugClient::QDeclarativeDebugQuery
+                                    appendItem(
-                                         ::State)));
+                                        new QtMessageLogItem(
+                                            QtMessageLogHandler::ErrorType,
+                                            _("Error evaluating expression.")));
+                        }
                     }
                 } else {
                     executeDebuggerCommand(expression);

src/plugins/debugger/qml/qmlengine.h

@@ -34,7 +34,6 @@
 #define DEBUGGER_QMLENGINE_H
 
 #include "debuggerengine.h"
-#include <qmljsdebugclient/qmlenginedebugclient.h>
 #include <qmljsdebugclient/qdebugmessageclient.h>
 #include <utils/outputformat.h>
 #include <qmljs/qmljsdocument.h>
@@ -96,6 +95,7 @@ public:
 public slots:
     void disconnected();
     void documentUpdated(QmlJS::Document::Ptr doc);
+    void expressionEvaluated(quint32 queryId, const QVariant &result);
 
 private slots:
     void errorMessageBoxFinished(int result);
@@ -171,8 +171,6 @@ private slots:
     void appendMessage(const QString &msg, Utils::OutputFormat);
 
     void synchronizeWatchers();
-    void onDebugQueryStateChanged(
-            QmlJsDebugClient::QDeclarativeDebugQuery::State state);
 
 private:
     void closeConnection();

src/plugins/qmljsinspector/qmljsclientproxy.cpp

@@ -53,13 +53,14 @@ ClientProxy::ClientProxy(Debugger::QmlAdapter *adapter, QObject *parent)
     , m_adapter(adapter)
     , m_engineClient(0)
     , m_inspectorClient(0)
-    , m_engineQuery(0)
+    , m_engineQueryId(0)
-    , m_contextQuery(0)
+    , m_contextQueryId(0)
     , m_isConnected(false)
 {
     m_requestObjectsTimer.setSingleShot(true);
     m_requestObjectsTimer.setInterval(3000);
-    connect(&m_requestObjectsTimer, SIGNAL(timeout()), this, SLOT(refreshObjectTree()));
+    connect(&m_requestObjectsTimer, SIGNAL(timeout()),
+            this, SLOT(refreshObjectTree()));
     connectToServer();
 }
 
@@ -74,15 +75,22 @@ void ClientProxy::connectToServer()
     m_engineClient = new QmlEngineDebugClient(m_adapter.data()->connection());
 
     connect(m_engineClient, SIGNAL(newObjects()), this, SLOT(newObjects()));
-    connect(m_engineClient, SIGNAL(statusChanged(QDeclarativeDebugClient::Status)),
+    connect(m_engineClient, SIGNAL(newStatus(QDeclarativeDebugClient::Status)),
+            SLOT(clientStatusChanged(QDeclarativeDebugClient::Status)));
+    connect(m_engineClient, SIGNAL(newStatus(QDeclarativeDebugClient::Status)),
+            SLOT(engineClientStatusChanged(QDeclarativeDebugClient::Status)));
+    connect(m_engineClient, SIGNAL(result(quint32,QVariant)),
+            SLOT(onResult(quint32,QVariant)));
+    connect(m_engineClient, SIGNAL(valueChanged(int,QByteArray,QVariant)),
+            SLOT(objectWatchTriggered(int,QByteArray,QVariant)));
+
+
+    m_inspectorClient =
+            new QmlJSInspectorClient(m_adapter.data()->connection(), this);
+
+    connect(m_inspectorClient,
+            SIGNAL(connectedStatusChanged(QDeclarativeDebugClient::Status)),
             this, SLOT(clientStatusChanged(QDeclarativeDebugClient::Status)));
-    connect(m_engineClient, SIGNAL(statusChanged(QDeclarativeDebugClient::Status)),
-            this, SLOT(engineClientStatusChanged(QDeclarativeDebugClient::Status)));
-
-    m_inspectorClient = new QmlJSInspectorClient(m_adapter.data()->connection(), this);
-
-    connect(m_inspectorClient, SIGNAL(connectedStatusChanged(QDeclarativeDebugClient::Status)),
-             this, SLOT(clientStatusChanged(QDeclarativeDebugClient::Status)));
     connect(m_inspectorClient, SIGNAL(currentObjectsChanged(QList<int>)),
         SLOT(onCurrentObjectsChanged(QList<int>)));
     connect(m_inspectorClient, SIGNAL(colorPickerActivated()),
@@ -127,26 +135,27 @@ void ClientProxy::clientStatusChanged(QDeclarativeDebugClient::Status status)
 void ClientProxy::engineClientStatusChanged(QDeclarativeDebugClient::Status status)
 {
     if (status == QDeclarativeDebugClient::Enabled) {
-        m_adapter.data()->setEngineDebugClient(qobject_cast<QmlEngineDebugClient *>(sender()));
+        m_adapter.data()->setEngineDebugClient(
+                    qobject_cast<QmlEngineDebugClient *>(sender()));
     }
 }
 
 void ClientProxy::refreshObjectTree()
 {
-    if (!m_contextQuery) {
+    if (!m_contextQueryId) {
         m_requestObjectsTimer.stop();
-        qDeleteAll(m_objectTreeQuery);
+        m_objectTreeQueryIds.clear();
-        m_objectTreeQuery.clear();
         queryEngineContext(m_engines.value(0).debugId());
     }
 }
 
-void ClientProxy::onCurrentObjectsChanged(const QList<int> &debugIds, bool requestIfNeeded)
+void ClientProxy::onCurrentObjectsChanged(const QList<int> &debugIds,
+                                          bool requestIfNeeded)
 {
-    QList<QDeclarativeDebugObjectReference> selectedItems;
+    QList<QmlDebugObjectReference> selectedItems;
 
     foreach (int debugId, debugIds) {
-        QDeclarativeDebugObjectReference ref = objectReferenceForId(debugId);
+        QmlDebugObjectReference ref = objectReferenceForId(debugId);
         if (ref.debugId() != -1) {
             selectedItems << ref;
         } else if (requestIfNeeded) {
@@ -171,12 +180,13 @@ void ClientProxy::setSelectedItemsByDebugId(const QList<int> &debugIds)
     m_inspectorClient->setCurrentObjects(debugIds);
 }
 
-void ClientProxy::setSelectedItemsByObjectId(const QList<QDeclarativeDebugObjectReference> &objectRefs)
+void ClientProxy::setSelectedItemsByObjectId(
+        const QList<QmlDebugObjectReference> &objectRefs)
 {
     if (isConnected()) {
         QList<int> debugIds;
 
-        foreach (const QDeclarativeDebugObjectReference &ref, objectRefs) {
+        foreach (const QmlDebugObjectReference &ref, objectRefs) {
             debugIds << ref.debugId();
         }
 
@@ -184,14 +194,14 @@ void ClientProxy::setSelectedItemsByObjectId(const QList<QDeclarativeDebugObject
     }
 }
 
-QDeclarativeDebugObjectReference ClientProxy::objectReferenceForId(int debugId) const
+QmlDebugObjectReference ClientProxy::objectReferenceForId(int debugId) const
 {
-    foreach (const QDeclarativeDebugObjectReference& it, m_rootObjects) {
+    foreach (const QmlDebugObjectReference& it, m_rootObjects) {
-        QDeclarativeDebugObjectReference result = objectReferenceForId(debugId, it);
+        QmlDebugObjectReference result = objectReferenceForId(debugId, it);
         if (result.debugId() == debugId)
             return result;
     }
-    return QDeclarativeDebugObjectReference();
+    return QmlDebugObjectReference();
 }
 
 void ClientProxy::log(LogDirection direction, const QString &message)
@@ -208,71 +218,76 @@ void ClientProxy::log(LogDirection direction, const QString &message)
         m_adapter.data()->logServiceActivity("QDeclarativeDebug", msg);
 }
 
-QList<QDeclarativeDebugObjectReference> QmlJSInspector::Internal::ClientProxy::rootObjectReference() const
+QList<QmlDebugObjectReference>
+QmlJSInspector::Internal::ClientProxy::rootObjectReference() const
 {
     return m_rootObjects;
 }
 
-QDeclarativeDebugObjectReference ClientProxy::objectReferenceForId(int debugId,
+QmlDebugObjectReference
-                                                                   const QDeclarativeDebugObjectReference &objectRef) const
+ClientProxy::objectReferenceForId(int debugId,
+                                  const QmlDebugObjectReference &objectRef) const
 {
     if (objectRef.debugId() == debugId)
         return objectRef;
 
-    foreach (const QDeclarativeDebugObjectReference &child, objectRef.children()) {
+    foreach (const QmlDebugObjectReference &child, objectRef.children()) {
-        QDeclarativeDebugObjectReference result = objectReferenceForId(debugId, child);
+        QmlDebugObjectReference result = objectReferenceForId(debugId, child);
         if (result.debugId() == debugId)
             return result;
     }
 
-    return QDeclarativeDebugObjectReference();
+    return QmlDebugObjectReference();
 }
 
-QDeclarativeDebugObjectReference ClientProxy::objectReferenceForId(const QString &objectId) const
+QmlDebugObjectReference ClientProxy::objectReferenceForId(
+        const QString &objectId) const
 {
     if (!objectId.isEmpty() && objectId[0].isLower()) {
-        const QList<QDeclarativeDebugObjectReference> refs = objectReferences();
+        const QList<QmlDebugObjectReference> refs = objectReferences();
-        foreach (const QDeclarativeDebugObjectReference &ref, refs) {
+        foreach (const QmlDebugObjectReference &ref, refs) {
             if (ref.idString() == objectId)
                 return ref;
         }
     }
-    return QDeclarativeDebugObjectReference();
+    return QmlDebugObjectReference();
 }
 
-QDeclarativeDebugObjectReference ClientProxy::objectReferenceForLocation(const int line, const int column) const
+QmlDebugObjectReference ClientProxy::objectReferenceForLocation(
+        const int line, const int column) const
 {
-    const QList<QDeclarativeDebugObjectReference> refs = objectReferences();
+    const QList<QmlDebugObjectReference> refs = objectReferences();
-    foreach (const QDeclarativeDebugObjectReference &ref, refs) {
+    foreach (const QmlDebugObjectReference &ref, refs) {
         if (ref.source().lineNumber() == line && ref.source().columnNumber() == column)
             return ref;
     }
 
-    return QDeclarativeDebugObjectReference();
+    return QmlDebugObjectReference();
 }
 
-QList<QDeclarativeDebugObjectReference> ClientProxy::objectReferences() const
+QList<QmlDebugObjectReference> ClientProxy::objectReferences() const
 {
-    QList<QDeclarativeDebugObjectReference> result;
+    QList<QmlDebugObjectReference> result;
-    foreach (const QDeclarativeDebugObjectReference &it, m_rootObjects) {
+    foreach (const QmlDebugObjectReference &it, m_rootObjects) {
         result.append(objectReferences(it));
     }
     return result;
 }
 
-QList<QDeclarativeDebugObjectReference> ClientProxy::objectReferences(const QDeclarativeDebugObjectReference &objectRef) const
+QList<QmlDebugObjectReference>
+ClientProxy::objectReferences(const QmlDebugObjectReference &objectRef) const
 {
-    QList<QDeclarativeDebugObjectReference> result;
+    QList<QmlDebugObjectReference> result;
     result.append(objectRef);
 
-    foreach (const QDeclarativeDebugObjectReference &child, objectRef.children()) {
+    foreach (const QmlDebugObjectReference &child, objectRef.children()) {
         result.append(objectReferences(child));
     }
 
     return result;
 }
 
-bool ClientProxy::setBindingForObject(int objectDebugId,
+quint32 ClientProxy::setBindingForObject(int objectDebugId,
                                       const QString &propertyName,
                                       const QVariant &value,
                                       bool isLiteralValue,
@@ -288,17 +303,23 @@ bool ClientProxy::setBindingForObject(int objectDebugId,
     if (!isConnected())
         return false;
 
-    log(LogSend, QString("SET_BINDING %1 %2 %3 %4").arg(QString::number(objectDebugId), propertyName, value.toString(), QString(isLiteralValue ? "true" : "false")));
+    log(LogSend, QString("SET_BINDING %1 %2 %3 %4").arg(
+            QString::number(objectDebugId), propertyName, value.toString(),
+            QString(isLiteralValue ? "true" : "false")));
 
-    bool result = m_engineClient->setBindingForObject(objectDebugId, propertyName, value.toString(), isLiteralValue, source, line);
+    quint32 queryId = m_engineClient->setBindingForObject(
+                objectDebugId, propertyName, value.toString(), isLiteralValue,
+                source, line);
 
-    if (!result)
+    if (!queryId)
         log(LogSend, QString("failed!"));
 
-    return result;
+    return queryId;
 }
 
-bool ClientProxy::setMethodBodyForObject(int objectDebugId, const QString &methodName, const QString &methodBody)
+quint32 ClientProxy::setMethodBodyForObject(int objectDebugId,
+                                            const QString &methodName,
+                                            const QString &methodBody)
 {
     if (objectDebugId == -1)
         return false;
@@ -306,17 +327,20 @@ bool ClientProxy::setMethodBodyForObject(int objectDebugId, const QString &metho
     if (!isConnected())
         return false;
 
-    log(LogSend, QString("SET_METHOD_BODY %1 %2 %3").arg(QString::number(objectDebugId), methodName, methodBody));
+    log(LogSend, QString("SET_METHOD_BODY %1 %2 %3").arg(
+            QString::number(objectDebugId), methodName, methodBody));
 
-    bool result = m_engineClient->setMethodBody(objectDebugId, methodName, methodBody);
+    quint32 queryId = m_engineClient->setMethodBody(
+                objectDebugId, methodName, methodBody);
 
-    if (!result)
+    if (!queryId)
         log(LogSend, QString("failed!"));
 
-    return result;
+    return queryId;
 }
 
-bool ClientProxy::resetBindingForObject(int objectDebugId, const QString& propertyName)
+quint32 ClientProxy::resetBindingForObject(int objectDebugId,
+                                           const QString& propertyName)
 {
     if (objectDebugId == -1)
         return false;
@@ -324,17 +348,20 @@ bool ClientProxy::resetBindingForObject(int objectDebugId, const QString& proper
     if (!isConnected())
         return false;
 
-    log(LogSend, QString("RESET_BINDING %1 %2").arg(QString::number(objectDebugId), propertyName));
+    log(LogSend, QString("RESET_BINDING %1 %2").arg(
+            QString::number(objectDebugId), propertyName));
 
-    bool result = m_engineClient->resetBindingForObject(objectDebugId, propertyName);
+    quint32 queryId = m_engineClient->resetBindingForObject(
+                objectDebugId, propertyName);
 
-    if (!result)
+    if (!queryId)
         log(LogSend, QString("failed!"));
 
-    return result;
+    return queryId;
 }
 
-QDeclarativeDebugExpressionQuery *ClientProxy::queryExpressionResult(int objectDebugId, const QString &expr)
+quint32 ClientProxy::queryExpressionResult(int objectDebugId,
+                                           const QString &expr)
 {
     if (objectDebugId == -1)
         return 0;
@@ -346,13 +373,13 @@ QDeclarativeDebugExpressionQuery *ClientProxy::queryExpressionResult(int objectD
     if (m_adapter)
         block = m_adapter.data()->disableJsDebugging(true);
 
-    log(LogSend, QString("EVAL_EXPRESSION %1 %2").arg(QString::number(objectDebugId), expr));
+    log(LogSend, QString("EVAL_EXPRESSION %1 %2").arg(
-    QDeclarativeDebugExpressionQuery *query
+            QString::number(objectDebugId), expr));
-            = m_engineClient->queryExpressionResult(objectDebugId, expr, m_engineClient);
+    quint32 queryId = m_engineClient->queryExpressionResult(objectDebugId, expr);
 
     if (m_adapter)
         m_adapter.data()->disableJsDebugging(block);
-    return query;
+    return queryId;
 }
 
 void ClientProxy::clearComponentCache()
@@ -370,32 +397,28 @@ bool ClientProxy::addObjectWatch(int objectDebugId)
         return false;
 
     // already set
-    if (m_objectWatches.keys().contains(objectDebugId))
+    if (m_objectWatches.contains(objectDebugId))
         return true;
 
-    QDeclarativeDebugObjectReference ref = objectReferenceForId(objectDebugId);
+    QmlDebugObjectReference ref = objectReferenceForId(objectDebugId);
     if (ref.debugId() != objectDebugId)
         return false;
 
     // is flooding the debugging output log!
     // log(LogSend, QString("WATCH_PROPERTY %1").arg(objectDebugId));
 
-    QDeclarativeDebugWatch *watch = m_engineClient->addWatch(ref, m_engineClient);
+    if (m_engineClient->addWatch(ref))
-    m_objectWatches.insert(objectDebugId, watch);
+        m_objectWatches.append(objectDebugId);
-
-    connect(watch,SIGNAL(valueChanged(QByteArray,QVariant)),this,SLOT(objectWatchTriggered(QByteArray,QVariant)));
 
     return false;
 }
 
-void ClientProxy::objectWatchTriggered(const QByteArray &propertyName, const QVariant &propertyValue)
+void ClientProxy::objectWatchTriggered(int objectDebugId,
+                                       const QByteArray &propertyName,
+                                       const QVariant &propertyValue)
 {
-    // is flooding the debugging output log!
+    if (m_objectWatches.contains(objectDebugId))
-    // log(LogReceive, QString("UPDATE_WATCH %1 %2").arg(QString::fromAscii(propertyName), propertyValue.toString()));
+        emit propertyChanged(objectDebugId, propertyName, propertyValue);
-
-    QDeclarativeDebugWatch *watch = dynamic_cast<QDeclarativeDebugWatch *>(QObject::sender());
-    if (watch)
-        emit propertyChanged(watch->objectDebugId(),propertyName, propertyValue);
 }
 
 bool ClientProxy::removeObjectWatch(int objectDebugId)
@@ -403,29 +426,19 @@ bool ClientProxy::removeObjectWatch(int objectDebugId)
     if (objectDebugId == -1)
         return false;
 
-    if (!m_objectWatches.keys().contains(objectDebugId))
+    if (!m_objectWatches.contains(objectDebugId))
         return false;
 
     if (!isConnected())
         return false;
 
-    QDeclarativeDebugWatch *watch = m_objectWatches.value(objectDebugId);
+    m_objectWatches.removeOne(objectDebugId);
-    disconnect(watch,SIGNAL(valueChanged(QByteArray,QVariant)), this, SLOT(objectWatchTriggered(QByteArray,QVariant)));
-
-    // is flooding the debugging output log!
-    // log(LogSend, QString("NO_WATCH %1").arg(QString::number(objectDebugId)));
-
-    m_engineClient->removeWatch(watch);
-    delete watch;
-    m_objectWatches.remove(objectDebugId);
-
-
     return true;
 }
 
 void ClientProxy::removeAllObjectWatches()
 {
-    foreach (int watchedObject, m_objectWatches.keys())
+    foreach (int watchedObject, m_objectWatches)
         removeObjectWatch(watchedObject);
 }
 
@@ -437,87 +450,75 @@ void ClientProxy::queryEngineContext(int id)
     if (!isConnected())
         return;
 
-    if (m_contextQuery) {
+    if (m_contextQueryId)
-        delete m_contextQuery;
+        m_contextQueryId = 0;
-        m_contextQuery = 0;
-    }
 
     log(LogSend, QString("LIST_OBJECTS %1").arg(QString::number(id)));
 
-    m_contextQuery = m_engineClient->queryRootContexts(QDeclarativeDebugEngineReference(id),
+    m_contextQueryId = m_engineClient->queryRootContexts(QmlDebugEngineReference(id));
-                                                       m_engineClient);
-    if (!m_contextQuery->isWaiting())
-        contextChanged();
-    else
-        connect(m_contextQuery, SIGNAL(stateChanged(QmlJsDebugClient::QDeclarativeDebugQuery::State)),
-                this, SLOT(contextChanged()));
 }
 
-void ClientProxy::contextChanged()
+void ClientProxy::contextChanged(const QVariant &value)
 {
     log(LogReceive, QString("LIST_OBJECTS_R"));
-    if (m_contextQuery) {
+    if (m_contextQueryId) {
         m_rootObjects.clear();
-        QDeclarativeDebugContextReference rootContext = m_contextQuery->rootContext();
+        QmlDebugContextReference rootContext =
-        delete m_contextQuery;
+                qvariant_cast<QmlDebugContextReference>(value);
-        m_contextQuery = 0;
+        m_contextQueryId = 0;
 
-        qDeleteAll(m_objectTreeQuery);
+        m_objectTreeQueryIds.clear();
-        m_objectTreeQuery.clear();
         m_requestObjectsTimer.stop();
 
         fetchContextObjectRecursive(rootContext);
     }
 }
 
-void ClientProxy::fetchContextObjectRecursive(const QDeclarativeDebugContextReference& context)
+void ClientProxy::fetchContextObjectRecursive(
+        const QmlDebugContextReference& context)
 {
     if (!isConnected())
         return;
 
-    foreach (const QDeclarativeDebugObjectReference & obj, context.objects()) {
+    foreach (const QmlDebugObjectReference & obj, context.objects()) {
 
         log(LogSend, QString("FETCH_OBJECT %1").arg(obj.idString()));
 
-        QDeclarativeDebugObjectQuery* query
+        quint32 queryId = m_engineClient->queryObjectRecursive(obj);
-                = m_engineClient->queryObjectRecursive(obj, m_engineClient);
+        if (queryId)
-        if (!query->isWaiting()) {
+            m_objectTreeQueryIds << queryId;
-            query->deleteLater(); //ignore errors;
-        } else {
-            m_objectTreeQuery << query;
-            connect(query,
-                    SIGNAL(stateChanged(QmlJsDebugClient::QDeclarativeDebugQuery::State)),
-                    SLOT(objectTreeFetched(QmlJsDebugClient::QDeclarativeDebugQuery::State)));
-        }
     }
-    foreach (const QDeclarativeDebugContextReference& child, context.contexts()) {
+    foreach (const QmlDebugContextReference& child, context.contexts()) {
         fetchContextObjectRecursive(child);
     }
 }
 
-
+void ClientProxy::onResult(quint32 queryId, const QVariant &value)
-void ClientProxy::objectTreeFetched(QmlJsDebugClient::QDeclarativeDebugQuery::State state)
 {
-    QDeclarativeDebugObjectQuery *query = qobject_cast<QDeclarativeDebugObjectQuery *>(sender());
+    if (m_objectTreeQueryIds.contains(queryId))
-    if (!query || state == QDeclarativeDebugQuery::Error) {
+        objectTreeFetched(queryId, value);
-        delete query;
+    else if (queryId == m_engineQueryId)
-        return;
+        updateEngineList(value);
-    }
+    else if (queryId == m_contextQueryId)
+        contextChanged(value);
+    else
+        emit result(queryId, value);
+}
 
-    log(LogReceive, QString("FETCH_OBJECT_R %1").arg(query->object().idString()));
+void ClientProxy::objectTreeFetched(quint32 queryId, const QVariant &result)
+{
+    QmlDebugObjectReference obj = qvariant_cast<QmlDebugObjectReference>(result);
 
-    m_rootObjects.append(query->object());
+    log(LogReceive, QString("FETCH_OBJECT_R %1").arg(obj.idString()));
 
-    int removed = m_objectTreeQuery.removeAll(query);
+    m_rootObjects.append(obj);
-    Q_ASSERT(removed == 1);
-    Q_UNUSED(removed);
-    delete query;
 
-    if (m_objectTreeQuery.isEmpty()) {
+    m_objectTreeQueryIds.removeOne(queryId);
+    if (m_objectTreeQueryIds.isEmpty()) {
         int old_count = m_debugIdHash.count();
         m_debugIdHash.clear();
         m_debugIdHash.reserve(old_count + 1);
-        foreach (const QDeclarativeDebugObjectReference &it, m_rootObjects)
+        foreach (const QmlDebugObjectReference &it, m_rootObjects)
             buildDebugIdHashRecursive(it);
         emit objectTreeUpdated();
 
@@ -530,14 +531,15 @@ void ClientProxy::objectTreeFetched(QmlJsDebugClient::QDeclarativeDebugQuery::St
     }
 }
 
-void ClientProxy::buildDebugIdHashRecursive(const QDeclarativeDebugObjectReference& ref)
+void ClientProxy::buildDebugIdHashRecursive(const QmlDebugObjectReference& ref)
 {
     QUrl fileUrl = ref.source().url();
     int lineNum = ref.source().lineNumber();
     int colNum = ref.source().columnNumber();
     int rev = 0;
 
-    // handle the case where the url contains the revision number encoded. (for object created by the debugger)
+    // handle the case where the url contains the revision number encoded.
+    //(for object created by the debugger)
     static QRegExp rx("(.*)_(\\d+):(\\d+)$");
     if (rx.exactMatch(fileUrl.path())) {
         fileUrl.setPath(rx.cap(1));
@@ -548,9 +550,10 @@ void ClientProxy::buildDebugIdHashRecursive(const QDeclarativeDebugObjectReferen
     const QString filePath = InspectorUi::instance()->findFileInProject(fileUrl);
 
     // append the debug ids in the hash
-    m_debugIdHash[qMakePair<QString, int>(filePath, rev)][qMakePair<int, int>(lineNum, colNum)].append(ref.debugId());
+    m_debugIdHash[qMakePair<QString, int>(filePath, rev)][qMakePair<int, int>(
+                lineNum, colNum)].append(ref.debugId());
 
-    foreach (const QDeclarativeDebugObjectReference &it, ref.children())
+    foreach (const QmlDebugObjectReference &it, ref.children())
         buildDebugIdHashRecursive(it);
 }
 
@@ -609,10 +612,12 @@ void ClientProxy::showAppOnTop(bool showOnTop)
 }
 
 void ClientProxy::createQmlObject(const QString &qmlText, int parentDebugId,
-                                  const QStringList &imports, const QString &filename, int order)
+                                  const QStringList &imports,
+                                  const QString &filename, int order)
 {
     if (isConnected())
-        m_inspectorClient->createQmlObject(qmlText, parentDebugId, imports, filename, order);
+        m_inspectorClient->createQmlObject(qmlText, parentDebugId, imports,
+                                           filename, order);
 }
 
 void ClientProxy::destroyQmlObject(int debugId)
@@ -629,8 +634,10 @@ void ClientProxy::reparentQmlObject(int debugId, int newParent)
 
 void ClientProxy::updateConnected()
 {
-    bool isConnected = m_inspectorClient && m_inspectorClient->status() == QDeclarativeDebugClient::Enabled
+    bool isConnected = m_inspectorClient &&
-            && m_engineClient && m_engineClient->status() == QDeclarativeDebugClient::Enabled;
+            m_inspectorClient->status() == QDeclarativeDebugClient::Enabled &&
+            m_engineClient &&
+            m_engineClient->status() == QDeclarativeDebugClient::Enabled;
 
     if (isConnected != m_isConnected) {
         m_isConnected = isConnected;
@@ -645,11 +652,6 @@ void ClientProxy::updateConnected()
 
 void ClientProxy::reloadEngines()
 {
-    if (m_engineQuery) {
-        emit connectionStatusMessage("[Inspector] Waiting for response to previous engine query");
-        return;
-    }
-
     if (!isConnected())
         return;
 
@@ -657,28 +659,20 @@ void ClientProxy::reloadEngines()
 
     log(LogSend, QString("LIST_ENGINES"));
 
-    m_engineQuery = m_engineClient->queryAvailableEngines(m_engineClient);
+    m_engineQueryId = m_engineClient->queryAvailableEngines();
-    if (!m_engineQuery->isWaiting()) {
-        updateEngineList();
-    } else {
-        connect(m_engineQuery, SIGNAL(stateChanged(QmlJsDebugClient::QDeclarativeDebugQuery::State)),
-                         this, SLOT(updateEngineList()));
-    }
 }
 
-QList<QDeclarativeDebugEngineReference> ClientProxy::engines() const
+QList<QmlDebugEngineReference> ClientProxy::engines() const
 {
     return m_engines;
 }
 
-void ClientProxy::updateEngineList()
+void ClientProxy::updateEngineList(const QVariant &value)
 {
     log(LogReceive, QString("LIST_ENGINES_R"));
 
-    m_engines = m_engineQuery->engines();
+    m_engines = qvariant_cast<QmlDebugEngineReferenceList>(value);
-    delete m_engineQuery;
+    m_engineQueryId = 0;
-    m_engineQuery = 0;
-
     emit enginesChanged();
 }
 

src/plugins/qmljsinspector/qmljsclientproxy.h

@@ -60,16 +60,16 @@ public:
     explicit ClientProxy(Debugger::QmlAdapter *adapter, QObject *parent = 0);
     ~ClientProxy();
 
-    bool setBindingForObject(int objectDebugId,
+    quint32 setBindingForObject(int objectDebugId,
                              const QString &propertyName,
                              const QVariant &value,
                              bool isLiteralValue,
                              QString source,
                              int line);
 
-    bool setMethodBodyForObject(int objectDebugId, const QString &methodName, const QString &methodBody);
+    quint32 setMethodBodyForObject(int objectDebugId, const QString &methodName, const QString &methodBody);
-    bool resetBindingForObject(int objectDebugId, const QString &propertyName);
+    quint32 resetBindingForObject(int objectDebugId, const QString &propertyName);
-    QDeclarativeDebugExpressionQuery *queryExpressionResult(int objectDebugId, const QString &expr);
+    quint32 queryExpressionResult(int objectDebugId, const QString &expr);
     void clearComponentCache();
 
     bool addObjectWatch(int objectDebugId);
@@ -77,19 +77,19 @@ public:
     void removeAllObjectWatches();
 
     // returns the object references
-    QList<QDeclarativeDebugObjectReference> objectReferences() const;
+    QList<QmlDebugObjectReference> objectReferences() const;
-    QDeclarativeDebugObjectReference objectReferenceForId(int debugId) const;
+    QmlDebugObjectReference objectReferenceForId(int debugId) const;
-    QDeclarativeDebugObjectReference objectReferenceForId(const QString &objectId) const;
+    QmlDebugObjectReference objectReferenceForId(const QString &objectId) const;
-    QDeclarativeDebugObjectReference objectReferenceForLocation(const int line, const int column) const;
+    QmlDebugObjectReference objectReferenceForLocation(const int line, const int column) const;
-    QList<QDeclarativeDebugObjectReference> rootObjectReference() const;
+    QList<QmlDebugObjectReference> rootObjectReference() const;
     DebugIdHash debugIdHash() const { return m_debugIdHash; }
 
     bool isConnected() const;
 
     void setSelectedItemsByDebugId(const QList<int> &debugIds);
-    void setSelectedItemsByObjectId(const QList<QDeclarativeDebugObjectReference> &objectRefs);
+    void setSelectedItemsByObjectId(const QList<QmlDebugObjectReference> &objectRefs);
 
-    QList<QDeclarativeDebugEngineReference> engines() const;
+    QList<QmlDebugEngineReference> engines() const;
 
     Debugger::QmlAdapter *qmlAdapter() const;
 
@@ -100,7 +100,7 @@ signals:
     void aboutToReloadEngines();
     void enginesChanged();
 
-    void selectedItemsChanged(const QList<QDeclarativeDebugObjectReference> &selectedItems);
+    void selectedItemsChanged(const QList<QmlDebugObjectReference> &selectedItems);
 
     void connected();
     void disconnected();
@@ -117,6 +117,8 @@ signals:
     void selectedColorChanged(const QColor &color);
     void propertyChanged(int debugId, const QByteArray &propertyName, const QVariant &propertyValue);
 
+    void result(quint32 queryId, const QVariant &result);
+
 public slots:
     void refreshObjectTree();
     void queryEngineContext(int id);
@@ -140,21 +142,21 @@ private slots:
     void clientStatusChanged(QDeclarativeDebugClient::Status status);
     void engineClientStatusChanged(QDeclarativeDebugClient::Status status);
 
-    void contextChanged();
-
     void onCurrentObjectsChanged(const QList<int> &debugIds, bool requestIfNeeded = true);
-    void updateEngineList();
+    void fetchContextObjectRecursive(const QmlDebugContextReference &context);
-    void objectTreeFetched(QmlJsDebugClient::QDeclarativeDebugQuery::State state = QmlJsDebugClient::QDeclarativeDebugQuery::Completed);
-    void fetchContextObjectRecursive(const QmlJsDebugClient::QDeclarativeDebugContextReference& context);
     void newObjects();
-    void objectWatchTriggered(const QByteArray &propertyName, const QVariant &propertyValue);
+    void objectWatchTriggered(int debugId, const QByteArray &propertyName, const QVariant &propertyValue);
+    void onResult(quint32 queryId, const QVariant &result);
 
 private:
+    void contextChanged(const QVariant &value);
+    void updateEngineList(const QVariant &value);
+    void objectTreeFetched(quint32 queryId, const QVariant &result);
     void updateConnected();
     void reloadEngines();
 
-    QList<QDeclarativeDebugObjectReference> objectReferences(const QDeclarativeDebugObjectReference &objectRef) const;
+    QList<QmlDebugObjectReference> objectReferences(const QmlDebugObjectReference &objectRef) const;
-    QDeclarativeDebugObjectReference objectReferenceForId(int debugId, const QDeclarativeDebugObjectReference &ref) const;
+    QmlDebugObjectReference objectReferenceForId(int debugId, const QmlDebugObjectReference &ref) const;
 
     enum LogDirection {
         LogSend,
@@ -164,22 +166,22 @@ private:
 
 
 private:
-    void buildDebugIdHashRecursive(const QDeclarativeDebugObjectReference &ref);
+    void buildDebugIdHashRecursive(const QmlDebugObjectReference &ref);
 
     QWeakPointer<Debugger::QmlAdapter> m_adapter;
     QmlEngineDebugClient *m_engineClient;
     QmlJSInspectorClient *m_inspectorClient;
 
-    QDeclarativeDebugEnginesQuery *m_engineQuery;
+    quint32 m_engineQueryId;
-    QDeclarativeDebugRootContextQuery *m_contextQuery;
+    quint32 m_contextQueryId;
-    QList<QDeclarativeDebugObjectQuery *> m_objectTreeQuery;
+    QList<quint32> m_objectTreeQueryIds;
 
-    QList<QDeclarativeDebugObjectReference> m_rootObjects;
+    QList<QmlDebugObjectReference> m_rootObjects;
-    QList<QDeclarativeDebugEngineReference> m_engines;
+    QmlDebugEngineReferenceList m_engines;
     QTimer m_requestObjectsTimer;
     DebugIdHash m_debugIdHash;
 
-    QHash<int, QDeclarativeDebugWatch *> m_objectWatches;
+    QList<int> m_objectWatches;
 
     bool m_isConnected;
 };

src/plugins/qmljsinspector/qmljsinspector.cpp

@@ -224,7 +224,7 @@ void InspectorUi::showDebuggerTooltip(const QPoint &mousePos, TextEditor::ITextE
         if (!qmlNode)
             return;
 
-        QDeclarativeDebugObjectReference ref;
+        QmlDebugObjectReference ref;
         if (QmlJS::AST::Node *node
                 = qmlEditor->semanticInfo().declaringMemberNoProperties(cursorPos)) {
             if (QmlJS::AST::UiObjectMember *objMember = node->uiObjectMemberCast()) {
@@ -249,7 +249,7 @@ void InspectorUi::showDebuggerTooltip(const QPoint &mousePos, TextEditor::ITextE
                 if ((qmlNode->kind == QmlJS::AST::Node::Kind_IdentifierExpression) &&
                         (m_clientProxy->objectReferenceForId(refToLook).debugId() == -1)) {
                     query = doubleQuote + QString("local: ") + refToLook + doubleQuote;
-                    foreach (const QDeclarativeDebugPropertyReference &property, ref.properties()) {
+                    foreach (const QmlDebugPropertyReference &property, ref.properties()) {
                         if (property.name() == wordAtCursor
                                 && !property.valueTypeName().isEmpty()) {
                             query = doubleQuote + property.name() + QLatin1Char(':')
@@ -263,7 +263,7 @@ void InspectorUi::showDebuggerTooltip(const QPoint &mousePos, TextEditor::ITextE
                             + QLatin1Char('+') + refToLook;
             } else {
                 // show properties
-                foreach (const QDeclarativeDebugPropertyReference &property, ref.properties()) {
+                foreach (const QmlDebugPropertyReference &property, ref.properties()) {
                     if (property.name() == wordAtCursor && !property.valueTypeName().isEmpty()) {
                         query = doubleQuote + property.name() + QLatin1Char(':')
                                 + doubleQuote + QLatin1Char('+') + property.name();
@@ -275,25 +275,19 @@ void InspectorUi::showDebuggerTooltip(const QPoint &mousePos, TextEditor::ITextE
 
         if (!query.isEmpty()) {
             m_debugQuery = m_clientProxy->queryExpressionResult(ref.debugId(), query);
-            connect(m_debugQuery, SIGNAL(stateChanged(QmlJsDebugClient::QDeclarativeDebugQuery::State)),
-                    this, SLOT(debugQueryUpdated(QmlJsDebugClient::QDeclarativeDebugQuery::State)));
         }
     }
 }
 
-void InspectorUi::debugQueryUpdated(QmlJsDebugClient::QDeclarativeDebugQuery::State newState)
+void InspectorUi::onResult(quint32 queryId, const QVariant &result)
 {
-    if (newState != QDeclarativeDebugExpressionQuery::Completed)
+    if (m_debugQuery != queryId)
-        return;
-    if (!m_debugQuery)
         return;
 
-    QString text = m_debugQuery->result().toString();
+    m_debugQuery = 0;
+    QString text = result.toString();
     if (!text.isEmpty())
         QToolTip::showText(QCursor::pos(), text);
-
-    disconnect(m_debugQuery, SIGNAL(stateChanged(QmlJsDebugClient::QDeclarativeDebugQuery::State)),
-               this, SLOT(debugQueryUpdated(QmlJsDebugClient::QDeclarativeDebugQuery::State)));
 }
 
 bool InspectorUi::isConnected() const
@@ -303,7 +297,13 @@ bool InspectorUi::isConnected() const
 
 void InspectorUi::connected(ClientProxy *clientProxy)
 {
+    if (m_clientProxy)
+        disconnect(m_clientProxy, SIGNAL(result(quint32,QVariant)),
+                   this, SLOT(onResult(quint32,QVariant)));
     m_clientProxy = clientProxy;
+    if (m_clientProxy)
+        connect(m_clientProxy, SIGNAL(result(quint32,QVariant)),
+                   SLOT(onResult(quint32,QVariant)));
 
     QmlJS::Snapshot snapshot = modelManager()->snapshot();
     for (QHash<QString, QmlJSLiveTextPreview *>::const_iterator it = m_textPreviews.constBegin();
@@ -365,19 +365,19 @@ void InspectorUi::objectTreeReady()
 
 void InspectorUi::updateEngineList()
 {
-    QList<QDeclarativeDebugEngineReference> engines = m_clientProxy->engines();
+    QList<QmlDebugEngineReference> engines = m_clientProxy->engines();
 
 //#warning update the QML engines combo
 
     if (engines.isEmpty())
         qWarning("qmldebugger: no engines found!");
     else {
-        const QDeclarativeDebugEngineReference engine = engines.first();
+        const QmlDebugEngineReference engine = engines.first();
         m_clientProxy->queryEngineContext(engine.debugId());
     }
 }
 
-void InspectorUi::changeSelectedItems(const QList<QDeclarativeDebugObjectReference> &objects)
+void InspectorUi::changeSelectedItems(const QList<QmlDebugObjectReference> &objects)
 {
     if (m_selectionCallbackExpected) {
         m_selectionCallbackExpected = false;
@@ -386,9 +386,9 @@ void InspectorUi::changeSelectedItems(const QList<QDeclarativeDebugObjectReferen
     m_cursorPositionChangedExternally = true;
 
     // QmlJSLiveTextPreview doesn't provide valid references, only correct debugIds. We need to remap them
-    QList <QDeclarativeDebugObjectReference> realList;
+    QList <QmlDebugObjectReference> realList;
-    foreach (const QDeclarativeDebugObjectReference &obj, objects) {
+    foreach (const QmlDebugObjectReference &obj, objects) {
-        QDeclarativeDebugObjectReference clientRef = m_clientProxy->objectReferenceForId(obj.debugId());
+        QmlDebugObjectReference clientRef = m_clientProxy->objectReferenceForId(obj.debugId());
         realList <<  clientRef;
     }
 
@@ -476,8 +476,8 @@ QmlJSLiveTextPreview *InspectorUi::createPreviewForEditor(Core::IEditor *newEdit
         } else {
             preview = new QmlJSLiveTextPreview(doc, initdoc, m_clientProxy, this);
             connect(preview,
-                    SIGNAL(selectedItemsChanged(QList<QDeclarativeDebugObjectReference>)),
+                    SIGNAL(selectedItemsChanged(QList<QmlDebugObjectReference>)),
-                    SLOT(changeSelectedItems(QList<QDeclarativeDebugObjectReference>)));
+                    SLOT(changeSelectedItems(QList<QmlDebugObjectReference>)));
             connect(preview, SIGNAL(reloadQmlViewerRequested()),
                     m_clientProxy, SLOT(reloadQmlViewer()));
             connect(preview, SIGNAL(disableLivePreviewRequested()), SLOT(disableLivePreview()));
@@ -503,36 +503,36 @@ void InspectorUi::reloadQmlViewer()
         m_clientProxy->reloadQmlViewer();
 }
 
-inline QDeclarativeDebugObjectReference findParentRecursive( int goalDebugId,
+inline QmlDebugObjectReference findParentRecursive( int goalDebugId,
-                                                            const QList< QDeclarativeDebugObjectReference > &objectsToSearch)
+                                                            const QList<QmlDebugObjectReference > &objectsToSearch)
 {
     if (goalDebugId == -1)
-        return QDeclarativeDebugObjectReference();
+        return QmlDebugObjectReference();
 
-    foreach (const QDeclarativeDebugObjectReference &possibleParent, objectsToSearch) {
+    foreach (const QmlDebugObjectReference &possibleParent, objectsToSearch) {
         // Am I a root object? No parent
         if ( possibleParent.debugId() == goalDebugId )
-            return QDeclarativeDebugObjectReference();
+            return QmlDebugObjectReference();
 
         // Is the goal one of my children?
-        foreach (const QDeclarativeDebugObjectReference &child, possibleParent.children())
+        foreach (const QmlDebugObjectReference &child, possibleParent.children())
             if ( child.debugId() == goalDebugId )
                 return possibleParent;
 
         // no luck? pass this on
-        QDeclarativeDebugObjectReference candidate = findParentRecursive(goalDebugId, possibleParent.children());
+        QmlDebugObjectReference candidate = findParentRecursive(goalDebugId, possibleParent.children());
         if (candidate.debugId() != -1)
             return candidate;
     }
 
-    return QDeclarativeDebugObjectReference();
+    return QmlDebugObjectReference();
 }
 
-inline QString displayName(const QDeclarativeDebugObjectReference &obj)
+inline QString displayName(const QmlDebugObjectReference &obj)
 {
     // special! state names
     if (obj.className() == "State") {
-        foreach (const QDeclarativeDebugPropertyReference &prop, obj.properties()) {
+        foreach (const QmlDebugPropertyReference &prop, obj.properties()) {
             if (prop.name() == "name")
                 return prop.value().toString();
         }
@@ -551,16 +551,16 @@ inline QString displayName(const QDeclarativeDebugObjectReference &obj)
     return QString("<%1>").arg(objTypeName);
 }
 
-void InspectorUi::selectItems(const QList<QDeclarativeDebugObjectReference> &objectReferences)
+void InspectorUi::selectItems(const QList<QmlDebugObjectReference> &objectReferences)
 {
-    foreach (const QDeclarativeDebugObjectReference &objref, objectReferences) {
+    foreach (const QmlDebugObjectReference &objref, objectReferences) {
         int debugId = objref.debugId();
         if (debugId != -1) {
             // select only the first valid element of the list
 
             m_clientProxy->removeAllObjectWatches();
             m_clientProxy->addObjectWatch(debugId);
-            QList <QDeclarativeDebugObjectReference> selectionList;
+            QList <QmlDebugObjectReference> selectionList;
             selectionList << objref;
             m_propertyInspector->setCurrentObjects(selectionList);
             populateCrumblePath(objref);
@@ -574,21 +574,21 @@ void InspectorUi::selectItems(const QList<QDeclarativeDebugObjectReference> &obj
     }
 }
 
-bool InspectorUi::isRoot(const QDeclarativeDebugObjectReference &obj) const
+bool InspectorUi::isRoot(const QmlDebugObjectReference &obj) const
 {
-    foreach (const QDeclarativeDebugObjectReference &rootObj, m_clientProxy->rootObjectReference())
+    foreach (const QmlDebugObjectReference &rootObj, m_clientProxy->rootObjectReference())
         if (obj.debugId() == rootObj.debugId())
             return true;
     return false;
 }
 
-void InspectorUi::populateCrumblePath(const QDeclarativeDebugObjectReference &objRef)
+void InspectorUi::populateCrumblePath(const QmlDebugObjectReference &objRef)
 {
     QStringList crumbleStrings;
     QList <int> crumbleData;
 
     // first find path by climbing the hierarchy
-    QDeclarativeDebugObjectReference ref = objRef;
+    QmlDebugObjectReference ref = objRef;
     crumbleData << objRef.debugId();
     crumbleStrings << displayName(objRef);
 
@@ -603,7 +603,7 @@ void InspectorUi::populateCrumblePath(const QDeclarativeDebugObjectReference &ob
     crumbleData.clear();
 
     // now append the children
-    foreach (const QDeclarativeDebugObjectReference &child, objRef.children()) {
+    foreach (const QmlDebugObjectReference &child, objRef.children()) {
         crumbleData.push_back(child.debugId());
         crumbleStrings.push_back( displayName(child) );
     }
@@ -613,10 +613,10 @@ void InspectorUi::populateCrumblePath(const QDeclarativeDebugObjectReference &ob
 
 void InspectorUi::selectItems(const QList<int> &objectIds)
 {
-    QList<QDeclarativeDebugObjectReference> objectReferences;
+    QList<QmlDebugObjectReference> objectReferences;
     foreach (int objectId, objectIds)
     {
-        QDeclarativeDebugObjectReference ref = m_clientProxy->objectReferenceForId(objectId);
+        QmlDebugObjectReference ref = m_clientProxy->objectReferenceForId(objectId);
         if (ref.debugId() == objectId)
             objectReferences.append(ref);
     }
@@ -646,7 +646,7 @@ void InspectorUi::disable()
     m_filterExp->setEnabled(false);
 }
 
-QDeclarativeDebugObjectReference InspectorUi::objectReferenceForLocation(const QString &fileName, int cursorPosition) const
+QmlDebugObjectReference InspectorUi::objectReferenceForLocation(const QString &fileName, int cursorPosition) const
 {
     Core::EditorManager *editorManager = Core::EditorManager::instance();
     Core::IEditor *editor = editorManager->openEditor(fileName);
@@ -667,17 +667,17 @@ QDeclarativeDebugObjectReference InspectorUi::objectReferenceForLocation(const Q
             }
         }
     }
-    return QDeclarativeDebugObjectReference();
+    return QmlDebugObjectReference();
 }
 
-void InspectorUi::gotoObjectReferenceDefinition(const QDeclarativeDebugObjectReference &obj)
+void InspectorUi::gotoObjectReferenceDefinition(const QmlDebugObjectReference &obj)
 {
     if (m_cursorPositionChangedExternally) {
         m_cursorPositionChangedExternally = false;
         return;
     }
 
-    QDeclarativeDebugFileReference source = obj.source();
+    QmlDebugFileReference source = obj.source();
 
     const QString fileName = m_projectFinder.findFile(source.url());
 
@@ -690,7 +690,7 @@ void InspectorUi::gotoObjectReferenceDefinition(const QDeclarativeDebugObjectRef
             m_selectionCallbackExpected = true;
 
     if (textEditor) {
-        QDeclarativeDebugObjectReference ref = objectReferenceForLocation(fileName);
+        QmlDebugObjectReference ref = objectReferenceForLocation(fileName);
         if (ref.debugId() != obj.debugId()) {
             m_selectionCallbackExpected = true;
             editorManager->addCurrentPositionToNavigationHistory();
@@ -843,8 +843,8 @@ void InspectorUi::connectSignals()
     connect(m_clientProxy, SIGNAL(propertyChanged(int,QByteArray,QVariant)),
             m_propertyInspector, SLOT(propertyValueChanged(int,QByteArray,QVariant)));
 
-    connect(m_clientProxy, SIGNAL(selectedItemsChanged(QList<QDeclarativeDebugObjectReference>)),
+    connect(m_clientProxy, SIGNAL(selectedItemsChanged(QList<QmlDebugObjectReference>)),
-            this, SLOT(selectItems(QList<QDeclarativeDebugObjectReference>)));
+            this, SLOT(selectItems(QList<QmlDebugObjectReference>)));
     connect(m_clientProxy, SIGNAL(enginesChanged()),
             this, SLOT(updateEngineList()));
     connect(m_clientProxy, SIGNAL(serverReloaded()),

src/plugins/qmljsinspector/qmljsinspector.h

@@ -112,14 +112,15 @@ public slots:
     void reloadQmlViewer();
     void serverReloaded();
     void setApplyChangesToQmlInspector(bool applyChanges);
+    void onResult(quint32 queryId, const QVariant &result);
 
 private slots:
     void enable();
     void disable();
-    void gotoObjectReferenceDefinition(const QDeclarativeDebugObjectReference &obj);
+    void gotoObjectReferenceDefinition(const QmlDebugObjectReference &obj);
-    void selectItems(const QList<QDeclarativeDebugObjectReference> &objectReferences);
+    void selectItems(const QList<QmlDebugObjectReference> &objectReferences);
     void selectItems(const QList<int> &objectIds);
-    void changeSelectedItems(const QList<QDeclarativeDebugObjectReference> &objects);
+    void changeSelectedItems(const QList<QmlDebugObjectReference> &objects);
     void changePropertyValue(int debugId,const QString &propertyName, const QString &valueExpression);
     void objectTreeReady();
 
@@ -133,7 +134,6 @@ private slots:
 
     void updatePendingPreviewDocuments(QmlJS::Document::Ptr doc);
     void showDebuggerTooltip(const QPoint &mousePos, TextEditor::ITextEditor *editor, int cursorPos);
-    void debugQueryUpdated(QmlJsDebugClient::QDeclarativeDebugQuery::State);
 
 private:
     bool addQuotesForData(const QVariant &value) const;
@@ -143,9 +143,9 @@ private:
     void applyChangesToQmlInspectorHelper(bool applyChanges);
     void setupDockWidgets();
     QString filenameForShadowBuildFile(const QString &filename) const;
-    void populateCrumblePath(const QDeclarativeDebugObjectReference &objRef);
+    void populateCrumblePath(const QmlDebugObjectReference &objRef);
-    bool isRoot(const QDeclarativeDebugObjectReference &obj) const;
+    bool isRoot(const QmlDebugObjectReference &obj) const;
-    QDeclarativeDebugObjectReference objectReferenceForLocation(const QString &fileName, int cursorPosition=-1) const;
+    QmlDebugObjectReference objectReferenceForLocation(const QString &fileName, int cursorPosition=-1) const;
 
     void connectSignals();
     void disconnectSignals();
@@ -160,7 +160,7 @@ private:
     InspectorSettings *m_settings;
     ClientProxy *m_clientProxy;
     QObject *m_qmlEngine;
-    QDeclarativeDebugExpressionQuery *m_debugQuery;
+    quint32 m_debugQuery;
 
     // Qml/JS integration
     QHash<QString, QmlJSLiveTextPreview *> m_textPreviews;

src/plugins/qmljsinspector/qmljsinspectorclient.cpp

@@ -182,15 +182,15 @@ void QmlJSInspectorClient::setCurrentObjects(const QList<int> &debugIds)
     sendMessage(message);
 }
 
-void recurseObjectIdList(const QDeclarativeDebugObjectReference &ref, QList<int> &debugIds, QList<QString> &objectIds)
+void recurseObjectIdList(const QmlDebugObjectReference &ref, QList<int> &debugIds, QList<QString> &objectIds)
 {
     debugIds << ref.debugId();
     objectIds << ref.idString();
-    foreach (const QDeclarativeDebugObjectReference &child, ref.children())
+    foreach (const QmlDebugObjectReference &child, ref.children())
         recurseObjectIdList(child, debugIds, objectIds);
 }
 
-void QmlJSInspectorClient::setObjectIdList(const QList<QDeclarativeDebugObjectReference> &objectRoots)
+void QmlJSInspectorClient::setObjectIdList(const QList<QmlDebugObjectReference> &objectRoots)
 {
     QByteArray message;
     QDataStream ds(&message, QIODevice::WriteOnly);
@@ -198,7 +198,7 @@ void QmlJSInspectorClient::setObjectIdList(const QList<QDeclarativeDebugObjectRe
     QList<int> debugIds;
     QList<QString> objectIds;
 
-    foreach (const QDeclarativeDebugObjectReference &ref, objectRoots)
+    foreach (const QmlDebugObjectReference &ref, objectRoots)
         recurseObjectIdList(ref, debugIds, objectIds);
 
     InspectorProtocol::Message cmd = InspectorProtocol::ObjectIdList;

src/plugins/qmljsinspector/qmljsinspectorclient.h

@@ -68,7 +68,7 @@ public:
     QList<int> currentObjects() const;
 
     // ### Qt 4.8: remove if we can have access to qdeclarativecontextdata or id's
-    void setObjectIdList(const QList<QDeclarativeDebugObjectReference> &objectRoots);
+    void setObjectIdList(const QList<QmlDebugObjectReference> &objectRoots);
 
     void clearComponentCache();
 

src/plugins/qmljsinspector/qmljslivetextpreview.cpp

@@ -220,7 +220,7 @@ void QmlJSLiveTextPreview::changeSelectedElements(QList<int> offsets, const QStr
     if (m_editors.isEmpty() || !m_previousDoc || !m_clientProxy)
         return;
 
-    QDeclarativeDebugObjectReference objectRefUnderCursor;
+    QmlDebugObjectReference objectRefUnderCursor;
     objectRefUnderCursor = m_clientProxy.data()->objectReferenceForId(wordAtCursor);
 
     QList<int> selectedReferences;
@@ -252,20 +252,20 @@ void QmlJSLiveTextPreview::changeSelectedElements(QList<int> offsets, const QStr
     }
 
     if (!selectedReferences.isEmpty()) {
-        QList<QDeclarativeDebugObjectReference> refs;
+        QList<QmlDebugObjectReference> refs;
         foreach(int i, selectedReferences)
-            refs << QDeclarativeDebugObjectReference(i);
+            refs << QmlDebugObjectReference(i);
         emit selectedItemsChanged(refs);
     }
 }
 
-static QList<int> findRootObjectRecursive(const QDeclarativeDebugObjectReference &object, const Document::Ptr &doc)
+static QList<int> findRootObjectRecursive(const QmlDebugObjectReference &object, const Document::Ptr &doc)
 {
     QList<int> result;
     if (object.className() == doc->componentName())
         result += object.debugId();
 
-    foreach (const QDeclarativeDebugObjectReference &it, object.children()) {
+    foreach (const QmlDebugObjectReference &it, object.children()) {
         result += findRootObjectRecursive(it, doc);
     }
     return result;
@@ -305,7 +305,7 @@ void QmlJSLiveTextPreview::updateDebugIds()
     if(doc->qmlProgram()->members &&  doc->qmlProgram()->members->member) {
         UiObjectMember* root = doc->qmlProgram()->members->member;
         QList<int> r;
-        foreach(const QDeclarativeDebugObjectReference& it, clientProxy->rootObjectReference())
+        foreach (const QmlDebugObjectReference& it, clientProxy->rootObjectReference())
             r += findRootObjectRecursive(it, doc);
         if (!r.isEmpty())
             m_debugIds[root] += r;
@@ -464,7 +464,10 @@ protected:
         if (isLiteral)
             expr = castToLiteral(scriptCode, scriptBinding);
         appliedChangesToViewer = true;
-        m_clientProxy->setBindingForObject(debugId, propertyName, expr, isLiteral, document()->fileName(), scriptBinding->firstSourceLocation().startLine);
+        m_clientProxy->setBindingForObject(
+                    debugId, propertyName, expr,
+                    isLiteral, document()->fileName(),
+                    scriptBinding->firstSourceLocation().startLine);
     }
 
     virtual void resetBindingForObject(int debugId, const QString &propertyName)

src/plugins/qmljsinspector/qmljslivetextpreview.h

@@ -72,8 +72,8 @@ public:
 
     void associateEditor(Core::IEditor *editor);
     void unassociateEditor(Core::IEditor *editor);
-    void setActiveObject(const QDeclarativeDebugObjectReference &object);
+    void setActiveObject(const QmlDebugObjectReference &object);
-    void mapObjectToQml(const QDeclarativeDebugObjectReference &object);
+    void mapObjectToQml(const QmlDebugObjectReference &object);
     void resetInitialDoc(const QmlJS::Document::Ptr &doc);
 
     void setClientProxy(ClientProxy *clientProxy);
@@ -85,7 +85,7 @@ public:
     };
 
 signals:
-    void selectedItemsChanged(const QList<QDeclarativeDebugObjectReference> &objects);
+    void selectedItemsChanged(const QList<QmlDebugObjectReference> &objects);
     void reloadQmlViewerRequested();
     void disableLivePreviewRequested();
 

src/plugins/qmljsinspector/qmljspropertyinspector.cpp

@@ -295,14 +295,14 @@ void QmlJSPropertyInspector::clear()
     m_currentObjects.clear();
 }
 
-void QmlJSPropertyInspector::setCurrentObjects(const QList<QDeclarativeDebugObjectReference> &objectList)
+void QmlJSPropertyInspector::setCurrentObjects(const QList<QmlDebugObjectReference> &objectList)
 {
     if (objectList.isEmpty())
         return;
 
     clear();
 
-    foreach (const QDeclarativeDebugObjectReference &obj, objectList) {
+    foreach (const QmlDebugObjectReference &obj, objectList) {
         m_currentObjects << obj.debugId();
         buildPropertyTree(obj);
     }
@@ -350,7 +350,7 @@ void QmlJSPropertyInspector::propertyValueEdited(const int objectId,const QStrin
     emit changePropertyValue(objectId, propertyName, propertyValue);
 }
 
-void QmlJSPropertyInspector::buildPropertyTree(const QDeclarativeDebugObjectReference &obj)
+void QmlJSPropertyInspector::buildPropertyTree(const QmlDebugObjectReference &obj)
 {
     // Strip off the misleading metadata
     QString objTypeName = obj.className();
@@ -375,7 +375,7 @@ void QmlJSPropertyInspector::buildPropertyTree(const QDeclarativeDebugObjectRefe
                false);
     }
 
-    foreach (const QDeclarativeDebugPropertyReference &prop, obj.properties()) {
+    foreach (const QmlDebugPropertyReference &prop, obj.properties()) {
         QString propertyName = prop.name();
         QString propertyValue = prop.value().toString();
 

src/plugins/qmljsinspector/qmljspropertyinspector.h

@@ -129,7 +129,7 @@ signals:
     void customContextMenuRequested(const QPoint &pos);
 
 public slots:
-    void setCurrentObjects(const QList<QDeclarativeDebugObjectReference> &);
+    void setCurrentObjects(const QList<QmlDebugObjectReference> &);
     void propertyValueEdited(const int objectId,const QString &propertyName, const QString &propertyValue);
     void propertyValueChanged(int debugId, const QByteArray &propertyName, const QVariant &propertyValue);
     void filterBy(const QString &expression);
@@ -139,7 +139,7 @@ public slots:
 
 private:
     friend class PropertyEditDelegate;
-    void buildPropertyTree(const QDeclarativeDebugObjectReference &);
+    void buildPropertyTree(const QmlDebugObjectReference &);
     void addRow(const QString &name, const QString &value, const QString &type,
                 const int debugId = -1, bool editable = true);
     void setColorIcon(int row);