Switch the gui to the on-demand-loader.

[apitrace] / gui / apitrace.cpp

diff --git a/gui/apitrace.cpp b/gui/apitrace.cpp
index eb65ba8754eb5d359f06a5d4997234bba02966ef..d6a9e41375c2cda6ef5f39eb43084e21d2b35cc0 100644 (file)
--- a/gui/apitrace.cpp
+++ b/gui/apitrace.cpp
@@ -1,31 +1,46 @@
 #include "apitrace.h"
 
-#include "loaderthread.h"
+#include "traceloader.h"
 #include "saverthread.h"
 
 #include <QDir>
+#include <QThread>
 
 ApiTrace::ApiTrace()
     : m_frameMarker(ApiTrace::FrameMarker_SwapBuffers),
       m_needsSaving(false)
 {
-    m_loader = new LoaderThread(this);
-    connect(m_loader, SIGNAL(parsedFrames(const QList<ApiTraceFrame*>)),
+    m_loader = new TraceLoader();
+    connect(this, SIGNAL(loadTrace(QString)),
+            m_loader, SLOT(loadTrace(QString)));
+    connect(m_loader, SIGNAL(framesLoaded(const QList<ApiTraceFrame*>)),
             this, SLOT(addFrames(const QList<ApiTraceFrame*>)));
-    connect(m_loader, SIGNAL(started()),
+    connect(m_loader, SIGNAL(frameLoaded(int,QVector<ApiTraceCall*>,quint64)),
+            this, SLOT(fillFrame(int,QVector<ApiTraceCall*>,quint64)));
+
+    connect(m_loader, SIGNAL(startedParsing()),
             this, SIGNAL(startedLoadingTrace()));
-    connect(m_loader, SIGNAL(finished()),
+    connect(m_loader, SIGNAL(parsed(int)),
+            this, SIGNAL(loaded(int)));
+    connect(m_loader, SIGNAL(finishedParsing()),
             this, SIGNAL(finishedLoadingTrace()));
 
+
     m_saver = new SaverThread(this);
     connect(m_saver, SIGNAL(traceSaved()),
             this, SLOT(slotSaved()));
     connect(m_saver, SIGNAL(traceSaved()),
             this, SIGNAL(saved()));
+
+    m_loaderThread = new QThread();
+    m_loader->moveToThread(m_loaderThread);
+    m_loaderThread->start();
 }
 
 ApiTrace::~ApiTrace()
 {
+    m_loaderThread->quit();
+    m_loaderThread->deleteLater();
     qDeleteAll(m_calls);
     qDeleteAll(m_frames);
     delete m_loader;
@@ -40,7 +55,9 @@ bool ApiTrace::isCallAFrameMarker(const ApiTraceCall *call,
 
     switch (marker) {
     case FrameMarker_SwapBuffers:
-        return call->name().contains(QLatin1String("SwapBuffers"));
+        return call->name().contains(QLatin1String("SwapBuffers")) ||
+               call->name() == QLatin1String("CGLFlushDrawable") ||
+               call->name() == QLatin1String("glFrameTerminatorGREMEDY");
     case FrameMarker_Flush:
         return call->name() == QLatin1String("glFlush");
     case FrameMarker_Finish:
@@ -72,7 +89,7 @@ ApiTrace::FrameMarker ApiTrace::frameMarker() const
     return m_frameMarker;
 }
 
-QList<ApiTraceCall*> ApiTrace::calls() const
+QVector<ApiTraceCall*> ApiTrace::calls() const
 {
     return m_calls;
 }
@@ -106,7 +123,7 @@ int ApiTrace::numCallsInFrame(int idx) const
 {
     const ApiTraceFrame *frame = frameAt(idx);
     if (frame)
-        return frame->calls.count();
+        return frame->numChildren();
     else
         return 0;
 }
@@ -116,10 +133,6 @@ void ApiTrace::setFileName(const QString &name)
     if (m_fileName != name) {
         m_fileName = name;
 
-        if (m_loader->isRunning()) {
-            m_loader->terminate();
-            m_loader->wait();
-        }
         m_frames.clear();
         m_calls.clear();
         m_errors.clear();
@@ -127,7 +140,8 @@ void ApiTrace::setFileName(const QString &name)
         m_needsSaving = false;
         emit invalidated();
 
-        m_loader->loadFile(m_fileName);
+//        m_loader->loadTrace(m_fileName);
+        emit loadTrace(m_fileName);
     }
 }
 
@@ -144,19 +158,25 @@ void ApiTrace::setFrameMarker(FrameMarker marker)
 
 void ApiTrace::addFrames(const QList<ApiTraceFrame*> &frames)
 {
+    QVector<ApiTraceCall*> calls;
     int currentFrames = m_frames.count();
     int numNewFrames = frames.count();
+
+    emit beginAddingFrames(currentFrames, numNewFrames);
+
     m_frames += frames;
 
     int currentCalls = m_calls.count();
     int numNewCalls = 0;
     foreach(ApiTraceFrame *frame, frames) {
         frame->setParentTrace(this);
-        numNewCalls += frame->calls.count();
-        m_calls += frame->calls;
+        numNewCalls += frame->numChildren();
+        calls += frame->calls();
     }
+    m_calls.reserve(m_calls.count() + calls.count() + 1);
+    m_calls += calls;
 
-    emit framesAdded(currentFrames, numNewFrames);
+    emit endAddingFrames();
     emit callsAdded(currentCalls, numNewCalls);
 }
 
@@ -165,15 +185,17 @@ void ApiTrace::detectFrames()
     if (m_calls.isEmpty())
         return;
 
+    emit beginAddingFrames(0, m_frames.count());
+
     ApiTraceFrame *currentFrame = 0;
     foreach(ApiTraceCall *apiCall, m_calls) {
         if (!currentFrame) {
-            currentFrame = new ApiTraceFrame();
-            currentFrame->setParentTrace(this);
+            currentFrame = new ApiTraceFrame(this);
             currentFrame->number = m_frames.count();
+            currentFrame->setLoaded(true);
         }
         apiCall->setParentFrame(currentFrame);
-        currentFrame->calls.append(apiCall);
+        currentFrame->addCall(apiCall);
         if (ApiTrace::isCallAFrameMarker(apiCall,
                                          m_frameMarker)) {
             m_frames.append(currentFrame);
@@ -187,7 +209,7 @@ void ApiTrace::detectFrames()
         m_frames.append(currentFrame);
         currentFrame = 0;
     }
-    emit framesAdded(0, m_frames.count());
+    emit endAddingFrames();
 }
 
 ApiTraceCall * ApiTrace::callWithIndex(int idx) const
@@ -203,10 +225,10 @@ ApiTraceCall * ApiTrace::callWithIndex(int idx) const
 ApiTraceState ApiTrace::defaultState() const
 {
     ApiTraceFrame *frame = frameAt(0);
-    if (!frame)
+    if (!frame || !frame->hasState())
         return ApiTraceState();
 
-    return frame->state();
+    return *frame->state();
 }
 
 void ApiTrace::callEdited(ApiTraceCall *call)
@@ -280,4 +302,9 @@ bool ApiTrace::hasErrors() const
     return !m_errors.isEmpty();
 }
 
+void ApiTrace::fillFrame(int frameIdx, const QVector<ApiTraceCall *> &calls,
+                         quint64 binaryDataSize)
+{
+}
+
 #include "apitrace.moc"