X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=gui%2Fapitrace.cpp;h=a69ce2fff0ef25a2f0293e392e273f9b4ecc1b4d;hb=940cdb8b143455fe2fc002ffd50f5e2ffcaf1260;hp=edf98b9eb85e33985c1fb9be53151e67db2f6d51;hpb=daf82af9d5f270c87434cc1142f32a6407703781;p=apitrace

diff --git a/gui/apitrace.cpp b/gui/apitrace.cpp
index edf98b9..a69ce2f 100644
--- a/gui/apitrace.cpp
+++ b/gui/apitrace.cpp
@@ -8,8 +8,7 @@
 #include <QThread>
 
 ApiTrace::ApiTrace()
-    : m_frameMarker(ApiTrace::FrameMarker_SwapBuffers),
-      m_needsSaving(false)
+    : m_needsSaving(false)
 {
     m_loader = new TraceLoader();
 
@@ -23,16 +22,16 @@ ApiTrace::ApiTrace()
             SIGNAL(frameContentsLoaded(ApiTraceFrame*,QVector<ApiTraceCall*>,quint64)),
             this,
             SLOT(loaderFrameLoaded(ApiTraceFrame*,QVector<ApiTraceCall*>,quint64)));
+    connect(m_loader, SIGNAL(guessedApi(int)),
+            this, SLOT(guessedApi(int)));
     connect(m_loader, SIGNAL(finishedParsing()),
             this, SLOT(finishedParsing()));
-    connect(this, SIGNAL(loaderSearchNext(int,QString,Qt::CaseSensitivity)),
-            m_loader, SLOT(searchNext(int,QString,Qt::CaseSensitivity)));
-    connect(this, SIGNAL(loaderSearchPrev(int,QString,Qt::CaseSensitivity)),
-            m_loader, SLOT(searchPrev(int,QString,Qt::CaseSensitivity)));
+    connect(this, SIGNAL(loaderSearch(ApiTrace::SearchRequest)),
+            m_loader, SLOT(search(ApiTrace::SearchRequest)));
     connect(m_loader,
-            SIGNAL(searchResult(ApiTrace::SearchResult,ApiTraceCall*)),
+            SIGNAL(searchResult(ApiTrace::SearchRequest,ApiTrace::SearchResult,ApiTraceCall*)),
             this,
-            SLOT(loaderSearchResult(ApiTrace::SearchResult,ApiTraceCall*)));
+            SLOT(loaderSearchResult(ApiTrace::SearchRequest,ApiTrace::SearchResult,ApiTraceCall*)));
     connect(this, SIGNAL(loaderFindFrameStart(ApiTraceFrame*)),
             m_loader, SLOT(findFrameStart(ApiTraceFrame*)));
     connect(this, SIGNAL(loaderFindFrameEnd(ApiTraceFrame*)),
@@ -75,31 +74,6 @@ ApiTrace::~ApiTrace()
     delete m_saver;
 }
 
-bool ApiTrace::isCallAFrameMarker(const ApiTraceCall *call,
-                                  ApiTrace::FrameMarker marker)
-{
-    if (!call) {
-        return false;
-    }
-
-    switch (marker) {
-    case FrameMarker_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:
-        return call->name() == QLatin1String("glFinish");
-    case FrameMarker_Clear:
-        return call->name() == QLatin1String("glClear");
-    }
-
-    Q_ASSERT(!"unknown frame marker");
-
-    return false;
-}
-
 bool ApiTrace::isEmpty() const
 {
     return m_frames.isEmpty();
@@ -114,12 +88,7 @@ QString ApiTrace::fileName() const
     return m_fileName;
 }
 
-ApiTrace::FrameMarker ApiTrace::frameMarker() const
-{
-    return m_frameMarker;
-}
-
-QList<ApiTraceFrame*> ApiTrace::frames() const
+const QList<ApiTraceFrame*> & ApiTrace::frames() const
 {
     return m_frames;
 }
@@ -261,20 +230,35 @@ bool ApiTrace::isSaving() const
 
 bool ApiTrace::hasErrors() const
 {
-    return !m_errors.isEmpty();
+    return !m_errors.isEmpty() || !m_queuedErrors.isEmpty();
 }
 
 void ApiTrace::loadFrame(ApiTraceFrame *frame)
 {
-    Q_ASSERT(!frame->isLoaded());
-    emit requestFrame(frame);
+    if (!isFrameLoading(frame)) {
+        Q_ASSERT(!frame->isLoaded());
+        m_loadingFrames.insert(frame);
+        emit requestFrame(frame);
+    }
+}
+
+void ApiTrace::guessedApi(int api)
+{
+    m_api = static_cast<trace::API>(api);
+}
+
+trace::API ApiTrace::api() const
+{
+    return m_api;
 }
 
 void ApiTrace::finishedParsing()
 {
-    ApiTraceFrame *firstFrame = m_frames[0];
-    if (firstFrame && !firstFrame->isLoaded()) {
-        loadFrame(firstFrame);
+    if (!m_frames.isEmpty()) {
+        ApiTraceFrame *firstFrame = m_frames[0];
+        if (firstFrame && !firstFrame->isLoaded()) {
+            loadFrame(firstFrame);
+        }
     }
 }
 
@@ -283,9 +267,13 @@ void ApiTrace::loaderFrameLoaded(ApiTraceFrame *frame,
                                  quint64 binaryDataSize)
 {
     Q_ASSERT(frame->numChildrenToLoad() == calls.size());
-    emit beginLoadingFrame(frame, calls.size());
-    frame->setCalls(calls, binaryDataSize);
-    emit endLoadingFrame(frame);
+
+    if (!frame->isLoaded()) {
+        emit beginLoadingFrame(frame, calls.size());
+        frame->setCalls(calls, binaryDataSize);
+        emit endLoadingFrame(frame);
+        m_loadingFrames.remove(frame);
+    }
 
     if (!m_queuedErrors.isEmpty()) {
         QList< QPair<ApiTraceFrame*, ApiTraceError> >::iterator itr;
@@ -320,11 +308,13 @@ void ApiTrace::findNext(ApiTraceFrame *frame,
 {
     ApiTraceCall *foundCall = 0;
     int frameIdx = m_frames.indexOf(frame);
+    SearchRequest request(SearchRequest::Next,
+                          frame, from, str, sensitivity);
 
     if (frame->isLoaded()) {
         foundCall = frame->findNextCall(from, str, sensitivity);
         if (foundCall) {
-            emit findResult(SearchResult_Found, foundCall);
+            emit findResult(request, SearchResult_Found, foundCall);
             return;
         }
 
@@ -333,20 +323,23 @@ void ApiTrace::findNext(ApiTraceFrame *frame,
         frameIdx += 1;
     }
 
+    //for the rest of the frames we search from beginning
+    request.from = 0;
     for (int i = frameIdx; i < m_frames.count(); ++i) {
         ApiTraceFrame *frame = m_frames[i];
+        request.frame = frame;
         if (!frame->isLoaded()) {
-            emit loaderSearchNext(i, str, sensitivity);
+            emit loaderSearch(request);
             return;
         } else {
             ApiTraceCall *call = frame->findNextCall(0, str, sensitivity);
             if (call) {
-                emit findResult(SearchResult_Found, call);
+                emit findResult(request, SearchResult_Found, call);
                 return;
             }
         }
     }
-    emit findResult(SearchResult_Wrapped, 0);
+    emit findResult(request, SearchResult_Wrapped, 0);
 }
 
 void ApiTrace::findPrev(ApiTraceFrame *frame,
@@ -356,11 +349,13 @@ void ApiTrace::findPrev(ApiTraceFrame *frame,
 {
     ApiTraceCall *foundCall = 0;
     int frameIdx = m_frames.indexOf(frame);
+    SearchRequest request(SearchRequest::Prev,
+                          frame, from, str, sensitivity);
 
     if (frame->isLoaded()) {
         foundCall = frame->findPrevCall(from, str, sensitivity);
         if (foundCall) {
-            emit findResult(SearchResult_Found, foundCall);
+            emit findResult(request, SearchResult_Found, foundCall);
             return;
         }
 
@@ -369,32 +364,38 @@ void ApiTrace::findPrev(ApiTraceFrame *frame,
         frameIdx -= 1;
     }
 
+    request.from = 0;
     for (int i = frameIdx; i >= 0; --i) {
         ApiTraceFrame *frame = m_frames[i];
+        request.frame = frame;
         if (!frame->isLoaded()) {
-            emit loaderSearchPrev(i, str, sensitivity);
+            emit loaderSearch(request);
             return;
         } else {
             ApiTraceCall *call = frame->findPrevCall(0, str, sensitivity);
             if (call) {
-                emit findResult(SearchResult_Found, call);
+                emit findResult(request, SearchResult_Found, call);
                 return;
             }
         }
     }
-    emit findResult(SearchResult_Wrapped, 0);
+    emit findResult(request, SearchResult_Wrapped, 0);
 }
 
-void ApiTrace::loaderSearchResult(ApiTrace::SearchResult result,
+void ApiTrace::loaderSearchResult(const ApiTrace::SearchRequest &request,
+                                  ApiTrace::SearchResult result,
                                   ApiTraceCall *call)
 {
     //qDebug()<<"Search result = "<<result
     //       <<", call is = "<<call;
-    emit findResult(result, call);
+    emit findResult(request, result, call);
 }
 
 void ApiTrace::findFrameStart(ApiTraceFrame *frame)
 {
+    if (!frame)
+        return;
+
     if (frame->isLoaded()) {
         emit foundFrameStart(frame);
     } else {
@@ -404,6 +405,9 @@ void ApiTrace::findFrameStart(ApiTraceFrame *frame)
 
 void ApiTrace::findFrameEnd(ApiTraceFrame *frame)
 {
+    if (!frame)
+        return;
+
     if (frame->isLoaded()) {
         emit foundFrameEnd(frame);
     } else {
@@ -437,7 +441,7 @@ int ApiTrace::callInFrame(int callIdx) const
 {
     unsigned numCalls = 0;
 
-    for (int frameIdx = 0; frameIdx <= m_frames.size(); ++frameIdx) {
+    for (int frameIdx = 0; frameIdx < m_frames.size(); ++frameIdx) {
         const ApiTraceFrame *frame = m_frames[frameIdx];
         unsigned numCallsInFrame =  frame->isLoaded()
                 ? frame->numChildren()
@@ -473,9 +477,31 @@ void ApiTrace::setCallError(const ApiTraceError &error)
         }
         emit changed(call);
     } else {
-        emit requestFrame(frame);
+        loadFrame(frame);
         m_queuedErrors.append(qMakePair(frame, error));
     }
 }
 
+bool ApiTrace::isFrameLoading(ApiTraceFrame *frame) const
+{
+    return m_loadingFrames.contains(frame);
+}
+
+void ApiTrace::bindThumbnailsToFrames(const QList<QImage> &thumbnails)
+{
+    QList<ApiTraceFrame *> frames = m_frames;
+
+    QList<QImage>::const_iterator thumbnail = thumbnails.begin();
+
+    foreach (ApiTraceFrame *frame, frames) {
+        if (thumbnail != thumbnails.end()) {
+            frame->setThumbnail(*thumbnail);
+
+            ++thumbnail;
+
+            emit changed(frame);
+        }
+    }
+}
+
 #include "apitrace.moc"