QmlProfiler: Unify event type definitions

Generally save both the Message and RangeType attributes so that we
avoid clashes between those types. Also keep all the types in one
place and make their names follow qtdeclarative's conventions.

Change-Id: I811bfcc4b72aaa2a0142babc92d96968ed2d4007
Reviewed-by: Kai Koehne <kai.koehne@digia.com>

20 files changed, 285 insertions, 230 deletions

diff --git a/src/libs/qmldebug/qmlprofilereventtypes.h b/src/libs/qmldebug/qmlprofilereventtypes.h
index 59e9987c57..d44ce22892 100644
--- a/src/libs/qmldebug/qmlprofilereventtypes.h
+++ b/src/libs/qmldebug/qmlprofilereventtypes.h
@@ -30,19 +30,43 @@
 #ifndef QMLPROFILEREVENTTYPES_H
 #define QMLPROFILEREVENTTYPES_H
 
+#include <QtGlobal>
+
 namespace QmlDebug {
 
-enum QmlEventType {
-    Painting,
+enum Message {
+    Event,
+    RangeStart,
+    RangeData,
+    RangeLocation,
+    RangeEnd,
+    Complete,
+    PixmapCacheEvent,
+    SceneGraphFrame,
+
+    MaximumMessage
+};
+
+enum EventType {
+    FramePaint, // unused
+    Mouse,
+    Key,
+    AnimationFrame, // new Qt5 paint events
+    EndTrace,
+    StartTrace,
+
+    MaximumEventType
+};
+
+enum RangeType {
+    Painting, // old Qt4 paint events
     Compiling,
     Creating,
     Binding,
     HandlingSignal,
     Javascript,
-    PixmapCacheEvent,
-    SceneGraphFrameEvent,
 
-    MaximumQmlEventType
+    MaximumRangeType
 };
 
 enum BindingType {
@@ -50,11 +74,36 @@ enum BindingType {
     V8Binding,
     OptimizedBinding,
     QPainterEvent,
-    AnimationFrame,
 
     MaximumBindingType
 };
 
+enum PixmapEventType {
+    PixmapSizeKnown,
+    PixmapReferenceCountChanged,
+    PixmapCacheCountChanged,
+    PixmapLoadingStarted,
+    PixmapLoadingFinished,
+    PixmapLoadingError,
+
+    MaximumPixmapEventType
+};
+
+enum SceneGraphFrameType {
+    SceneGraphRendererFrame,
+    SceneGraphAdaptationLayerFrame,
+    SceneGraphContextFrame,
+    SceneGraphRenderLoopFrame,
+    SceneGraphTexturePrepare,
+    SceneGraphTextureDeletion,
+    SceneGraphPolishAndSync,
+    SceneGraphWindowsRenderShow,
+    SceneGraphWindowsAnimations,
+    SceneGraphWindowsPolishFrame,
+
+    MaximumSceneGraphFrameType
+};
+
 enum AnimationThread {
     GuiThread,
     RenderThread,
diff --git a/src/libs/qmldebug/qmlprofilertraceclient.cpp b/src/libs/qmldebug/qmlprofilertraceclient.cpp
index ffbac4902f..1442cc63db 100644
--- a/src/libs/qmldebug/qmlprofilertraceclient.cpp
+++ b/src/libs/qmldebug/qmlprofilertraceclient.cpp
@@ -39,18 +39,18 @@ public:
         , maximumTime(0)
         , recording(false)
     {
-        ::memset(rangeCount, 0, MaximumQmlEventType * sizeof(int));
+        ::memset(rangeCount, 0, MaximumRangeType * sizeof(int));
     }
 
     void sendRecordingStatus();
 
     QmlProfilerTraceClient *q;
     qint64 inProgressRanges;
-    QStack<qint64> rangeStartTimes[MaximumQmlEventType];
-    QStack<QStringList> rangeDatas[MaximumQmlEventType];
-    QStack<QmlEventLocation> rangeLocations[MaximumQmlEventType];
+    QStack<qint64> rangeStartTimes[MaximumRangeType];
+    QStack<QStringList> rangeDatas[MaximumRangeType];
+    QStack<QmlEventLocation> rangeLocations[MaximumRangeType];
     QStack<BindingType> bindingTypes;
-    int rangeCount[MaximumQmlEventType];
+    int rangeCount[MaximumRangeType];
     qint64 maximumTime;
     bool recording;
 };
@@ -86,8 +86,8 @@ QmlProfilerTraceClient::~QmlProfilerTraceClient()
 
 void QmlProfilerTraceClient::clearData()
 {
-    ::memset(d->rangeCount, 0, MaximumQmlEventType * sizeof(int));
-    for (int eventType = 0; eventType < MaximumQmlEventType; eventType++) {
+    ::memset(d->rangeCount, 0, MaximumRangeType * sizeof(int));
+    for (int eventType = 0; eventType < MaximumRangeType; eventType++) {
         d->rangeDatas[eventType].clear();
         d->rangeLocations[eventType].clear();
         d->rangeStartTimes[eventType].clear();
@@ -175,8 +175,8 @@ void QmlProfilerTraceClient::messageReceived(const QByteArray &data)
                 stream >> threadId;
             else
                 threadId = 0;
-            emit rangedEvent(QmlDebug::Painting, QmlDebug::AnimationFrame, time, 0,
-                       QStringList(), QmlDebug::QmlEventLocation(), frameRate, animationCount, threadId,0,0);
+            emit rangedEvent(Event, MaximumRangeType, AnimationFrame, time, 0, QStringList(),
+                             QmlDebug::QmlEventLocation(), frameRate, animationCount, threadId,0,0);
             d->maximumTime = qMax(time, d->maximumTime);
         } else if (event == StartTrace) {
             emit this->traceStarted(time);
@@ -198,8 +198,9 @@ void QmlProfilerTraceClient::messageReceived(const QByteArray &data)
         }
         while (count<5)
             params[count++] = 0;
-        emit rangedEvent(SceneGraphFrameEvent, sgEventType,time, 0, QStringList(),
-                         QmlDebug::QmlEventLocation(), params[0], params[1], params[2], params[3], params[4]);
+        emit rangedEvent(SceneGraphFrame, QmlDebug::MaximumRangeType, sgEventType,time, 0,
+                         QStringList(), QmlDebug::QmlEventLocation(), params[0], params[1],
+                         params[2], params[3], params[4]);
     } else if (messageType == PixmapCacheEvent) {
         int pixEvTy, width = 0, height = 0, refcount = 0;
         QString pixUrl;
@@ -210,14 +211,15 @@ void QmlProfilerTraceClient::messageReceived(const QByteArray &data)
             stream >> width >> height;
             refcount = 1;
         }
-        emit rangedEvent(QmlDebug::PixmapCacheEvent, pixEvTy, time, 0, QStringList(),
-                        QmlDebug::QmlEventLocation(pixUrl,0,0), width, height, refcount, 0, 0);
+        emit rangedEvent(QmlDebug::PixmapCacheEvent, QmlDebug::MaximumRangeType, pixEvTy, time, 0,
+                         QStringList(), QmlDebug::QmlEventLocation(pixUrl,0,0), width, height,
+                         refcount, 0, 0);
         d->maximumTime = qMax(time, d->maximumTime);
     } else {
         int range;
         stream >> range;
 
-        if (range >= MaximumQmlEventType)
+        if (range >= MaximumRangeType)
             return;
 
         if (messageType == RangeStart) {
@@ -226,7 +228,7 @@ void QmlProfilerTraceClient::messageReceived(const QByteArray &data)
             ++d->rangeCount[range];
 
             // read binding type
-            if ((QmlEventType)range == Binding) {
+            if ((RangeType)range == Binding) {
                 int bindingType = (int)QmlBinding;
                 if (!stream.atEnd())
                     stream >> bindingType;
@@ -270,12 +272,12 @@ void QmlProfilerTraceClient::messageReceived(const QByteArray &data)
 
                 qint64 startTime = d->rangeStartTimes[range].pop();
                 BindingType bindingType = QmlBinding;
-                if ((QmlEventType)range == Binding)
+                if ((RangeType)range == Binding)
                     bindingType = d->bindingTypes.pop();
-                if ((QmlEventType)range == Painting)
+                if ((RangeType)range == Painting)
                     bindingType = QPainterEvent;
-                emit rangedEvent((QmlEventType)range, bindingType, startTime, time - startTime, data,
-                           location, 0, 0, 0, 0, 0);
+                emit rangedEvent(MaximumMessage, (RangeType)range, bindingType, startTime,
+                                 time - startTime, data, location, 0, 0, 0, 0, 0);
                 if (d->rangeCount[range] == 0) {
                     int count = d->rangeDatas[range].count() +
                                 d->rangeStartTimes[range].count() +
diff --git a/src/libs/qmldebug/qmlprofilertraceclient.h b/src/libs/qmldebug/qmlprofilertraceclient.h
index 6b9d4f9b5a..1912652e92 100644
--- a/src/libs/qmldebug/qmlprofilertraceclient.h
+++ b/src/libs/qmldebug/qmlprofilertraceclient.h
@@ -53,41 +53,6 @@ public:
     QmlProfilerTraceClient(QmlDebugConnection *client);
     ~QmlProfilerTraceClient();
 
-    enum EventType {
-        FramePaint,
-        Mouse,
-        Key,
-        AnimationFrame,
-        EndTrace,
-        StartTrace,
-
-        MaximumEventType
-    };
-
-    enum Message {
-        Event,
-        RangeStart,
-        RangeData,
-        RangeLocation,
-        RangeEnd,
-        Complete,
-        PixmapCacheEvent,
-        SceneGraphFrame,
-
-        MaximumMessage
-    };
-
-    enum PixmapEventType {
-        PixmapSizeKnown,
-        PixmapReferenceCountChanged,
-        PixmapCacheCountChanged,
-        PixmapLoadingStarted,
-        PixmapLoadingFinished,
-        PixmapLoadingError,
-
-        MaximumPixmapEventType
-    };
-
     bool isEnabled() const;
     bool isRecording() const;
     void setRecording(bool);
@@ -102,9 +67,10 @@ signals:
     void event(int event, qint64 time);
     void traceFinished( qint64 time );
     void traceStarted( qint64 time );
-    void rangedEvent(int type, int bindingType, qint64 startTime, qint64 length,
-               const QStringList &data, const QmlDebug::QmlEventLocation &location,
-               qint64 param1, qint64 param2, qint64 param3, qint64 param4, qint64 param5);
+    void rangedEvent(QmlDebug::Message, QmlDebug::RangeType, int detailType, qint64 startTime,
+                     qint64 length, const QStringList &data,
+                     const QmlDebug::QmlEventLocation &location, qint64 param1, qint64 param2,
+                     qint64 param3, qint64 param4, qint64 param5);
     void recordingChanged(bool arg);
 
     void enabledChanged();
diff --git a/src/plugins/qmlprofiler/qmlprofilerclientmanager.cpp b/src/plugins/qmlprofiler/qmlprofilerclientmanager.cpp
index ad57a88ed9..828707828d 100644
--- a/src/plugins/qmlprofiler/qmlprofilerclientmanager.cpp
+++ b/src/plugins/qmlprofiler/qmlprofilerclientmanager.cpp
@@ -175,11 +175,13 @@ void QmlProfilerClientManager::connectClientSignals()
         connect(d->qmlclientplugin.data(), SIGNAL(complete(qint64)),
                 this, SLOT(qmlComplete(qint64)));
         connect(d->qmlclientplugin.data(),
-                SIGNAL(rangedEvent(int,int,qint64,qint64,QStringList,QmlDebug::QmlEventLocation,
-                             qint64,qint64,qint64,qint64,qint64)),
+                SIGNAL(rangedEvent(QmlDebug::Message,QmlDebug::RangeType,int,qint64,qint64,
+                                   QStringList,QmlDebug::QmlEventLocation,qint64,qint64,qint64,
+                                   qint64,qint64)),
                 d->modelManager,
-                SLOT(addQmlEvent(int,int,qint64,qint64,QStringList,QmlDebug::QmlEventLocation,
-                             qint64,qint64,qint64,qint64,qint64)));
+                SLOT(addQmlEvent(QmlDebug::Message,QmlDebug::RangeType,int,qint64,qint64,
+                                 QStringList,QmlDebug::QmlEventLocation,qint64,qint64,qint64,qint64,
+                                 qint64)));
         connect(d->qmlclientplugin.data(), SIGNAL(traceFinished(qint64)),
                 d->modelManager->traceTime(), SLOT(setEndTime(qint64)));
         connect(d->qmlclientplugin.data(), SIGNAL(traceStarted(qint64)),
diff --git a/src/plugins/qmlprofiler/qmlprofilerdatamodel.cpp b/src/plugins/qmlprofiler/qmlprofilerdatamodel.cpp
index c4c364ccb7..39ba49baa2 100644
--- a/src/plugins/qmlprofiler/qmlprofilerdatamodel.cpp
+++ b/src/plugins/qmlprofiler/qmlprofilerdatamodel.cpp
@@ -55,7 +55,7 @@ QString getInitialDetails(const QmlProfilerDataModel::QmlEventData &event);
 QmlDebug::QmlEventLocation getLocation(const QmlProfilerDataModel::QmlEventData &event)
 {
     QmlDebug::QmlEventLocation eventLocation = event.location;
-    if ((event.eventType == QmlDebug::Creating || event.eventType == QmlDebug::Compiling)
+    if ((event.rangeType == QmlDebug::Creating || event.rangeType == QmlDebug::Compiling)
             && eventLocation.filename.isEmpty()) {
         eventLocation.filename = getInitialDetails(event);
         eventLocation.line = 1;
@@ -169,7 +169,7 @@ void QmlProfilerDataModel::complete()
         // request further details from files
         //
 
-        if (event->eventType != QmlDebug::Binding && event->eventType != QmlDebug::HandlingSignal)
+        if (event->rangeType != QmlDebug::Binding && event->rangeType != QmlDebug::HandlingSignal)
             continue;
 
         // This skips anonymous bindings in Qt4.8 (we don't have valid location data for them)
@@ -189,7 +189,8 @@ void QmlProfilerDataModel::complete()
     QmlProfilerBaseModel::complete();
 }
 
-void QmlProfilerDataModel::addQmlEvent(int type, int bindingType, qint64 startTime,
+void QmlProfilerDataModel::addQmlEvent(QmlDebug::Message message, QmlDebug::RangeType rangeType,
+                                            int detailType, qint64 startTime,
                                             qint64 duration, const QStringList &data,
                                             const QmlDebug::QmlEventLocation &location,
                                             qint64 ndata1, qint64 ndata2, qint64 ndata3,
@@ -197,7 +198,7 @@ void QmlProfilerDataModel::addQmlEvent(int type, int bindingType, qint64 startTi
 {
     Q_D(QmlProfilerDataModel);
     QString displayName;
-    if (type == QmlDebug::Painting && bindingType == QmlDebug::AnimationFrame) {
+    if (message == QmlDebug::Event && detailType == QmlDebug::AnimationFrame) {
         displayName = tr("Animations");
     } else {
         displayName = QString::fromLatin1("%1:%2").arg(
@@ -205,8 +206,8 @@ void QmlProfilerDataModel::addQmlEvent(int type, int bindingType, qint64 startTi
                 QString::number(location.line));
     }
 
-    QmlEventData eventData = {displayName, type, bindingType, startTime, duration, data, location,
-                              ndata1, ndata2, ndata3, ndata4, ndata5};
+    QmlEventData eventData = {displayName, message, rangeType, detailType, startTime, duration,
+                              data, location, ndata1, ndata2, ndata3, ndata4, ndata5};
     d->eventList.append(eventData);
 
     d->modelManager->modelProxyCountUpdated(d->modelId, startTime,
@@ -219,8 +220,8 @@ QString QmlProfilerDataModel::getHashString(const QmlProfilerDataModel::QmlEvent
                 event.location.filename,
                 QString::number(event.location.line),
                 QString::number(event.location.column),
-                QString::number(event.eventType),
-                QString::number(event.bindingType));
+                QString::number((event.message << 8) | event.rangeType),
+                QString::number(event.detailType));
 }
 
 qint64 QmlProfilerDataModel::lastTimeMark() const
diff --git a/src/plugins/qmlprofiler/qmlprofilerdatamodel.h b/src/plugins/qmlprofiler/qmlprofilerdatamodel.h
index 400faaee14..ec426afc13 100644
--- a/src/plugins/qmlprofiler/qmlprofilerdatamodel.h
+++ b/src/plugins/qmlprofiler/qmlprofilerdatamodel.h
@@ -30,6 +30,7 @@
 #ifndef QMLPROFILERDATAMODEL_H
 #define QMLPROFILERDATAMODEL_H
 
+#include <qmldebug/qmlprofilereventtypes.h>
 #include "qmlprofilerbasemodel.h"
 
 namespace QmlProfiler {
@@ -40,8 +41,9 @@ class QMLPROFILER_EXPORT QmlProfilerDataModel : public QmlProfilerBaseModel
 public:
     struct QmlEventData {
         QString displayName;
-        int eventType;
-        int bindingType;
+        QmlDebug::Message message;
+        QmlDebug::RangeType rangeType;
+        int detailType; // can be EventType, BindingType, PixmapEventType or SceneGraphFrameType
         qint64 startTime;
         qint64 duration;
         QStringList data;
@@ -60,9 +62,10 @@ public:
     virtual void clear();
     virtual bool isEmpty() const;
     virtual void complete();
-    void addQmlEvent(int type, int bindingType, qint64 startTime, qint64 duration,
-                     const QStringList &data, const QmlDebug::QmlEventLocation &location,
-                     qint64 ndata1, qint64 ndata2, qint64 ndata3, qint64 ndata4, qint64 ndata5);
+    void addQmlEvent(QmlDebug::Message message, QmlDebug::RangeType rangeType, int bindingType,
+                     qint64 startTime, qint64 duration, const QStringList &data,
+                     const QmlDebug::QmlEventLocation &location, qint64 ndata1, qint64 ndata2,
+                     qint64 ndata3, qint64 ndata4, qint64 ndata5);
     static QString getHashString(const QmlProfilerDataModel::QmlEventData &event);
     qint64 lastTimeMark() const;
 
diff --git a/src/plugins/qmlprofiler/qmlprofilereventsmodelproxy.cpp b/src/plugins/qmlprofiler/qmlprofilereventsmodelproxy.cpp
index 9ffac56271..485f2973f0 100644
--- a/src/plugins/qmlprofiler/qmlprofilereventsmodelproxy.cpp
+++ b/src/plugins/qmlprofiler/qmlprofilereventsmodelproxy.cpp
@@ -58,7 +58,7 @@ public:
 
     int modelId;
 
-    QList<QmlDebug::QmlEventType> acceptedTypes;
+    QList<QmlDebug::RangeType> acceptedTypes;
     QSet<QString> eventsInBindingLoop;
 };
 
@@ -80,7 +80,7 @@ QmlProfilerEventsModelProxy::~QmlProfilerEventsModelProxy()
     delete d;
 }
 
-void QmlProfilerEventsModelProxy::setEventTypeAccepted(QmlDebug::QmlEventType type, bool accepted)
+void QmlProfilerEventsModelProxy::setEventTypeAccepted(QmlDebug::RangeType type, bool accepted)
 {
     if (accepted && !d->acceptedTypes.contains(type))
         d->acceptedTypes << type;
@@ -88,7 +88,7 @@ void QmlProfilerEventsModelProxy::setEventTypeAccepted(QmlDebug::QmlEventType ty
         d->acceptedTypes.removeOne(type);
 }
 
-bool QmlProfilerEventsModelProxy::eventTypeAccepted(QmlDebug::QmlEventType type) const
+bool QmlProfilerEventsModelProxy::eventTypeAccepted(QmlDebug::RangeType type) const
 {
     return d->acceptedTypes.contains(type);
 }
@@ -144,7 +144,7 @@ void QmlProfilerEventsModelProxy::loadData(qint64 rangeStart, qint64 rangeEnd)
     for (int i = 0; i < eventList.size(); ++i) {
         const QmlProfilerDataModel::QmlEventData *event = &eventList[i];
 
-        if (!d->acceptedTypes.contains((QmlDebug::QmlEventType)event->eventType))
+        if (!d->acceptedTypes.contains(event->rangeType))
             continue;
 
         if (checkRanges) {
@@ -161,8 +161,9 @@ void QmlProfilerEventsModelProxy::loadData(qint64 rangeStart, qint64 rangeEnd)
                 hash,
                 event->data.join(QLatin1String(" ")),
                 event->location,
-                event->eventType,
-                event->bindingType,
+                event->message,
+                event->rangeType,
+                event->detailType,
                 event->duration,
                 1, //calls
                 event->duration, //minTime
@@ -257,7 +258,8 @@ void QmlProfilerEventsModelProxy::loadData(qint64 rangeStart, qint64 rangeEnd)
         rootEventName, // hash
         tr("Main Program"), //event.details,
         rootEventLocation, // location
-        (int)QmlDebug::Binding, // event type
+        QmlDebug::MaximumMessage,
+        QmlDebug::Binding, // event type
         0, // binding type
         qmlTime + 1,
         1, //calls
@@ -347,6 +349,7 @@ void QmlProfilerEventParentsModelProxy::loadData()
     QString rootEventName = tr("<program>");
     QmlProfilerDataModel::QmlEventData rootEvent = {
         rootEventName,
+        QmlDebug::MaximumMessage,
         QmlDebug::Binding,
         0,
         0,
@@ -370,7 +373,7 @@ void QmlProfilerEventParentsModelProxy::loadData()
     const QVector<QmlProfilerDataModel::QmlEventData> eventList = simpleModel->getEvents();
     foreach (const QmlProfilerDataModel::QmlEventData &event, eventList) {
         // whitelist
-        if (!m_eventsModel->eventTypeAccepted((QmlDebug::QmlEventType)event.eventType))
+        if (!m_eventsModel->eventTypeAccepted(event.rangeType))
             continue;
 
         // level computation
@@ -407,7 +410,7 @@ void QmlProfilerEventParentsModelProxy::loadData()
             m_data[eventHash].insert(parentHash, QmlEventRelativesData());
             QmlEventRelativesData *parent = &(m_data[eventHash][parentHash]);
             parent->displayName = parentEvent->displayName;
-            parent->eventType = parentEvent->eventType;
+            parent->rangeType = parentEvent->rangeType;
             parent->duration = event.duration;
             parent->calls = 1;
             parent->details = parentEvent->data.join(QLatin1String(""));
@@ -450,7 +453,7 @@ void QmlProfilerEventChildrenModelProxy::loadData()
     const QVector<QmlProfilerDataModel::QmlEventData> eventList = simpleModel->getEvents();
     foreach (const QmlProfilerDataModel::QmlEventData &event, eventList) {
         // whitelist
-        if (!m_eventsModel->eventTypeAccepted((QmlDebug::QmlEventType)event.eventType))
+        if (!m_eventsModel->eventTypeAccepted(event.rangeType))
             continue;
 
         // level computation
@@ -480,7 +483,7 @@ void QmlProfilerEventChildrenModelProxy::loadData()
             m_data[parentHash].insert(eventHash, QmlEventRelativesData());
             QmlEventRelativesData *child = &(m_data[parentHash][eventHash]);
             child->displayName = event.displayName;
-            child->eventType = event.eventType;
+            child->rangeType = event.rangeType;
             child->duration = event.duration;
             child->calls = 1;
             child->details = event.data.join(QLatin1String(""));
diff --git a/src/plugins/qmlprofiler/qmlprofilereventsmodelproxy.h b/src/plugins/qmlprofiler/qmlprofilereventsmodelproxy.h
index cc57a096f5..c716664092 100644
--- a/src/plugins/qmlprofiler/qmlprofilereventsmodelproxy.h
+++ b/src/plugins/qmlprofiler/qmlprofilereventsmodelproxy.h
@@ -53,7 +53,8 @@ public:
         QString eventHashStr;
         QString details;
         QmlDebug::QmlEventLocation location;
-        int eventType;
+        QmlDebug::Message message;
+        QmlDebug::RangeType rangeType;
         int bindingType;
 
         qint64 duration;
@@ -70,8 +71,8 @@ public:
     QmlProfilerEventsModelProxy(QmlProfilerModelManager *modelManager, QObject *parent = 0);
     ~QmlProfilerEventsModelProxy();
 
-    void setEventTypeAccepted(QmlDebug::QmlEventType type, bool accepted);
-    bool eventTypeAccepted(QmlDebug::QmlEventType) const;
+    void setEventTypeAccepted(QmlDebug::RangeType type, bool accepted);
+    bool eventTypeAccepted(QmlDebug::RangeType) const;
 
     const QList<QmlEventStats> getData() const;
     int count() const;
@@ -104,7 +105,7 @@ class QmlProfilerEventRelativesModelProxy : public QObject
 public:
     struct QmlEventRelativesData {
         QString displayName;
-        int eventType;
+        QmlDebug::RangeType rangeType;
         qint64 duration;
         qint64 calls;
         QString details;
diff --git a/src/plugins/qmlprofiler/qmlprofilereventview.cpp b/src/plugins/qmlprofiler/qmlprofilereventview.cpp
index ed8d6bb1c8..47616c12d5 100644
--- a/src/plugins/qmlprofiler/qmlprofilereventview.cpp
+++ b/src/plugins/qmlprofiler/qmlprofilereventview.cpp
@@ -561,9 +561,9 @@ void QmlProfilerEventsMainView::parseModelProxy()
             newRow << new EventsViewItem(event.displayName);
 
         if (d->m_fieldShown[Type]) {
-            QString typeString = QmlProfilerEventsMainView::nameForType(event.eventType);
+            QString typeString = QmlProfilerEventsMainView::nameForType(event.rangeType);
             QString toolTipText;
-            if (event.eventType == Binding) {
+            if (event.rangeType == Binding) {
                 if (event.bindingType == (int)OptimizedBinding) {
                     typeString = typeString + QLatin1Char(' ') +  tr("(Opt)");
                     toolTipText = tr("Binding is evaluated by the optimized engine.");
@@ -645,17 +645,17 @@ void QmlProfilerEventsMainView::parseModelProxy()
     }
 }
 
-QString QmlProfilerEventsMainView::nameForType(int typeNumber)
+QString QmlProfilerEventsMainView::nameForType(QmlDebug::RangeType typeNumber)
 {
     switch (typeNumber) {
-    case 0: return QmlProfilerEventsMainView::tr("Paint");
-    case 1: return QmlProfilerEventsMainView::tr("Compile");
-    case 2: return QmlProfilerEventsMainView::tr("Create");
-    case 3: return QmlProfilerEventsMainView::tr("Binding");
-    case 4: return QmlProfilerEventsMainView::tr("Signal");
-    case 5: return QmlProfilerEventsMainView::tr("JavaScript");
+    case QmlDebug::Painting: return QmlProfilerEventsMainView::tr("Paint");
+    case QmlDebug::Compiling: return QmlProfilerEventsMainView::tr("Compile");
+    case QmlDebug::Creating: return QmlProfilerEventsMainView::tr("Create");
+    case QmlDebug::Binding: return QmlProfilerEventsMainView::tr("Binding");
+    case QmlDebug::HandlingSignal: return QmlProfilerEventsMainView::tr("Signal");
+    case QmlDebug::Javascript: return QmlProfilerEventsMainView::tr("JavaScript");
+    default: return QString();
     }
-    return QString();
 }
 
 void QmlProfilerEventsMainView::getStatisticsInRange(qint64 rangeStart, qint64 rangeEnd)
@@ -867,7 +867,7 @@ void QmlProfilerEventRelativesView::rebuildTree(QmlProfilerEventRelativesModelPr
         // maybe we should store the data in this proxy and get it here
         // no indirections at this level of abstraction!
         newRow << new EventsViewItem(event.displayName);
-        newRow << new EventsViewItem(QmlProfilerEventsMainView::nameForType(event.eventType));
+        newRow << new EventsViewItem(QmlProfilerEventsMainView::nameForType(event.rangeType));
         newRow << new EventsViewItem(QmlProfilerBaseModel::formatTime(event.duration));
         newRow << new EventsViewItem(QString::number(event.calls));
         newRow << new EventsViewItem(event.details);
diff --git a/src/plugins/qmlprofiler/qmlprofilereventview.h b/src/plugins/qmlprofiler/qmlprofilereventview.h
index 492fdbf4f4..22ee7cdd95 100644
--- a/src/plugins/qmlprofiler/qmlprofilereventview.h
+++ b/src/plugins/qmlprofiler/qmlprofilereventview.h
@@ -119,7 +119,7 @@ public:
     void copyTableToClipboard() const;
     void copyRowToClipboard() const;
 
-    static QString nameForType(int typeNumber);
+    static QString nameForType(QmlDebug::RangeType typeNumber);
 
     void getStatisticsInRange(qint64 rangeStart, qint64 rangeEnd);
     QString selectedEventHash() const;
diff --git a/src/plugins/qmlprofiler/qmlprofilermodelmanager.cpp b/src/plugins/qmlprofiler/qmlprofilermodelmanager.cpp
index e22eb097a8..d62015b023 100644
--- a/src/plugins/qmlprofiler/qmlprofilermodelmanager.cpp
+++ b/src/plugins/qmlprofiler/qmlprofilermodelmanager.cpp
@@ -249,8 +249,9 @@ void QmlProfilerModelManager::newTimeEstimation(qint64 estimation)
     d->estimatedTime = estimation;
 }
 
-void QmlProfilerModelManager::addQmlEvent(int type,
-                                          int bindingType,
+void QmlProfilerModelManager::addQmlEvent(QmlDebug::Message message,
+                                          QmlDebug::RangeType rangeType,
+                                          int detailType,
                                           qint64 startTime,
                                           qint64 length,
                                           const QStringList &data,
@@ -266,7 +267,8 @@ void QmlProfilerModelManager::addQmlEvent(int type,
         d->traceTime->setStartTime(startTime);
 
     QTC_ASSERT(state() == QmlProfilerDataState::AcquiringData, /**/);
-    d->model->addQmlEvent(type, bindingType, startTime, length, data, location, ndata1, ndata2, ndata3, ndata4, ndata5);
+    d->model->addQmlEvent(message, rangeType, detailType, startTime, length, data, location,
+                          ndata1, ndata2, ndata3, ndata4, ndata5);
 }
 
 void QmlProfilerModelManager::addV8Event(int depth, const QString &function, const QString &filename,
@@ -353,10 +355,12 @@ void QmlProfilerModelManager::load()
 
     QmlProfilerFileReader reader;
     connect(&reader, SIGNAL(error(QString)), this, SIGNAL(error(QString)));
-    connect(&reader, SIGNAL(rangedEvent(int,int,qint64,qint64,QStringList,QmlDebug::QmlEventLocation,
+    connect(&reader, SIGNAL(rangedEvent(QmlDebug::Message,QmlDebug::RangeType,int,qint64,qint64,
+                                        QStringList,QmlDebug::QmlEventLocation,
                                         qint64, qint64, qint64, qint64, qint64)),
-            this, SLOT(addQmlEvent(int,int,qint64,qint64,QStringList,QmlDebug::QmlEventLocation,
-                             qint64, qint64, qint64, qint64, qint64)));
+            this, SLOT(addQmlEvent(QmlDebug::Message,QmlDebug::RangeType,int,qint64,qint64,
+                                   QStringList,QmlDebug::QmlEventLocation,
+                                   qint64, qint64, qint64, qint64, qint64)));
     connect(&reader, SIGNAL(traceStartTime(qint64)), traceTime(), SLOT(setStartTime(qint64)));
     connect(&reader, SIGNAL(traceEndTime(qint64)), traceTime(), SLOT(setEndTime(qint64)));
     reader.setV8DataModel(d->v8Model);
diff --git a/src/plugins/qmlprofiler/qmlprofilermodelmanager.h b/src/plugins/qmlprofiler/qmlprofilermodelmanager.h
index 1be9abd973..ebee32057f 100644
--- a/src/plugins/qmlprofiler/qmlprofilermodelmanager.h
+++ b/src/plugins/qmlprofiler/qmlprofilermodelmanager.h
@@ -33,6 +33,7 @@
 #include "qmlprofiler_global.h"
 
 #include <qmldebug/qmlprofilereventlocation.h>
+#include <qmldebug/qmlprofilereventtypes.h>
 #include <utils/fileinprojectfinder.h>
 
 #include <QObject>
@@ -138,8 +139,9 @@ public slots:
     void clear();
 
     void prepareForWriting();
-    void addQmlEvent(int type, int bindingType, qint64 startTime, qint64 length,
-                        const QStringList &data, const QmlDebug::QmlEventLocation &location,
+    void addQmlEvent(QmlDebug::Message message, QmlDebug::RangeType rangeType, int bindingType,
+                     qint64 startTime, qint64 length, const QStringList &data,
+                     const QmlDebug::QmlEventLocation &location,
                      qint64 ndata1, qint64 ndata2, qint64 ndata3, qint64 ndata4, qint64 ndata5);
     void addV8Event(int depth, const QString &function,const QString &filename, int lineNumber,
                     double totalTime, double selfTime);
diff --git a/src/plugins/qmlprofiler/qmlprofilerpainteventsmodelproxy.cpp b/src/plugins/qmlprofiler/qmlprofilerpainteventsmodelproxy.cpp
index c4aa50ea74..963abbaf97 100644
--- a/src/plugins/qmlprofiler/qmlprofilerpainteventsmodelproxy.cpp
+++ b/src/plugins/qmlprofiler/qmlprofilerpainteventsmodelproxy.cpp
@@ -63,7 +63,7 @@ private:
 PaintEventsModelProxy::PaintEventsModelProxy(QObject *parent)
     : SingleCategoryTimelineModel(new PaintEventsModelProxyPrivate,
                                   QLatin1String("PaintEventsModelProxy"), tr("Painting"),
-                                  QmlDebug::Painting, parent)
+                                  QmlDebug::Event, QmlDebug::MaximumRangeType, parent)
 {
     Q_D(PaintEventsModelProxy);
     d->seenForeignPaintEvent = false;
@@ -84,7 +84,7 @@ void PaintEventsModelProxy::clear()
 bool PaintEventsModelProxy::eventAccepted(const QmlProfilerDataModel::QmlEventData &event) const
 {
     return SingleCategoryTimelineModel::eventAccepted(event) &&
-            event.bindingType == QmlDebug::AnimationFrame;
+            event.detailType== QmlDebug::AnimationFrame;
 }
 
 void PaintEventsModelProxy::loadData()
@@ -103,7 +103,7 @@ void PaintEventsModelProxy::loadData()
 
     foreach (const QmlProfilerDataModel::QmlEventData &event, referenceList) {
         if (!eventAccepted(event)) {
-            if (event.eventType == QmlDebug::Painting)
+            if (event.rangeType == QmlDebug::Painting)
                 d->seenForeignPaintEvent = true;
             continue;
         }
diff --git a/src/plugins/qmlprofiler/qmlprofilertimelinemodelproxy.cpp b/src/plugins/qmlprofiler/qmlprofilertimelinemodelproxy.cpp
index c945b7155c..5fe7288ec6 100644
--- a/src/plugins/qmlprofiler/qmlprofilertimelinemodelproxy.cpp
+++ b/src/plugins/qmlprofiler/qmlprofilertimelinemodelproxy.cpp
@@ -92,7 +92,7 @@ void BasicTimelineModel::clear()
 void BasicTimelineModel::BasicTimelineModelPrivate::prepare()
 {
     categorySpan.clear();
-    for (int i = 0; i < QmlDebug::MaximumQmlEventType; i++) {
+    for (int i = 0; i < QmlDebug::MaximumRangeType; i++) {
         CategorySpan newCategory = {false, 1, 1, i};
         categorySpan << newCategory;
     }
@@ -100,11 +100,8 @@ void BasicTimelineModel::BasicTimelineModelPrivate::prepare()
 
 bool BasicTimelineModel::eventAccepted(const QmlProfilerDataModel::QmlEventData &event) const
 {
-    // only accept Qt4.x Painting events
-    if (event.eventType == QmlDebug::Painting)
-        return (event.bindingType == QmlDebug::QPainterEvent);
-
-    return (event.eventType <= QmlDebug::Javascript);
+    // Accept all range types. Qt5 paint events aren't ranges
+    return (event.rangeType != QmlDebug::MaximumRangeType);
 }
 
 void BasicTimelineModel::loadData()
@@ -126,7 +123,7 @@ void BasicTimelineModel::loadData()
     foreach (const QmlProfilerDataModel::QmlEventData &event, eventList) {
         if (!eventAccepted(event))
             continue;
-        if (event.eventType == QmlDebug::Painting)
+        if (event.rangeType == QmlDebug::Painting)
             d->seenPaintEvent = true;
 
         QString eventHash = QmlProfilerDataModel::getHashString(event);
@@ -139,7 +136,7 @@ void BasicTimelineModel::loadData()
                 event.displayName,
                 event.data.join(QLatin1String(" ")),
                 event.location,
-                (QmlDebug::QmlEventType)event.eventType,
+                event.rangeType,
                 lastEventId++ // event id
             };
             d->eventDict << rangeEventData;
@@ -190,7 +187,7 @@ void BasicTimelineModel::BasicTimelineModelPrivate::computeNestingContracted()
     QList<int> nestingLevels;
     QList< QHash<int, qint64> > endtimesPerNestingLevel;
 
-    for (i = 0; i < QmlDebug::MaximumQmlEventType; i++) {
+    for (i = 0; i < QmlDebug::MaximumRangeType; i++) {
         nestingLevels << QmlDebug::Constants::QML_MIN_LEVEL;
         QHash<int, qint64> dummyHash;
         dummyHash[QmlDebug::Constants::QML_MIN_LEVEL] = 0;
@@ -247,8 +244,8 @@ void BasicTimelineModel::BasicTimelineModelPrivate::findBindingLoops()
 
         BasicTimelineModel::QmlRangeEventData data = eventDict.at(event->eventId);
 
-        static QVector<QmlDebug::QmlEventType> acceptedTypes =
-                QVector<QmlDebug::QmlEventType>() << QmlDebug::Binding << QmlDebug::HandlingSignal;
+        static QVector<QmlDebug::RangeType> acceptedTypes =
+                QVector<QmlDebug::RangeType>() << QmlDebug::Binding << QmlDebug::HandlingSignal;
 
         if (!acceptedTypes.contains(data.eventType))
             continue;
diff --git a/src/plugins/qmlprofiler/qmlprofilertimelinemodelproxy.h b/src/plugins/qmlprofiler/qmlprofilertimelinemodelproxy.h
index b79172502f..a01797f871 100644
--- a/src/plugins/qmlprofiler/qmlprofilertimelinemodelproxy.h
+++ b/src/plugins/qmlprofiler/qmlprofilertimelinemodelproxy.h
@@ -53,7 +53,7 @@ public:
         QString displayName;
         QString details;
         QmlDebug::QmlEventLocation location;
-        QmlDebug::QmlEventType eventType;
+        QmlDebug::RangeType eventType;
 
         int eventId;  // separate
     };
diff --git a/src/plugins/qmlprofiler/qmlprofilertracefile.cpp b/src/plugins/qmlprofiler/qmlprofilertracefile.cpp
index f058708ffb..b36ac78880 100644
--- a/src/plugins/qmlprofiler/qmlprofilertracefile.cpp
+++ b/src/plugins/qmlprofiler/qmlprofilertracefile.cpp
@@ -43,17 +43,33 @@ using namespace QmlDebug;
 
 const char PROFILER_FILE_VERSION[] = "1.02";
 
-const char TYPE_PAINTING_STR[] = "Painting";
-const char TYPE_COMPILING_STR[] = "Compiling";
-const char TYPE_CREATING_STR[] = "Creating";
-const char TYPE_BINDING_STR[] = "Binding";
-const char TYPE_HANDLINGSIGNAL_STR[] = "HandlingSignal";
-const char TYPE_PIXMAPCACHE_STR[] = "PixmapCache";
-const char TYPE_SCENEGRAPH_STR[] = "SceneGraph";
+static const char *RANGE_TYPE_STRINGS[] = {
+    "Painting",
+    "Compiling",
+    "Creating",
+    "Binding",
+    "HandlingSignal",
+    "Javascript"
+};
+
+Q_STATIC_ASSERT(sizeof(RANGE_TYPE_STRINGS) == QmlDebug::MaximumRangeType * sizeof(const char *));
+
+static const char *MESSAGE_STRINGS[] = {
+    // So far only pixmap and scenegraph are used. The others are padding.
+    "Event",
+    "RangeStart",
+    "RangeData",
+    "RangeLocation",
+    "RangeEnd",
+    "Complete",
+    "PixmapCache",
+    "SceneGraph"
+};
+
+Q_STATIC_ASSERT(sizeof(MESSAGE_STRINGS) == QmlDebug::MaximumMessage * sizeof(const char *));
 
 #define _(X) QLatin1String(X)
 
-
 //
 // "be strict in your output but tolerant in your inputs"
 //
@@ -61,59 +77,44 @@ const char TYPE_SCENEGRAPH_STR[] = "SceneGraph";
 namespace QmlProfiler {
 namespace Internal {
 
-static QmlEventType qmlEventTypeAsEnum(const QString &typeString)
+static QPair<QmlDebug::Message, QmlDebug::RangeType> qmlTypeAsEnum(const QString &typeString)
 {
-    if (typeString == _(TYPE_PAINTING_STR)) {
-        return Painting;
-    } else if (typeString == _(TYPE_COMPILING_STR)) {
-        return Compiling;
-    } else if (typeString == _(TYPE_CREATING_STR)) {
-        return Creating;
-    } else if (typeString == _(TYPE_BINDING_STR)) {
-        return Binding;
-    } else if (typeString == _(TYPE_HANDLINGSIGNAL_STR)) {
-        return HandlingSignal;
-    } else if (typeString == _(TYPE_PIXMAPCACHE_STR)) {
-        return PixmapCacheEvent;
-    } else if (typeString == _(TYPE_SCENEGRAPH_STR)) {
-        return SceneGraphFrameEvent;
-    } else {
+    QPair<QmlDebug::Message, QmlDebug::RangeType> ret(QmlDebug::MaximumMessage,
+                                                      QmlDebug::MaximumRangeType);
+
+    for (int i = 0; i < QmlDebug::MaximumMessage; ++i) {
+        if (typeString == _(MESSAGE_STRINGS[i])) {
+            ret.first = static_cast<QmlDebug::Message>(i);
+            break;
+        }
+    }
+
+    for (int i = 0; i < QmlDebug::MaximumRangeType; ++i) {
+        if (typeString == _(RANGE_TYPE_STRINGS[i])) {
+            ret.second = static_cast<QmlDebug::RangeType>(i);
+            break;
+        }
+    }
+
+    if (ret.first == QmlDebug::MaximumMessage && ret.second == QmlDebug::MaximumRangeType) {
         bool isNumber = false;
         int type = typeString.toUInt(&isNumber);
-        if (isNumber)
-            return (QmlEventType)type;
-        else
-            return MaximumQmlEventType;
+        if (isNumber && type < QmlDebug::MaximumRangeType)
+            // Allow saving ranges as numbers, but not messages.
+            ret.second = static_cast<QmlDebug::RangeType>(type);
     }
+
+    return ret;
 }
 
-static QString qmlEventTypeAsString(QmlEventType typeEnum)
+static QString qmlTypeAsString(QmlDebug::Message message, QmlDebug::RangeType rangeType)
 {
-    switch (typeEnum) {
-    case Painting:
-        return _(TYPE_PAINTING_STR);
-        break;
-    case Compiling:
-        return _(TYPE_COMPILING_STR);
-        break;
-    case Creating:
-        return _(TYPE_CREATING_STR);
-        break;
-    case Binding:
-        return _(TYPE_BINDING_STR);
-        break;
-    case HandlingSignal:
-        return _(TYPE_HANDLINGSIGNAL_STR);
-        break;
-    case PixmapCacheEvent:
-        return _(TYPE_PIXMAPCACHE_STR);
-        break;
-    case SceneGraphFrameEvent:
-        return _(TYPE_SCENEGRAPH_STR);
-        break;
-    default:
-        return QString::number((int)typeEnum);
-    }
+    if (rangeType < QmlDebug::MaximumRangeType)
+        return _(RANGE_TYPE_STRINGS[rangeType]);
+    else if (message != QmlDebug::MaximumMessage)
+        return _(MESSAGE_STRINGS[message]);
+    else
+        return QString::number((int)rangeType);
 }
 
 
@@ -195,6 +196,7 @@ void QmlProfilerFileReader::loadEventData(QXmlStreamReader &stream)
             QString(), // displayname
             QString(), // filename
             QString(), // details
+            MaximumMessage,
             Painting, // type
             QmlBinding,  // bindingType, set for backwards compatibility
             0, // line
@@ -233,7 +235,9 @@ void QmlProfilerFileReader::loadEventData(QXmlStreamReader &stream)
             }
 
             if (elementName == _("type")) {
-                event.type = qmlEventTypeAsEnum(readData);
+                QPair<QmlDebug::Message, QmlDebug::RangeType> enums = qmlTypeAsEnum(readData);
+                event.message = enums.first;
+                event.rangeType = enums.second;
                 break;
             }
 
@@ -257,11 +261,23 @@ void QmlProfilerFileReader::loadEventData(QXmlStreamReader &stream)
                 break;
             }
 
+            if (elementName == _("animationFrame")) {
+                event.detailType = readData.toInt();
+                // new animation frames used to be saved as ranges of range type Painting with
+                // binding type 4 (which was called "AnimationFrame" to make everything even more
+                // confusing), even though they clearly aren't ranges. Convert that to something
+                // sane here.
+                if (event.detailType == 4) {
+                    event.message = Event;
+                    event.rangeType = MaximumRangeType;
+                    event.detailType = AnimationFrame;
+                }
+            }
+
             if (elementName == _("bindingType") ||
-                    elementName == _("animationFrame") ||
                     elementName == _("cacheEventType") ||
                     elementName == _("sgEventType")) {
-                event.bindingType = readData.toInt();
+                event.detailType = readData.toInt();
                 break;
             }
 
@@ -370,10 +386,11 @@ void QmlProfilerFileReader::processQmlEvents()
 
         QmlEvent &event = m_qmlEvents[eventIndex];
 
-        emit rangedEvent(event.type, event.bindingType, range.startTime, range.duration,
-                         QStringList(event.details),
+        emit rangedEvent(event.message, event.rangeType, event.detailType, range.startTime,
+                         range.duration, QStringList(event.details),
                          QmlEventLocation(event.filename, event.line, event.column),
-                         range.numericData1,range.numericData2, range.numericData3, range.numericData4, range.numericData5);
+                         range.numericData1,range.numericData2, range.numericData3,
+                         range.numericData4, range.numericData5);
 
     }
 }
@@ -385,7 +402,9 @@ QmlProfilerFileWriter::QmlProfilerFileWriter(QObject *parent) :
     m_measuredTime(0),
     m_v8Model(0)
 {
-    m_acceptedTypes << QmlDebug::Compiling << QmlDebug::Creating << QmlDebug::Binding << QmlDebug::HandlingSignal;
+    m_acceptedRangeTypes << QmlDebug::Compiling << QmlDebug::Creating << QmlDebug::Binding
+                         << QmlDebug::HandlingSignal << QmlDebug::Javascript;
+    m_acceptedMessages << QmlDebug::SceneGraphFrame << QmlDebug::PixmapCacheEvent;
 }
 
 void QmlProfilerFileWriter::setTraceTime(qint64 startTime, qint64 endTime, qint64 measuredTime)
@@ -405,14 +424,16 @@ void QmlProfilerFileWriter::setQmlEvents(const QVector<QmlProfilerDataModel::Qml
     foreach (const QmlProfilerDataModel::QmlEventData &event, events) {
         const QString hashStr = QmlProfilerDataModel::getHashString(event);
         if (!m_qmlEvents.contains(hashStr)) {
-            QmlEvent e = { event.displayName,
-                           event.location.filename,
-                           event.data.join(_("")),
-                           static_cast<QmlDebug::QmlEventType>(event.eventType),
-                           event.bindingType,
-                           event.location.line,
-                           event.location.column
-                         };
+            QmlEvent e = {
+                event.displayName,
+                event.location.filename,
+                event.data.join(_("")),
+                event.message,
+                event.rangeType,
+                event.detailType,
+                event.location.line,
+                event.location.column
+            };
             m_qmlEvents.insert(hashStr, e);
         }
 
@@ -451,21 +472,21 @@ void QmlProfilerFileWriter::save(QIODevice *device)
         stream.writeStartElement(_("event"));
         stream.writeAttribute(_("index"), keys[eventIter.key()]);
         stream.writeTextElement(_("displayname"), event.displayName);
-        stream.writeTextElement(_("type"), qmlEventTypeAsString(event.type));
+        stream.writeTextElement(_("type"), qmlTypeAsString(event.message, event.rangeType));
         if (!event.filename.isEmpty()) {
             stream.writeTextElement(_("filename"), event.filename);
             stream.writeTextElement(_("line"), QString::number(event.line));
             stream.writeTextElement(_("column"), QString::number(event.column));
         }
         stream.writeTextElement(_("details"), event.details);
-        if (event.type == Binding)
-            stream.writeTextElement(_("bindingType"), QString::number(event.bindingType));
-        if (event.type == Painting && event.bindingType == AnimationFrame)
-            stream.writeTextElement(_("animationFrame"), QString::number(event.bindingType));
-        if (event.type == PixmapCacheEvent)
-            stream.writeTextElement(_("cacheEventType"), QString::number(event.bindingType));
-        if (event.type == SceneGraphFrameEvent)
-            stream.writeTextElement(_("sgEventType"), QString::number(event.bindingType));
+        if (event.rangeType == Binding)
+            stream.writeTextElement(_("bindingType"), QString::number(event.detailType));
+        if (event.message == Event && event.detailType == AnimationFrame)
+            stream.writeTextElement(_("animationFrame"), QString::number(event.detailType));
+        if (event.message == PixmapCacheEvent)
+            stream.writeTextElement(_("cacheEventType"), QString::number(event.detailType));
+        if (event.message == SceneGraphFrame)
+            stream.writeTextElement(_("sgEventType"), QString::number(event.detailType));
         stream.writeEndElement();
     }
     stream.writeEndElement(); // eventData
@@ -486,27 +507,25 @@ void QmlProfilerFileWriter::save(QIODevice *device)
         QmlEvent event = m_qmlEvents.value(eventHash);
 
         // special: animation event
-        if (event.type == QmlDebug::Painting && event.bindingType == QmlDebug::AnimationFrame) {
-
+        if (event.message == QmlDebug::Event && event.detailType == QmlDebug::AnimationFrame) {
             stream.writeAttribute(_("framerate"), QString::number(range.numericData1));
             stream.writeAttribute(_("animationcount"), QString::number(range.numericData2));
             stream.writeAttribute(_("thread"), QString::number(range.numericData3));
         }
 
         // special: pixmap cache event
-        if (event.type == QmlDebug::PixmapCacheEvent) {
-            // pixmap image size
-            if (event.bindingType == 0) {
+        if (event.message == QmlDebug::PixmapCacheEvent) {
+            if (event.detailType == PixmapSizeKnown) {
                 stream.writeAttribute(_("width"), QString::number(range.numericData1));
                 stream.writeAttribute(_("height"), QString::number(range.numericData2));
             }
 
-            // reference count (1) / cache size changed (2)
-            if (event.bindingType == 1 || event.bindingType == 2)
+            if (event.detailType == PixmapReferenceCountChanged ||
+                    event.detailType == PixmapCacheCountChanged)
                 stream.writeAttribute(_("refCount"), QString::number(range.numericData3));
         }
 
-        if (event.type == QmlDebug::SceneGraphFrameEvent) {
+        if (event.message == QmlDebug::SceneGraphFrame) {
             // special: scenegraph frame events
             if (range.numericData1 > 0)
                 stream.writeAttribute(_("timing1"), QString::number(range.numericData1));
@@ -542,7 +561,8 @@ void QmlProfilerFileWriter::calculateMeasuredTime(const QVector<QmlProfilerDataM
 
     foreach (const QmlProfilerDataModel::QmlEventData &event, events) {
         // whitelist
-        if (!m_acceptedTypes.contains(event.eventType))
+        if (!m_acceptedRangeTypes.contains(event.rangeType) &&
+                !m_acceptedMessages.contains(event.message))
             continue;
 
         // level computation
diff --git a/src/plugins/qmlprofiler/qmlprofilertracefile.h b/src/plugins/qmlprofiler/qmlprofilertracefile.h
index 0ecf73bfc3..b0f81ed5d2 100644
--- a/src/plugins/qmlprofiler/qmlprofilertracefile.h
+++ b/src/plugins/qmlprofiler/qmlprofilertracefile.h
@@ -52,8 +52,9 @@ struct QmlEvent {
     QString displayName;
     QString filename;
     QString details;
-    QmlDebug::QmlEventType type;
-    int bindingType;
+    QmlDebug::Message message;
+    QmlDebug::RangeType rangeType;
+    int detailType;
     int line;
     int column;
 };
@@ -85,8 +86,9 @@ signals:
     void traceStartTime(qint64 traceStartTime);
     void traceEndTime(qint64 traceStartTime);
 
-    void rangedEvent(int type, int bindingType, qint64 startTime, qint64 length,
-                     const QStringList &data, const QmlDebug::QmlEventLocation &location,
+    void rangedEvent(QmlDebug::Message message, QmlDebug::RangeType rangeType, int detailType,
+                     qint64 startTime, qint64 length, const QStringList &data,
+                     const QmlDebug::QmlEventLocation &location,
                      qint64 param1, qint64 param2, qint64 param3, qint64 param4, qint64 param5);
     void error(const QString &error);
 
@@ -124,7 +126,8 @@ private:
     QV8ProfilerDataModel *m_v8Model;
     QHash<QString,QmlEvent> m_qmlEvents;
     QVector<QPair<Range, QString> > m_ranges;
-    QVector <int> m_acceptedTypes;
+    QVector<QmlDebug::RangeType> m_acceptedRangeTypes;
+    QVector<QmlDebug::Message> m_acceptedMessages;
 };
 
 
diff --git a/src/plugins/qmlprofiler/singlecategorytimelinemodel.cpp b/src/plugins/qmlprofiler/singlecategorytimelinemodel.cpp
index 61b1da3cc0..58139d8f15 100644
--- a/src/plugins/qmlprofiler/singlecategorytimelinemodel.cpp
+++ b/src/plugins/qmlprofiler/singlecategorytimelinemodel.cpp
@@ -33,14 +33,15 @@
 namespace QmlProfiler {
 
 SingleCategoryTimelineModel::SingleCategoryTimelineModel(SingleCategoryTimelineModelPrivate *dd,
-        const QString &name, const QString &label, QmlDebug::QmlEventType eventType,
-        QObject *parent) :
+        const QString &name, const QString &label, QmlDebug::Message message,
+        QmlDebug::RangeType rangeType, QObject *parent) :
     AbstractTimelineModel(dd, name, parent)
 {
     Q_D(SingleCategoryTimelineModel);
     d->expanded = false;
     d->label = label;
-    d->eventType = eventType;
+    d->message = message;
+    d->rangeType = rangeType;
 }
 
 /////////////////// QML interface
@@ -48,7 +49,7 @@ SingleCategoryTimelineModel::SingleCategoryTimelineModel(SingleCategoryTimelineM
 bool SingleCategoryTimelineModel::eventAccepted(const QmlProfilerDataModel::QmlEventData &event) const
 {
     Q_D(const SingleCategoryTimelineModel);
-    return (event.eventType == d->eventType);
+    return (event.rangeType == d->rangeType && event.message == d->message);
 }
 
 bool SingleCategoryTimelineModel::expanded(int categoryIndex) const
@@ -84,7 +85,7 @@ int SingleCategoryTimelineModel::getEventType(int index) const
 {
     Q_D(const SingleCategoryTimelineModel);
     Q_UNUSED(index);
-    return (int)d->eventType;
+    return (d->message << 8) + d->rangeType;
 }
 
 int SingleCategoryTimelineModel::getEventCategory(int index) const
diff --git a/src/plugins/qmlprofiler/singlecategorytimelinemodel.h b/src/plugins/qmlprofiler/singlecategorytimelinemodel.h
index 005f7c2a6d..1e3d3290fc 100644
--- a/src/plugins/qmlprofiler/singlecategorytimelinemodel.h
+++ b/src/plugins/qmlprofiler/singlecategorytimelinemodel.h
@@ -52,8 +52,8 @@ public:
 protected:
     class SingleCategoryTimelineModelPrivate;
     SingleCategoryTimelineModel(SingleCategoryTimelineModelPrivate *dd, const QString &name,
-                                const QString &label, QmlDebug::QmlEventType eventType,
-                                QObject *parent);
+                                const QString &label, QmlDebug::Message message,
+                                QmlDebug::RangeType rangeType, QObject *parent);
     Q_DECLARE_PRIVATE(SingleCategoryTimelineModel)
 };
 
diff --git a/src/plugins/qmlprofiler/singlecategorytimelinemodel_p.h b/src/plugins/qmlprofiler/singlecategorytimelinemodel_p.h
index b0045c2352..857cd31214 100644
--- a/src/plugins/qmlprofiler/singlecategorytimelinemodel_p.h
+++ b/src/plugins/qmlprofiler/singlecategorytimelinemodel_p.h
@@ -40,7 +40,8 @@ class SingleCategoryTimelineModel::SingleCategoryTimelineModelPrivate :
 public:
     bool expanded;
     QString label;
-    QmlDebug::QmlEventType eventType;
+    QmlDebug::Message message;
+    QmlDebug::RangeType rangeType;
 };
 }