Adapt to changes in QmlEventData

Change-Id: I2d01bb8b6684c9a9e3b2c4146f2101c31c7b0fa1
Reviewed-by: Joerg Bornemann <joerg.bornemann@theqtcompany.com>

4 files changed, 65 insertions, 65 deletions

diff --git a/plugins/qmlprofiler/inputeventsmodel.cpp b/plugins/qmlprofiler/inputeventsmodel.cpp
index 278d1f272b..be610ee8b6 100644
--- a/plugins/qmlprofiler/inputeventsmodel.cpp
+++ b/plugins/qmlprofiler/inputeventsmodel.cpp
@@ -142,19 +142,19 @@ void InputEventsModel::loadData()
 
     const QVector<QmlProfilerDataModel::QmlEventTypeData> &types = simpleModel->getEventTypes();
     foreach (const QmlProfilerDataModel::QmlEventData &event, simpleModel->getEvents()) {
-        const QmlProfilerDataModel::QmlEventTypeData &type = types[event.typeIndex];
+        const QmlProfilerDataModel::QmlEventTypeData &type = types[event.typeIndex()];
         if (!accepted(type))
             continue;
 
-        m_data.insert(insert(event.startTime, 0, type.detailType),
-                      InputEvent(static_cast<QmlDebug::InputEventType>(event.numericData1),
-                                 event.numericData2, event.numericData3));
+        m_data.insert(insert(event.startTime(), 0, type.detailType),
+                      InputEvent(static_cast<QmlDebug::InputEventType>(event.numericData(0)),
+                                 event.numericData(1), event.numericData(2)));
 
         if (type.detailType == QmlDebug::Mouse) {
             if (m_mouseTypeId == -1)
-                m_mouseTypeId = event.typeIndex;
+                m_mouseTypeId = event.typeIndex();
         } else if (m_keyTypeId == -1) {
-            m_keyTypeId = event.typeIndex;
+            m_keyTypeId = event.typeIndex();
         }
         updateProgress(count(), simpleModel->getEvents().count());
     }
diff --git a/plugins/qmlprofiler/memoryusagemodel.cpp b/plugins/qmlprofiler/memoryusagemodel.cpp
index 402b1e08c0..cbcac9c8f2 100644
--- a/plugins/qmlprofiler/memoryusagemodel.cpp
+++ b/plugins/qmlprofiler/memoryusagemodel.cpp
@@ -157,13 +157,13 @@ void MemoryUsageModel::loadData()
 
     const QVector<QmlProfilerDataModel::QmlEventTypeData> &types = simpleModel->getEventTypes();
     foreach (const QmlProfilerDataModel::QmlEventData &event, simpleModel->getEvents()) {
-        const QmlProfilerDataModel::QmlEventTypeData &type = types[event.typeIndex];
-        while (!rangeStack.empty() && rangeStack.top().endTime < event.startTime)
+        const QmlProfilerDataModel::QmlEventTypeData &type = types[event.typeIndex()];
+        while (!rangeStack.empty() && rangeStack.top().endTime < event.startTime())
             rangeStack.pop();
         if (!accepted(type)) {
             if (type.rangeType != QmlDebug::MaximumRangeType) {
-                rangeStack.push(RangeStackFrame(event.typeIndex, event.startTime,
-                                                event.startTime + event.duration));
+                rangeStack.push(RangeStackFrame(event.typeIndex(), event.startTime(),
+                                                event.startTime() + event.duration()));
             }
             continue;
         }
@@ -173,19 +173,19 @@ void MemoryUsageModel::loadData()
                     type.detailType == selectionId(currentUsageIndex) &&
                     m_data[currentUsageIndex].originTypeIndex == rangeStack.top().originTypeIndex &&
                     rangeStack.top().startTime < startTime(currentUsageIndex)) {
-                m_data[currentUsageIndex].update(event.numericData1);
+                m_data[currentUsageIndex].update(event.numericData(0));
                 currentUsage = m_data[currentUsageIndex].size;
             } else {
-                MemoryAllocation allocation(event.typeIndex, currentUsage,
+                MemoryAllocation allocation(event.typeIndex(), currentUsage,
                         rangeStack.empty() ? -1 : rangeStack.top().originTypeIndex);
-                allocation.update(event.numericData1);
+                allocation.update(event.numericData(0));
                 currentUsage = allocation.size;
 
                 if (currentUsageIndex != -1) {
                     insertEnd(currentUsageIndex,
-                              event.startTime - startTime(currentUsageIndex) - 1);
+                              event.startTime() - startTime(currentUsageIndex) - 1);
                 }
-                currentUsageIndex = insertStart(event.startTime, QmlDebug::SmallItem);
+                currentUsageIndex = insertStart(event.startTime(), QmlDebug::SmallItem);
                 m_data.insert(currentUsageIndex, allocation);
             }
         }
@@ -196,20 +196,20 @@ void MemoryUsageModel::loadData()
                     m_data[currentJSHeapIndex].originTypeIndex ==
                     rangeStack.top().originTypeIndex &&
                     rangeStack.top().startTime < startTime(currentJSHeapIndex)) {
-                m_data[currentJSHeapIndex].update(event.numericData1);
+                m_data[currentJSHeapIndex].update(event.numericData(0));
                 currentSize = m_data[currentJSHeapIndex].size;
             } else {
-                MemoryAllocation allocation(event.typeIndex, currentSize,
+                MemoryAllocation allocation(event.typeIndex(), currentSize,
                         rangeStack.empty() ? -1 : rangeStack.top().originTypeIndex);
-                allocation.update(event.numericData1);
+                allocation.update(event.numericData(0));
                 currentSize = allocation.size;
 
                 if (currentSize > m_maxSize)
                     m_maxSize = currentSize;
                 if (currentJSHeapIndex != -1)
                     insertEnd(currentJSHeapIndex,
-                              event.startTime - startTime(currentJSHeapIndex) - 1);
-                currentJSHeapIndex = insertStart(event.startTime, type.detailType);
+                              event.startTime() - startTime(currentJSHeapIndex) - 1);
+                currentJSHeapIndex = insertStart(event.startTime(), type.detailType);
                 m_data.insert(currentJSHeapIndex, allocation);
             }
         }
diff --git a/plugins/qmlprofiler/pixmapcachemodel.cpp b/plugins/qmlprofiler/pixmapcachemodel.cpp
index f9d69af179..3a220f0e9c 100644
--- a/plugins/qmlprofiler/pixmapcachemodel.cpp
+++ b/plugins/qmlprofiler/pixmapcachemodel.cpp
@@ -171,13 +171,13 @@ void PixmapCacheModel::loadData()
 
     const QVector<QmlProfilerDataModel::QmlEventTypeData> &types = simpleModel->getEventTypes();
     foreach (const QmlProfilerDataModel::QmlEventData &event, simpleModel->getEvents()) {
-        const QmlProfilerDataModel::QmlEventTypeData &type = types[event.typeIndex];
+        const QmlProfilerDataModel::QmlEventTypeData &type = types[event.typeIndex()];
         if (!accepted(type))
             continue;
 
         PixmapCacheEvent newEvent;
         newEvent.pixmapEventType = static_cast<PixmapEventType>(type.detailType);
-        qint64 pixmapStartTime = event.startTime;
+        qint64 pixmapStartTime = event.startTime();
 
         newEvent.urlIndex = -1;
         for (QVector<Pixmap>::const_iterator it(m_pixmaps.cend()); it != m_pixmaps.cbegin();) {
@@ -206,31 +206,31 @@ void PixmapCacheModel::loadData()
                 // We can't have cached it before we knew the size
                 Q_ASSERT(i->cacheState != Cached);
 
-                i->size.setWidth(event.numericData1);
-                i->size.setHeight(event.numericData2);
+                i->size.setWidth(event.numericData(0));
+                i->size.setHeight(event.numericData(1));
                 newEvent.sizeIndex = i - pixmap.sizes.begin();
                 break;
             }
 
             if (newEvent.sizeIndex == -1) {
                 newEvent.sizeIndex = pixmap.sizes.length();
-                pixmap.sizes << PixmapState(event.numericData1, event.numericData2);
+                pixmap.sizes << PixmapState(event.numericData(0), event.numericData(1));
             }
 
             PixmapState &state = pixmap.sizes[newEvent.sizeIndex];
             if (state.cacheState == ToBeCached) {
                 lastCacheSizeEvent = updateCacheCount(lastCacheSizeEvent, pixmapStartTime,
                                               state.size.width() * state.size.height(), newEvent,
-                                              event.typeIndex);
+                                              event.typeIndex());
                 state.cacheState = Cached;
             }
             break;
         }
         case PixmapCacheCountChanged: {// Cache Size Changed Event
-            pixmapStartTime = event.startTime + 1; // delay 1 ns for proper sorting
+            pixmapStartTime = event.startTime() + 1; // delay 1 ns for proper sorting
 
-            bool uncache = cumulatedCount > event.numericData3;
-            cumulatedCount = event.numericData3;
+            bool uncache = cumulatedCount > event.numericData(2);
+            cumulatedCount = event.numericData(2);
             qint64 pixSize = 0;
 
             // First try to find a preferred pixmap, which either is Corrupt and will be uncached
@@ -281,7 +281,7 @@ void PixmapCacheModel::loadData()
             }
 
             lastCacheSizeEvent = updateCacheCount(lastCacheSizeEvent, pixmapStartTime, pixSize,
-                                                  newEvent, event.typeIndex);
+                                                  newEvent, event.typeIndex());
             break;
         }
         case PixmapLoadingStarted: { // Load
@@ -301,7 +301,7 @@ void PixmapCacheModel::loadData()
 
             PixmapState &state = pixmap.sizes[newEvent.sizeIndex];
             state.loadState = Loading;
-            newEvent.typeId = event.typeIndex;
+            newEvent.typeId = event.typeIndex();
             state.started = insertStart(pixmapStartTime, newEvent.urlIndex + 1);
             m_data.insert(state.started, newEvent);
             break;
@@ -346,7 +346,7 @@ void PixmapCacheModel::loadData()
             // If the pixmap loading wasn't started, start it at traceStartTime()
             if (state.loadState == Initial) {
                 newEvent.pixmapEventType = PixmapLoadingStarted;
-                newEvent.typeId = event.typeIndex;
+                newEvent.typeId = event.typeIndex();
                 qint64 traceStart = modelManager()->traceTime()->startTime();
                 state.started = insert(traceStart, pixmapStartTime - traceStart,
                                        newEvent.urlIndex + 1);
diff --git a/plugins/qmlprofiler/scenegraphtimelinemodel.cpp b/plugins/qmlprofiler/scenegraphtimelinemodel.cpp
index 304aca76dc..0683c86aa9 100644
--- a/plugins/qmlprofiler/scenegraphtimelinemodel.cpp
+++ b/plugins/qmlprofiler/scenegraphtimelinemodel.cpp
@@ -136,7 +136,7 @@ void SceneGraphTimelineModel::loadData()
     // combine the data of several eventtypes into two rows
     const QVector<QmlProfilerDataModel::QmlEventTypeData> &types = simpleModel->getEventTypes();
     foreach (const QmlProfilerDataModel::QmlEventData &event, simpleModel->getEvents()) {
-        const QmlProfilerDataModel::QmlEventTypeData &type = types[event.typeIndex];
+        const QmlProfilerDataModel::QmlEventTypeData &type = types[event.typeIndex()];
         if (!accepted(type))
             continue;
 
@@ -146,70 +146,70 @@ void SceneGraphTimelineModel::loadData()
             // look incomplete if that was left out as the printf profiler lists it, too, and people
             // are apparently comparing that. Unfortunately it is somewhat redundant as the other
             // parts of the breakdown are usually very short.
-            qint64 startTime = event.startTime - event.numericData1 - event.numericData2 -
-                    event.numericData3 - event.numericData4;
-            startTime += insert(startTime, event.numericData1, event.typeIndex, RenderPreprocess);
-            startTime += insert(startTime, event.numericData2, event.typeIndex, RenderUpdate);
-            startTime += insert(startTime, event.numericData3, event.typeIndex, RenderBind);
-            insert(startTime, event.numericData4, event.typeIndex, RenderRender);
+            qint64 startTime = event.startTime() - event.numericData(0) - event.numericData(1) -
+                    event.numericData(2) - event.numericData(3);
+            startTime += insert(startTime, event.numericData(0), event.typeIndex(), RenderPreprocess);
+            startTime += insert(startTime, event.numericData(1), event.typeIndex(), RenderUpdate);
+            startTime += insert(startTime, event.numericData(2), event.typeIndex(), RenderBind);
+            insert(startTime, event.numericData(3), event.typeIndex(), RenderRender);
             break;
         }
         case QmlDebug::SceneGraphAdaptationLayerFrame: {
-            qint64 startTime = event.startTime - event.numericData2 - event.numericData3;
-            startTime += insert(startTime, event.numericData2, event.typeIndex, GlyphRender,
-                                event.numericData1);
-            insert(startTime, event.numericData3, event.typeIndex, GlyphStore, event.numericData1);
+            qint64 startTime = event.startTime() - event.numericData(1) - event.numericData(2);
+            startTime += insert(startTime, event.numericData(1), event.typeIndex(), GlyphRender,
+                                event.numericData(0));
+            insert(startTime, event.numericData(2), event.typeIndex(), GlyphStore, event.numericData(0));
             break;
         }
         case QmlDebug::SceneGraphContextFrame: {
-            insert(event.startTime - event.numericData1, event.numericData1, event.typeIndex,
+            insert(event.startTime() - event.numericData(0), event.numericData(0), event.typeIndex(),
                       Material);
             break;
         }
         case QmlDebug::SceneGraphRenderLoopFrame: {
-            qint64 startTime = event.startTime - event.numericData1 - event.numericData2 -
-                    event.numericData3;
-            startTime += insert(startTime, event.numericData1, event.typeIndex,
+            qint64 startTime = event.startTime() - event.numericData(0) - event.numericData(1) -
+                    event.numericData(2);
+            startTime += insert(startTime, event.numericData(0), event.typeIndex(),
                                    RenderThreadSync);
-            startTime += insert(startTime, event.numericData2, event.typeIndex,
+            startTime += insert(startTime, event.numericData(1), event.typeIndex(),
                                    Render);
-            insert(startTime, event.numericData3, event.typeIndex, Swap);
+            insert(startTime, event.numericData(2), event.typeIndex(), Swap);
             break;
         }
         case QmlDebug::SceneGraphTexturePrepare: {
-            qint64 startTime = event.startTime - event.numericData1 - event.numericData2 -
-                    event.numericData3 - event.numericData4 - event.numericData5;
-            startTime += insert(startTime, event.numericData1, event.typeIndex, TextureBind);
-            startTime += insert(startTime, event.numericData2, event.typeIndex, TextureConvert);
-            startTime += insert(startTime, event.numericData3, event.typeIndex, TextureSwizzle);
-            startTime += insert(startTime, event.numericData4, event.typeIndex, TextureUpload);
-            insert(startTime, event.numericData5, event.typeIndex, TextureMipmap);
+            qint64 startTime = event.startTime() - event.numericData(0) - event.numericData(1) -
+                    event.numericData(2) - event.numericData(3) - event.numericData(4);
+            startTime += insert(startTime, event.numericData(0), event.typeIndex(), TextureBind);
+            startTime += insert(startTime, event.numericData(1), event.typeIndex(), TextureConvert);
+            startTime += insert(startTime, event.numericData(2), event.typeIndex(), TextureSwizzle);
+            startTime += insert(startTime, event.numericData(3), event.typeIndex(), TextureUpload);
+            insert(startTime, event.numericData(4), event.typeIndex(), TextureMipmap);
             break;
         }
         case QmlDebug::SceneGraphTextureDeletion: {
-            insert(event.startTime - event.numericData1, event.numericData1, event.typeIndex,
+            insert(event.startTime() - event.numericData(0), event.numericData(0), event.typeIndex(),
                    TextureDeletion);
             break;
         }
         case QmlDebug::SceneGraphPolishAndSync: {
-            qint64 startTime = event.startTime - event.numericData1 - event.numericData2 -
-                    event.numericData3 - event.numericData4;
+            qint64 startTime = event.startTime() - event.numericData(0) - event.numericData(1) -
+                    event.numericData(2) - event.numericData(3);
 
-            startTime += insert(startTime, event.numericData1, event.typeIndex, Polish);
-            startTime += insert(startTime, event.numericData2, event.typeIndex, Wait);
-            startTime += insert(startTime, event.numericData3, event.typeIndex, GUIThreadSync);
-            insert(startTime, event.numericData4, event.typeIndex, Animations);
+            startTime += insert(startTime, event.numericData(0), event.typeIndex(), Polish);
+            startTime += insert(startTime, event.numericData(1), event.typeIndex(), Wait);
+            startTime += insert(startTime, event.numericData(2), event.typeIndex(), GUIThreadSync);
+            insert(startTime, event.numericData(3), event.typeIndex(), Animations);
             break;
         }
         case QmlDebug::SceneGraphWindowsAnimations: {
             // GUI thread, separate animations stage
-            insert(event.startTime - event.numericData1, event.numericData1, event.typeIndex,
+            insert(event.startTime() - event.numericData(0), event.numericData(0), event.typeIndex(),
                    Animations);
             break;
         }
         case QmlDebug::SceneGraphPolishFrame: {
             // GUI thread, separate polish stage
-            insert(event.startTime - event.numericData1, event.numericData1, event.typeIndex,
+            insert(event.startTime() - event.numericData(0), event.numericData(0), event.typeIndex(),
                    Polish);
             break;
         }