AbstractViewInspector::AbstractViewInspector(QObject *parent) :
QObject(parent),
m_enabled(false),
- m_debugService(QQmlInspectorService::instance()),
+ m_debugService(QQmlInspectorServiceImpl::instance()),
m_eventId(0),
m_reloadEventId(-1)
{
QT_BEGIN_NAMESPACE
class QQmlEngine;
-class QQmlInspectorService;
+class QQmlDebugService;
class QKeyEvent;
class QMouseEvent;
class QWheelEvent;
bool m_enabled;
- QQmlInspectorService *m_debugService;
+ QQmlDebugService *m_debugService;
QList<AbstractTool *> m_tools;
int m_eventId;
int m_reloadEventId;
$$PWD/qqmldebug.cpp \
$$PWD/qqmldebugconnector.cpp \
$$PWD/qqmldebugservice.cpp \
+ $$PWD/qqmldebugserviceinterfaces.cpp \
$$PWD/qqmlprofilerservice.cpp \
$$PWD/qqmldebugserver.cpp \
$$PWD/qqmlinspectorservice.cpp \
$$PWD/qqmlprofilerservice_p.h \
$$PWD/qqmldebugserver_p.h \
$$PWD/qqmldebugserverconnection_p.h \
+ $$PWD/qqmldebugserviceinterfaces_p.h \
$$PWD/qqmldebugstatesdelegate_p.h \
$$PWD/qqmlinspectorservice_p.h \
$$PWD/qqmlinspectorinterface_p.h \
class QQmlConfigurableDebugService : public Base
{
protected:
- QQmlConfigurableDebugService(const QString &name, float version, QObject *parent = 0) :
- Base(name, version, parent), m_configMutex(QMutex::Recursive)
+ QQmlConfigurableDebugService(float version, QObject *parent = 0) :
+ Base(version, parent), m_configMutex(QMutex::Recursive)
{
init();
}
}
params->instance = loadQQmlDebugConnector(QLatin1String("QQmlDebugServer"));
if (params->instance) {
- QQmlEngineDebugService::instance();
- QV4DebugService::instance();
- QQmlProfilerService::instance();
+ QQmlEngineDebugServiceImpl::instance();
+ QV4DebugServiceImpl::instance();
+ QQmlProfilerServiceImpl::instance();
QDebugMessageService::instance();
QQmlEngineControlService::instance();
- QQmlInspectorService::instance();
+ QQmlInspectorServiceImpl::instance();
}
}
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qqmldebugserviceinterfaces_p.h"
+
+QT_BEGIN_NAMESPACE
+
+const QString QV4DebugService::s_key = QStringLiteral("V8Debugger");
+const QString QQmlEngineDebugService::s_key = QStringLiteral("QmlDebugger");
+const QString QQmlInspectorService::s_key = QStringLiteral("QmlInspector");
+const QString QQmlProfilerService::s_key = QStringLiteral("CanvasFrameRate");
+
+QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQMLDEBUGSERVICEINTERFACES_P_H
+#define QQMLDEBUGSERVICEINTERFACES_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/qstring.h>
+#include <private/qtqmlglobal_p.h>
+#include <private/qqmldebugservice_p.h>
+#include <private/qqmldebugstatesdelegate_p.h>
+#include <private/qqmlabstractprofileradapter_p.h>
+#include <private/qqmlboundsignal_p.h>
+
+#include <limits>
+
+QT_BEGIN_NAMESPACE
+
+class Q_QML_PRIVATE_EXPORT QV4DebugService : protected QQmlDebugService
+{
+ Q_OBJECT
+public:
+ virtual void signalEmitted(const QString &signal) = 0;
+
+protected:
+ QV4DebugService(float version, QObject *parent = 0) :
+ QQmlDebugService(s_key, version, parent) {}
+
+ static const QString s_key;
+};
+
+class Q_QML_PRIVATE_EXPORT QQmlProfilerService : protected QQmlDebugService
+{
+ Q_OBJECT
+public:
+ virtual void addGlobalProfiler(QQmlAbstractProfilerAdapter *profiler) = 0;
+ virtual void removeGlobalProfiler(QQmlAbstractProfilerAdapter *profiler) = 0;
+
+ virtual void startProfiling(QQmlEngine *engine,
+ quint64 features = std::numeric_limits<quint64>::max()) = 0;
+ virtual void stopProfiling(QQmlEngine *engine) = 0;
+
+ virtual void dataReady(QQmlAbstractProfilerAdapter *profiler) = 0;
+
+protected:
+ QQmlProfilerService(float version, QObject *parent = 0) :
+ QQmlDebugService(s_key, version, parent) {}
+
+ static const QString s_key;
+};
+
+class Q_QML_PRIVATE_EXPORT QQmlEngineDebugService : protected QQmlDebugService
+{
+ Q_OBJECT
+public:
+ virtual void objectCreated(QQmlEngine *engine, QObject *object) = 0;
+ virtual void setStatesDelegate(QQmlDebugStatesDelegate *) = 0;
+
+protected:
+ QQmlEngineDebugService(float version, QObject *parent = 0) :
+ QQmlDebugService(s_key, version, parent) {}
+
+ QQmlBoundSignal *nextSignal(QQmlBoundSignal *prev) { return prev->m_nextSignal; }
+
+ static const QString s_key;
+};
+
+class Q_QML_PRIVATE_EXPORT QQmlInspectorService : protected QQmlDebugService
+{
+ Q_OBJECT
+public:
+ virtual void addView(QObject *) = 0;
+ virtual void removeView(QObject *) = 0;
+
+protected:
+ QQmlInspectorService(float version, QObject *parent = 0) :
+ QQmlDebugService(s_key, version, parent) {}
+
+ static const QString s_key;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQMLDEBUGSERVICEINTERFACES_P_H
+
QT_BEGIN_NAMESPACE
-Q_GLOBAL_STATIC(QQmlEngineDebugService, qmlEngineDebugService)
+Q_GLOBAL_STATIC(QQmlEngineDebugServiceImpl, qmlEngineDebugService)
-QQmlEngineDebugService *QQmlEngineDebugService::instance()
+QQmlEngineDebugServiceImpl *QQmlEngineDebugServiceImpl::instance()
{
return qmlEngineDebugService();
}
-QQmlEngineDebugService::QQmlEngineDebugService(QObject *parent)
- : QQmlDebugService(QStringLiteral("QmlDebugger"), 2, parent),
- m_watch(new QQmlWatcher(this)),
- m_statesDelegate(0)
+QQmlEngineDebugServiceImpl::QQmlEngineDebugServiceImpl(QObject *parent) :
+ QQmlEngineDebugService(2, parent), m_watch(new QQmlWatcher(this)), m_statesDelegate(0)
{
QObject::connect(m_watch, SIGNAL(propertyChanged(int,int,QMetaProperty,QVariant)),
this, SLOT(propertyChanged(int,int,QMetaProperty,QVariant)));
}
-QQmlEngineDebugService::~QQmlEngineDebugService()
+QQmlEngineDebugServiceImpl::~QQmlEngineDebugServiceImpl()
{
delete m_statesDelegate;
}
QDataStream &operator<<(QDataStream &ds,
- const QQmlEngineDebugService::QQmlObjectData &data)
+ const QQmlEngineDebugServiceImpl::QQmlObjectData &data)
{
ds << data.url << data.lineNumber << data.columnNumber << data.idString
<< data.objectName << data.objectType << data.objectId << data.contextId
}
QDataStream &operator>>(QDataStream &ds,
- QQmlEngineDebugService::QQmlObjectData &data)
+ QQmlEngineDebugServiceImpl::QQmlObjectData &data)
{
ds >> data.url >> data.lineNumber >> data.columnNumber >> data.idString
>> data.objectName >> data.objectType >> data.objectId >> data.contextId
}
QDataStream &operator<<(QDataStream &ds,
- const QQmlEngineDebugService::QQmlObjectProperty &data)
+ const QQmlEngineDebugServiceImpl::QQmlObjectProperty &data)
{
ds << (int)data.type << data.name;
// check first whether the data can be saved
}
QDataStream &operator>>(QDataStream &ds,
- QQmlEngineDebugService::QQmlObjectProperty &data)
+ QQmlEngineDebugServiceImpl::QQmlObjectProperty &data)
{
int type;
ds >> type >> data.name >> data.value >> data.valueTypeName
>> data.binding >> data.hasNotifySignal;
- data.type = (QQmlEngineDebugService::QQmlObjectProperty::Type)type;
+ data.type = (QQmlEngineDebugServiceImpl::QQmlObjectProperty::Type)type;
return ds;
}
return true;
}
-QQmlEngineDebugService::QQmlObjectProperty
-QQmlEngineDebugService::propertyData(QObject *obj, int propIdx)
+QQmlEngineDebugServiceImpl::QQmlObjectProperty
+QQmlEngineDebugServiceImpl::propertyData(QObject *obj, int propIdx)
{
QQmlObjectProperty rv;
return rv;
}
-QVariant QQmlEngineDebugService::valueContents(QVariant value) const
+QVariant QQmlEngineDebugServiceImpl::valueContents(QVariant value) const
{
// We can't send JS objects across the wire, so transform them to variant
// maps for serialization.
return QString(QStringLiteral("<unknown value>"));
}
-void QQmlEngineDebugService::buildObjectDump(QDataStream &message,
+void QQmlEngineDebugServiceImpl::buildObjectDump(QDataStream &message,
QObject *object, bool recur, bool dumpProperties)
{
message << objectData(object);
}
fakeProperties << prop;
- signalHandler = signalHandler->m_nextSignal;
+ signalHandler = nextSignal(signalHandler);
}
}
message << fakeProperties[ii];
}
-void QQmlEngineDebugService::prepareDeferredObjects(QObject *obj)
+void QQmlEngineDebugServiceImpl::prepareDeferredObjects(QObject *obj)
{
qmlExecuteDeferred(obj);
}
-void QQmlEngineDebugService::storeObjectIds(QObject *co)
+void QQmlEngineDebugServiceImpl::storeObjectIds(QObject *co)
{
QQmlDebugService::idForObject(co);
QObjectList children = co->children();
storeObjectIds(children.at(ii));
}
-void QQmlEngineDebugService::buildObjectList(QDataStream &message,
+void QQmlEngineDebugServiceImpl::buildObjectList(QDataStream &message,
QQmlContext *ctxt,
const QList<QPointer<QObject> > &instances)
{
}
}
-void QQmlEngineDebugService::buildStatesList(bool cleanList,
+void QQmlEngineDebugServiceImpl::buildStatesList(bool cleanList,
const QList<QPointer<QObject> > &instances)
{
if (m_statesDelegate)
m_statesDelegate->buildStatesList(cleanList, instances);
}
-QQmlEngineDebugService::QQmlObjectData
-QQmlEngineDebugService::objectData(QObject *object)
+QQmlEngineDebugServiceImpl::QQmlObjectData
+QQmlEngineDebugServiceImpl::objectData(QObject *object)
{
QQmlData *ddata = QQmlData::get(object);
QQmlObjectData rv;
return rv;
}
-void QQmlEngineDebugService::messageReceived(const QByteArray &message)
+void QQmlEngineDebugServiceImpl::messageReceived(const QByteArray &message)
{
QMetaObject::invokeMethod(this, "processMessage", Qt::QueuedConnection, Q_ARG(QByteArray, message));
}
/*!
Returns a list of objects matching the given filename, line and column.
*/
-QList<QObject*> QQmlEngineDebugService::objectForLocationInfo(const QString &filename,
+QList<QObject*> QQmlEngineDebugServiceImpl::objectForLocationInfo(const QString &filename,
int lineNumber, int columnNumber)
{
QList<QObject *> objects;
return objects;
}
-void QQmlEngineDebugService::processMessage(const QByteArray &message)
+void QQmlEngineDebugServiceImpl::processMessage(const QByteArray &message)
{
QQmlDebugStream ds(message);
emit messageToClient(name(), reply);
}
-bool QQmlEngineDebugService::setBinding(int objectId,
+bool QQmlEngineDebugServiceImpl::setBinding(int objectId,
const QString &propertyName,
const QVariant &expression,
bool isLiteralValue,
return ok;
}
-bool QQmlEngineDebugService::resetBinding(int objectId, const QString &propertyName)
+bool QQmlEngineDebugServiceImpl::resetBinding(int objectId, const QString &propertyName)
{
QObject *object = objectForId(objectId);
QQmlContext *context = qmlContext(object);
return false;
}
-bool QQmlEngineDebugService::setMethodBody(int objectId, const QString &method, const QString &body)
+bool QQmlEngineDebugServiceImpl::setMethodBody(int objectId, const QString &method, const QString &body)
{
QObject *object = objectForId(objectId);
QQmlContext *context = qmlContext(object);
return true;
}
-void QQmlEngineDebugService::propertyChanged(int id, int objectId, const QMetaProperty &property, const QVariant &value)
+void QQmlEngineDebugServiceImpl::propertyChanged(int id, int objectId, const QMetaProperty &property, const QVariant &value)
{
QByteArray reply;
QQmlDebugStream rs(&reply, QIODevice::WriteOnly);
emit messageToClient(name(), reply);
}
-void QQmlEngineDebugService::engineAboutToBeAdded(QQmlEngine *engine)
+void QQmlEngineDebugServiceImpl::engineAboutToBeAdded(QQmlEngine *engine)
{
Q_ASSERT(engine);
Q_ASSERT(!m_engines.contains(engine));
emit attachedToEngine(engine);
}
-void QQmlEngineDebugService::engineAboutToBeRemoved(QQmlEngine *engine)
+void QQmlEngineDebugServiceImpl::engineAboutToBeRemoved(QQmlEngine *engine)
{
Q_ASSERT(engine);
Q_ASSERT(m_engines.contains(engine));
emit detachedFromEngine(engine);
}
-void QQmlEngineDebugService::objectCreated(QQmlEngine *engine, QObject *object)
+void QQmlEngineDebugServiceImpl::objectCreated(QQmlEngine *engine, QObject *object)
{
Q_ASSERT(engine);
Q_ASSERT(m_engines.contains(engine));
emit messageToClient(name(), reply);
}
-void QQmlEngineDebugService::setStatesDelegate(QQmlDebugStatesDelegate *delegate)
+void QQmlEngineDebugServiceImpl::setStatesDelegate(QQmlDebugStatesDelegate *delegate)
{
m_statesDelegate = delegate;
}
//
#include <private/qqmldebugservice_p.h>
+#include <private/qqmldebugserviceinterfaces_p.h>
#include <QtCore/qurl.h>
#include <QtCore/qvariant.h>
class QDataStream;
class QQmlDebugStatesDelegate;
-class Q_QML_PRIVATE_EXPORT QQmlEngineDebugService : public QQmlDebugService
+class Q_QML_PRIVATE_EXPORT QQmlEngineDebugServiceImpl : public QQmlEngineDebugService
{
Q_OBJECT
public:
- QQmlEngineDebugService(QObject * = 0);
- ~QQmlEngineDebugService();
+ QQmlEngineDebugServiceImpl(QObject * = 0);
+ ~QQmlEngineDebugServiceImpl();
struct QQmlObjectData {
QUrl url;
void setStatesDelegate(QQmlDebugStatesDelegate *);
- static QQmlEngineDebugService *instance();
+ static QQmlEngineDebugServiceImpl *instance();
protected:
virtual void messageReceived(const QByteArray &);
QQmlWatcher *m_watch;
QQmlDebugStatesDelegate *m_statesDelegate;
};
-Q_QML_PRIVATE_EXPORT QDataStream &operator<<(QDataStream &, const QQmlEngineDebugService::QQmlObjectData &);
-Q_QML_PRIVATE_EXPORT QDataStream &operator>>(QDataStream &, QQmlEngineDebugService::QQmlObjectData &);
-Q_QML_PRIVATE_EXPORT QDataStream &operator<<(QDataStream &, const QQmlEngineDebugService::QQmlObjectProperty &);
-Q_QML_PRIVATE_EXPORT QDataStream &operator>>(QDataStream &, QQmlEngineDebugService::QQmlObjectProperty &);
+Q_QML_PRIVATE_EXPORT QDataStream &operator<<(QDataStream &, const QQmlEngineDebugServiceImpl::QQmlObjectData &);
+Q_QML_PRIVATE_EXPORT QDataStream &operator>>(QDataStream &, QQmlEngineDebugServiceImpl::QQmlObjectData &);
+Q_QML_PRIVATE_EXPORT QDataStream &operator<<(QDataStream &, const QQmlEngineDebugServiceImpl::QQmlObjectProperty &);
+Q_QML_PRIVATE_EXPORT QDataStream &operator>>(QDataStream &, QQmlEngineDebugServiceImpl::QQmlObjectProperty &);
QT_END_NAMESPACE
QT_BEGIN_NAMESPACE
-Q_GLOBAL_STATIC(QQmlInspectorService, serviceInstance)
+Q_GLOBAL_STATIC(QQmlInspectorServiceImpl, serviceInstance)
-QQmlInspectorService::QQmlInspectorService()
- : QQmlDebugService(QStringLiteral("QmlInspector"), 1)
- , m_currentInspectorPlugin(0)
+QQmlInspectorServiceImpl::QQmlInspectorServiceImpl(): QQmlInspectorService(1),
+ m_currentInspectorPlugin(0)
{
}
-QQmlInspectorService *QQmlInspectorService::instance()
+QQmlInspectorServiceImpl *QQmlInspectorServiceImpl::instance()
{
return serviceInstance();
}
-void QQmlInspectorService::addView(QObject *view)
+void QQmlInspectorServiceImpl::addView(QObject *view)
{
m_views.append(view);
updateState();
}
-void QQmlInspectorService::removeView(QObject *view)
+void QQmlInspectorServiceImpl::removeView(QObject *view)
{
m_views.removeAll(view);
updateState();
}
-void QQmlInspectorService::stateChanged(State /*state*/)
+void QQmlInspectorServiceImpl::stateChanged(State /*state*/)
{
QMetaObject::invokeMethod(this, "updateState", Qt::QueuedConnection);
}
-void QQmlInspectorService::updateState()
+void QQmlInspectorServiceImpl::updateState()
{
if (m_views.isEmpty()) {
if (m_currentInspectorPlugin) {
}
}
-void QQmlInspectorService::messageReceived(const QByteArray &message)
+void QQmlInspectorServiceImpl::messageReceived(const QByteArray &message)
{
QMetaObject::invokeMethod(this, "processMessage", Qt::QueuedConnection, Q_ARG(QByteArray, message));
}
-void QQmlInspectorService::processMessage(const QByteArray &message)
+void QQmlInspectorServiceImpl::processMessage(const QByteArray &message)
{
if (m_currentInspectorPlugin)
m_currentInspectorPlugin->clientMessage(message);
}
-void QQmlInspectorService::loadInspectorPlugins()
+void QQmlInspectorServiceImpl::loadInspectorPlugins()
{
#ifndef QT_NO_LIBRARY
QStringList pluginCandidates;
//
#include "qqmldebugservice_p.h"
+#include "qqmldebugserviceinterfaces_p.h"
#include <QtQml/qtqmlglobal.h>
#include <QtCore/QList>
QT_BEGIN_NAMESPACE
+namespace QmlJSDebugger { class AbstractViewInspector; }
class QQmlInspectorInterface;
-class Q_QML_PRIVATE_EXPORT QQmlInspectorService : public QQmlDebugService
+class Q_QML_PRIVATE_EXPORT QQmlInspectorServiceImpl : public QQmlInspectorService
{
Q_OBJECT
public:
- QQmlInspectorService();
- static QQmlInspectorService *instance();
+ QQmlInspectorServiceImpl();
+ static QQmlInspectorServiceImpl *instance();
void addView(QObject *);
void removeView(QObject *);
void updateState();
private:
+ friend class QmlJSDebugger::AbstractViewInspector;
void loadInspectorPlugins();
QList<QObject*> m_views;
QT_BEGIN_NAMESPACE
-Q_GLOBAL_STATIC(QQmlProfilerService, profilerInstance)
+Q_GLOBAL_STATIC(QQmlProfilerServiceImpl, profilerInstance)
-QQmlProfilerService::QQmlProfilerService()
- : QQmlConfigurableDebugService<QQmlDebugService>(QStringLiteral("CanvasFrameRate"), 1),
+QQmlProfilerServiceImpl::QQmlProfilerServiceImpl()
+ : QQmlConfigurableDebugService<QQmlProfilerService>(1),
m_waitingForStop(false)
{
m_timer.start();
}
-QQmlProfilerService::~QQmlProfilerService()
+QQmlProfilerServiceImpl::~QQmlProfilerServiceImpl()
{
// No need to lock here. If any engine or global profiler is still trying to register at this
// point we have a nasty bug anyway.
qDeleteAll(m_globalProfilers);
}
-void QQmlProfilerService::dataReady(QQmlAbstractProfilerAdapter *profiler)
+void QQmlProfilerServiceImpl::dataReady(QQmlAbstractProfilerAdapter *profiler)
{
QMutexLocker lock(&m_configMutex);
bool dataComplete = true;
}
}
-QQmlProfilerService *QQmlProfilerService::instance()
+QQmlProfilerServiceImpl *QQmlProfilerServiceImpl::instance()
{
// just make sure that the service is properly registered
return profilerInstance();
}
-void QQmlProfilerService::engineAboutToBeAdded(QQmlEngine *engine)
+void QQmlProfilerServiceImpl::engineAboutToBeAdded(QQmlEngine *engine)
{
Q_ASSERT_X(QThread::currentThread() == engine->thread(), Q_FUNC_INFO,
"QML profilers have to be added from the engine thread");
QV4ProfilerAdapter *v4Adapter = new QV4ProfilerAdapter(this, QV8Engine::getV4(engine->handle()));
addEngineProfiler(qmlAdapter, engine);
addEngineProfiler(v4Adapter, engine);
- QQmlConfigurableDebugService<QQmlDebugService>::engineAboutToBeAdded(engine);
+ QQmlConfigurableDebugService<QQmlProfilerService>::engineAboutToBeAdded(engine);
}
-void QQmlProfilerService::engineAdded(QQmlEngine *engine)
+void QQmlProfilerServiceImpl::engineAdded(QQmlEngine *engine)
{
Q_ASSERT_X(QThread::currentThread() == engine->thread(), Q_FUNC_INFO,
"QML profilers have to be added from the engine thread");
profiler->stopWaiting();
}
-void QQmlProfilerService::engineAboutToBeRemoved(QQmlEngine *engine)
+void QQmlProfilerServiceImpl::engineAboutToBeRemoved(QQmlEngine *engine)
{
Q_ASSERT_X(QThread::currentThread() == engine->thread(), Q_FUNC_INFO,
"QML profilers have to be removed from the engine thread");
}
}
-void QQmlProfilerService::engineRemoved(QQmlEngine *engine)
+void QQmlProfilerServiceImpl::engineRemoved(QQmlEngine *engine)
{
Q_ASSERT_X(QThread::currentThread() == engine->thread(), Q_FUNC_INFO,
"QML profilers have to be removed from the engine thread");
m_engineProfilers.remove(engine);
}
-void QQmlProfilerService::addEngineProfiler(QQmlAbstractProfilerAdapter *profiler, QQmlEngine *engine)
+void QQmlProfilerServiceImpl::addEngineProfiler(QQmlAbstractProfilerAdapter *profiler, QQmlEngine *engine)
{
profiler->moveToThread(thread());
profiler->synchronize(m_timer);
m_engineProfilers.insert(engine, profiler);
}
-void QQmlProfilerService::addGlobalProfiler(QQmlAbstractProfilerAdapter *profiler)
+void QQmlProfilerServiceImpl::addGlobalProfiler(QQmlAbstractProfilerAdapter *profiler)
{
QMutexLocker lock(&m_configMutex);
profiler->synchronize(m_timer);
profiler->startProfiling(features);
}
-void QQmlProfilerService::removeGlobalProfiler(QQmlAbstractProfilerAdapter *profiler)
+void QQmlProfilerServiceImpl::removeGlobalProfiler(QQmlAbstractProfilerAdapter *profiler)
{
QMutexLocker lock(&m_configMutex);
removeProfilerFromStartTimes(profiler);
delete profiler;
}
-void QQmlProfilerService::removeProfilerFromStartTimes(const QQmlAbstractProfilerAdapter *profiler)
+void QQmlProfilerServiceImpl::removeProfilerFromStartTimes(const QQmlAbstractProfilerAdapter *profiler)
{
for (QMultiMap<qint64, QQmlAbstractProfilerAdapter *>::iterator i(m_startTimes.begin());
i != m_startTimes.end();) {
*
* If any engine profiler is started like that also start all global profilers.
*/
-void QQmlProfilerService::startProfiling(QQmlEngine *engine, quint64 features)
+void QQmlProfilerServiceImpl::startProfiling(QQmlEngine *engine, quint64 features)
{
QMutexLocker lock(&m_configMutex);
* If afterwards no more engine profilers are running, also stop all global profilers. Otherwise
* only make them report their data.
*/
-void QQmlProfilerService::stopProfiling(QQmlEngine *engine)
+void QQmlProfilerServiceImpl::stopProfiling(QQmlEngine *engine)
{
QMutexLocker lock(&m_configMutex);
QList<QQmlAbstractProfilerAdapter *> stopping;
/*
Send the queued up messages.
*/
-void QQmlProfilerService::sendMessages()
+void QQmlProfilerServiceImpl::sendMessages()
{
QList<QByteArray> messages;
}
}
-void QQmlProfilerService::stateAboutToBeChanged(QQmlDebugService::State newState)
+void QQmlProfilerServiceImpl::stateAboutToBeChanged(QQmlDebugService::State newState)
{
QMutexLocker lock(&m_configMutex);
}
}
-void QQmlProfilerService::messageReceived(const QByteArray &message)
+void QQmlProfilerServiceImpl::messageReceived(const QByteArray &message)
{
QMutexLocker lock(&m_configMutex);
stopWaiting();
}
-void QQmlProfilerService::flush()
+void QQmlProfilerServiceImpl::flush()
{
QMutexLocker lock(&m_configMutex);
//
#include "qqmlconfigurabledebugservice_p.h"
+#include "qqmldebugserviceinterfaces_p.h"
#include "qqmlprofilerdefinitions_p.h"
#include "qqmlabstractprofileradapter_p.h"
class QQmlEngine;
-class Q_QML_PRIVATE_EXPORT QQmlProfilerService :
- public QQmlConfigurableDebugService<QQmlDebugService>,
+class Q_QML_PRIVATE_EXPORT QQmlProfilerServiceImpl :
+ public QQmlConfigurableDebugService<QQmlProfilerService>,
public QQmlProfilerDefinitions
{
Q_OBJECT
public:
- static QQmlProfilerService *instance();
+ static QQmlProfilerServiceImpl *instance();
void engineAboutToBeAdded(QQmlEngine *engine);
void engineAboutToBeRemoved(QQmlEngine *engine);
void engineAdded(QQmlEngine *engine);
void startProfiling(QQmlEngine *engine, quint64 features = std::numeric_limits<quint64>::max());
void stopProfiling(QQmlEngine *engine);
- QQmlProfilerService();
- ~QQmlProfilerService();
+ QQmlProfilerServiceImpl();
+ ~QQmlProfilerServiceImpl();
void dataReady(QQmlAbstractProfilerAdapter *profiler);
QT_BEGIN_NAMESPACE
-Q_GLOBAL_STATIC(QV4DebugService, v4ServiceInstance)
+Q_GLOBAL_STATIC(QV4DebugServiceImpl, v4ServiceInstance)
class V8CommandHandler;
class UnknownV8CommandHandler;
QHash<QV4::Object *, int> objectRefs;
};
-int QV4DebugService::debuggerIndex = 0;
-int QV4DebugService::sequence = 0;
+int QV4DebugServiceImpl::debuggerIndex = 0;
+int QV4DebugServiceImpl::sequence = 0;
class V8CommandHandler
{
QString command() const { return cmd; }
- void handle(const QJsonObject &request, QV4DebugService *s)
+ void handle(const QJsonObject &request, QV4DebugServiceImpl *s)
{
TRACE_PROTOCOL(qDebug() << "handling command" << command() << "...");
QString cmd;
QJsonObject req;
QJsonValue seq;
- QV4DebugService *debugService;
+ QV4DebugServiceImpl *debugService;
QJsonObject response;
};
};
} // anonymous namespace
-void QV4DebugService::addHandler(V8CommandHandler* handler)
+void QV4DebugServiceImpl::addHandler(V8CommandHandler* handler)
{
handlers[handler->command()] = handler;
}
-V8CommandHandler *QV4DebugService::v8CommandHandler(const QString &command) const
+V8CommandHandler *QV4DebugServiceImpl::v8CommandHandler(const QString &command) const
{
V8CommandHandler *handler = handlers.value(command, 0);
if (handler)
return unknownV8CommandHandler.data();
}
-QV4DebugService::QV4DebugService(QObject *parent) :
- QQmlConfigurableDebugService<QQmlDebugService>(QStringLiteral("V8Debugger"), 1, parent),
+QV4DebugServiceImpl::QV4DebugServiceImpl(QObject *parent) :
+ QQmlConfigurableDebugService<QV4DebugService>(1, parent),
debuggerAgent(this), version(1), theSelectedFrame(0),
unknownV8CommandHandler(new UnknownV8CommandHandler)
{
addHandler(new V8EvaluateRequest);
}
-QV4DebugService::~QV4DebugService()
+QV4DebugServiceImpl::~QV4DebugServiceImpl()
{
qDeleteAll(handlers);
}
-QV4DebugService *QV4DebugService::instance()
+QV4DebugServiceImpl *QV4DebugServiceImpl::instance()
{
return v4ServiceInstance();
}
-void QV4DebugService::engineAboutToBeAdded(QQmlEngine *engine)
+void QV4DebugServiceImpl::engineAboutToBeAdded(QQmlEngine *engine)
{
QMutexLocker lock(&m_configMutex);
if (engine) {
}
}
}
- QQmlConfigurableDebugService<QQmlDebugService>::engineAboutToBeAdded(engine);
+ QQmlConfigurableDebugService<QV4DebugService>::engineAboutToBeAdded(engine);
}
-void QV4DebugService::engineAboutToBeRemoved(QQmlEngine *engine)
+void QV4DebugServiceImpl::engineAboutToBeRemoved(QQmlEngine *engine)
{
QMutexLocker lock(&m_configMutex);
if (engine){
debuggerAgent.removeDebugger(debugger);
}
}
- QQmlConfigurableDebugService<QQmlDebugService>::engineAboutToBeRemoved(engine);
+ QQmlConfigurableDebugService<QV4DebugService>::engineAboutToBeRemoved(engine);
}
-void QV4DebugService::signalEmitted(const QString &signal)
+void QV4DebugServiceImpl::signalEmitted(const QString &signal)
{
//This function is only called by QQmlBoundSignal
//only if there is a slot connected to the signal. Hence, there
}
}
-void QV4DebugService::messageReceived(const QByteArray &message)
+void QV4DebugServiceImpl::messageReceived(const QByteArray &message)
{
QMutexLocker lock(&m_configMutex);
}
}
-void QV4DebugService::sendSomethingToSomebody(const char *type, int magicNumber)
+void QV4DebugServiceImpl::sendSomethingToSomebody(const char *type, int magicNumber)
{
QByteArray response;
QQmlDebugStream rs(&response, QIODevice::WriteOnly);
emit messageToClient(name(), packMessage(type, response));
}
-QV4DebuggerAgent::QV4DebuggerAgent(QV4DebugService *debugService)
+QV4DebuggerAgent::QV4DebuggerAgent(QV4DebugServiceImpl *debugService)
: debugService(debugService)
{}
debugService->send(response);
}
-void QV4DebugService::handleV8Request(const QByteArray &payload)
+void QV4DebugServiceImpl::handleV8Request(const QByteArray &payload)
{
TRACE_PROTOCOL(qDebug() << "v8request, payload:" << payload.constData());
}
}
-QByteArray QV4DebugService::packMessage(const QByteArray &command, const QByteArray &message)
+QByteArray QV4DebugServiceImpl::packMessage(const QByteArray &command, const QByteArray &message)
{
QByteArray reply;
QQmlDebugStream rs(&reply, QIODevice::WriteOnly);
return reply;
}
-void QV4DebugService::send(QJsonObject v8Payload)
+void QV4DebugServiceImpl::send(QJsonObject v8Payload)
{
v8Payload[QLatin1String("seq")] = sequence++;
QJsonDocument doc;
emit messageToClient(name(), packMessage("v8message", responseData));
}
-void QV4DebugService::clearHandles(QV4::ExecutionEngine *engine)
+void QV4DebugServiceImpl::clearHandles(QV4::ExecutionEngine *engine)
{
theCollector.reset(new VariableCollector(engine));
}
-QJsonObject QV4DebugService::buildFrame(const QV4::StackFrame &stackFrame, int frameNr,
+QJsonObject QV4DebugServiceImpl::buildFrame(const QV4::StackFrame &stackFrame, int frameNr,
QV4::Debugging::Debugger *debugger)
{
QJsonObject frame;
return frame;
}
-int QV4DebugService::encodeScopeType(QV4::Heap::ExecutionContext::ContextType scopeType)
+int QV4DebugServiceImpl::encodeScopeType(QV4::Heap::ExecutionContext::ContextType scopeType)
{
switch (scopeType) {
case QV4::Heap::ExecutionContext::Type_GlobalContext:
}
}
-QJsonObject QV4DebugService::buildScope(int frameNr, int scopeNr,
+QJsonObject QV4DebugServiceImpl::buildScope(int frameNr, int scopeNr,
QV4::Debugging::Debugger *debugger)
{
QJsonObject scope;
return scope;
}
-QJsonValue QV4DebugService::lookup(int refId) const
+QJsonValue QV4DebugServiceImpl::lookup(int refId) const
{
return theCollector->lookup(refId);
}
-QJsonArray QV4DebugService::buildRefs()
+QJsonArray QV4DebugServiceImpl::buildRefs()
{
return theCollector->retrieveRefsToInclude();
}
-VariableCollector *QV4DebugService::collector() const
+VariableCollector *QV4DebugServiceImpl::collector() const
{
return theCollector.data();
}
-void QV4DebugService::selectFrame(int frameNr)
+void QV4DebugServiceImpl::selectFrame(int frameNr)
{
theSelectedFrame = frameNr;
}
-int QV4DebugService::selectedFrame() const
+int QV4DebugServiceImpl::selectedFrame() const
{
return theSelectedFrame;
}
//
#include "qqmlconfigurabledebugservice_p.h"
+#include "qqmldebugserviceinterfaces_p.h"
#include <private/qv4debugging_p.h>
#include <QtCore/QJsonValue>
class VariableCollector;
class V8CommandHandler;
class UnknownV8CommandHandler;
-class QV4DebugService;
+class QV4DebugServiceImpl;
class QV4DebuggerAgent : public QV4::Debugging::DebuggerAgent
{
Q_OBJECT
public:
- QV4DebuggerAgent(QV4DebugService *debugService);
+ QV4DebuggerAgent(QV4DebugServiceImpl *debugService);
QV4::Debugging::Debugger *firstDebugger() const;
bool isRunning() const;
int requestSequenceNr);
private:
- QV4DebugService *debugService;
+ QV4DebugServiceImpl *debugService;
};
-class QV4DebugService : public QQmlConfigurableDebugService<QQmlDebugService>
+class QV4DebugServiceImpl : public QQmlConfigurableDebugService<QV4DebugService>
{
Q_OBJECT
public:
- explicit QV4DebugService(QObject *parent = 0);
- ~QV4DebugService();
+ explicit QV4DebugServiceImpl(QObject *parent = 0);
+ ~QV4DebugServiceImpl();
- static QV4DebugService *instance();
+ static QV4DebugServiceImpl *instance();
void engineAboutToBeAdded(QQmlEngine *engine);
void engineAboutToBeRemoved(QQmlEngine *engine);
return;
if (QQmlDebugConnector::instance())
- QV4DebugService::instance()->signalEmitted(QString::fromLatin1(QMetaObjectPrivate::signal(s->m_expression->target()->metaObject(), s->signalIndex()).methodSignature()));
+ QV4DebugServiceImpl::instance()->signalEmitted(QString::fromLatin1(QMetaObjectPrivate::signal(s->m_expression->target()->metaObject(), s->signalIndex()).methodSignature()));
QQmlEngine *engine;
if (s->m_expression && (engine = s->m_expression->engine())) {
if (enginePriv->isDebugging && rv) {
if (!context->isInternal)
context->asQQmlContextPrivate()->instances.append(rv);
- QQmlEngineDebugService::instance()->objectCreated(engine, rv);
+ QQmlEngineDebugServiceImpl::instance()->objectCreated(engine, rv);
}
return rv;
if (!QQmlDebugConnector::instance()) {
logger.warning("Cannot start profiling because debug service is disabled. Start with -qmljsdebugger=port:XXXXX.");
} else {
- QQmlProfilerService::instance()->startProfiling(v4->qmlEngine());
+ QQmlProfilerServiceImpl::instance()->startProfiling(v4->qmlEngine());
logger.debug("Profiling started.");
}
if (!QQmlDebugConnector::instance()) {
logger.warning("Ignoring console.profileEnd(): the debug service is disabled.");
} else {
- QQmlProfilerService::instance()->stopProfiling(v4->qmlEngine());
+ QQmlProfilerServiceImpl::instance()->stopProfiling(v4->qmlEngine());
logger.debug("Profiling ended.");
}
}
if (QQmlDebugConnector::instance())
- QQmlInspectorService::instance()->addView(q);
+ QQmlInspectorServiceImpl::instance()->addView(q);
}
QQuickViewPrivate::QQuickViewPrivate()
QQuickViewPrivate::~QQuickViewPrivate()
{
if (QQmlDebugConnector::instance())
- QQmlInspectorService::instance()->removeView(q_func());
+ QQmlInspectorServiceImpl::instance()->removeView(q_func());
}
void QQuickViewPrivate::execute()
#endif
if (QQmlDebugConnector::instance()) {
- QQmlEngineDebugService::instance()->setStatesDelegate(
+ QQmlEngineDebugServiceImpl::instance()->setStatesDelegate(
new QQmlQtQuick2DebugStatesDelegate);
QQuickProfiler::initialize();
}
void QQuickProfiler::initialize()
{
Q_ASSERT(s_instance == 0);
- QQmlProfilerService *service = QQmlProfilerService::instance();
+ QQmlProfilerServiceImpl *service = QQmlProfilerServiceImpl::instance();
s_instance = new QQuickProfiler(service);
- QQmlProfilerService::instance()->addGlobalProfiler(s_instance);
+ QQmlProfilerServiceImpl::instance()->addGlobalProfiler(s_instance);
}
void animationTimerCallback(qint64 delta)
engine.data()->setIncubationController(offscreenWindow->incubationController());
if (QQmlDebugConnector::instance())
- QQmlInspectorService::instance()->addView(q);
+ QQmlInspectorServiceImpl::instance()->addView(q);
#ifndef QT_NO_DRAGANDDROP
q->setAcceptDrops(true);
QQuickWidgetPrivate::~QQuickWidgetPrivate()
{
if (QQmlDebugConnector::instance())
- QQmlInspectorService::instance()->removeView(q_func());
+ QQmlInspectorServiceImpl::instance()->removeView(q_func());
invalidateRenderControl();
projects / platform / upstream / qtdeclarative.git / commitdiff