]> git.cworth.org Git - apitrace/blobdiff - gui/apitrace.cpp
projects / apitrace / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix size comparisons in traceloader.cpp.
[apitrace] / gui / apitrace.cpp
diff --git a/gui/apitrace.cpp b/gui/apitrace.cpp
index 6f101cd9f789aa21dc7ae13d83683ba4e638fe2d..084a4bf78633b9ec56c98b4f3d2ec4c30a49cdcd 100644 (file)
--- a/gui/apitrace.cpp
+++ b/gui/apitrace.cpp
@@ -25,14 +25,12 @@ ApiTrace::ApiTrace()
             SLOT(loaderFrameLoaded(ApiTraceFrame*,QVector<ApiTraceCall*>,quint64)));
     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*)),
@@ -78,14 +76,13 @@ ApiTrace::~ApiTrace()
 bool ApiTrace::isCallAFrameMarker(const ApiTraceCall *call,
                                   ApiTrace::FrameMarker marker)
 {
-    if (!call)
+    if (!call) {
         return false;
+    }
 
     switch (marker) {
     case FrameMarker_SwapBuffers:
-        return call->name().contains(QLatin1String("SwapBuffers")) ||
-               call->name() == QLatin1String("CGLFlushDrawable") ||
-               call->name() == QLatin1String("glFrameTerminatorGREMEDY");
+        return call->flags() & trace::CALL_FLAG_END_FRAME;
     case FrameMarker_Flush:
         return call->name() == QLatin1String("glFlush");
     case FrameMarker_Finish:
@@ -106,8 +103,9 @@ bool ApiTrace::isEmpty() const
 
 QString ApiTrace::fileName() const
 {
-    if (edited())
+    if (edited()) {
         return m_tempFileName;
+    }
 
     return m_fileName;
 }
@@ -135,31 +133,32 @@ int ApiTrace::numFrames() const
 int ApiTrace::numCallsInFrame(int idx) const
 {
     const ApiTraceFrame *frame = frameAt(idx);
-    if (frame)
+    if (frame) {
         return frame->numChildren();
-    else
+    } else {
         return 0;
+    }
 }
 
 void ApiTrace::setFileName(const QString &name)
 {
     if (m_fileName != name) {
         m_fileName = name;
+        m_tempFileName = QString();
 
         m_frames.clear();
         m_errors.clear();
         m_editedCalls.clear();
+        m_queuedErrors.clear();
         m_needsSaving = false;
         emit invalidated();
 
-//        m_loader->loadTrace(m_fileName);
         emit loadTrace(m_fileName);
     }
 }
 
 void ApiTrace::addFrames(const QList<ApiTraceFrame*> &frames)
 {
-    QVector<ApiTraceCall*> calls;
     int currentFrames = m_frames.count();
     int numNewFrames = frames.count();
 
@@ -167,11 +166,8 @@ void ApiTrace::addFrames(const QList<ApiTraceFrame*> &frames)
 
     m_frames += frames;
 
-    int numNewCalls = 0;
     foreach(ApiTraceFrame *frame, frames) {
         frame->setParentTrace(this);
-        numNewCalls += frame->numChildren();
-        calls += frame->calls();
     }
 
     emit endAddingFrames();
@@ -181,8 +177,9 @@ ApiTraceCall * ApiTrace::callWithIndex(int idx) const
 {
     for (int i = 0; i < m_frames.count(); ++i) {
         ApiTraceCall *call = m_frames[i]->callWithIndex(idx);
-        if (call)
+        if (call) {
             return call;
+        }
     }
     return NULL;
 }
@@ -190,8 +187,9 @@ ApiTraceCall * ApiTrace::callWithIndex(int idx) const
 ApiTraceState ApiTrace::defaultState() const
 {
     ApiTraceFrame *frame = frameAt(0);
-    if (!frame || !frame->loaded() || frame->isEmpty())
+    if (!frame || !frame->isLoaded() || frame->isEmpty()) {
         return ApiTraceState();
+    }
 
     ApiTraceCall *firstCall = frame->calls().first();
     if (!firstCall->hasState()) {
@@ -264,15 +262,20 @@ bool ApiTrace::hasErrors() const
 
 void ApiTrace::loadFrame(ApiTraceFrame *frame)
 {
-    Q_ASSERT(!frame->loaded());
-    emit requestFrame(frame);
+    if (!isFrameLoading(frame)) {
+        Q_ASSERT(!frame->isLoaded());
+        m_loadingFrames.insert(frame);
+        emit requestFrame(frame);
+    }
 }
 
 void ApiTrace::finishedParsing()
 {
-    ApiTraceFrame *firstFrame = m_frames[0];
-    if (firstFrame && !firstFrame->loaded()) {
-        loadFrame(firstFrame);
+    if (!m_frames.isEmpty()) {
+        ApiTraceFrame *firstFrame = m_frames[0];
+        if (firstFrame && !firstFrame->isLoaded()) {
+            loadFrame(firstFrame);
+        }
     }
 }
 
@@ -281,9 +284,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;
@@ -318,11 +325,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->loaded()) {
+    if (frame->isLoaded()) {
         foundCall = frame->findNextCall(from, str, sensitivity);
         if (foundCall) {
-            emit findResult(SearchFound, foundCall);
+            emit findResult(request, SearchResult_Found, foundCall);
             return;
         }
 
@@ -331,20 +340,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];
-        if (!frame->loaded()) {
-            emit loaderSearchNext(i, str, sensitivity);
+        request.frame = frame;
+        if (!frame->isLoaded()) {
+            emit loaderSearch(request);
             return;
         } else {
             ApiTraceCall *call = frame->findNextCall(0, str, sensitivity);
             if (call) {
-                emit findResult(SearchFound, call);
+                emit findResult(request, SearchResult_Found, call);
                 return;
             }
         }
     }
-    emit findResult(SearchWrapped, 0);
+    emit findResult(request, SearchResult_Wrapped, 0);
 }
 
 void ApiTrace::findPrev(ApiTraceFrame *frame,
@@ -354,11 +366,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->loaded()) {
+    if (frame->isLoaded()) {
         foundCall = frame->findPrevCall(from, str, sensitivity);
         if (foundCall) {
-            emit findResult(SearchFound, foundCall);
+            emit findResult(request, SearchResult_Found, foundCall);
             return;
         }
 
@@ -367,33 +381,36 @@ void ApiTrace::findPrev(ApiTraceFrame *frame,
         frameIdx -= 1;
     }
 
+    request.from = 0;
     for (int i = frameIdx; i >= 0; --i) {
         ApiTraceFrame *frame = m_frames[i];
-        if (!frame->loaded()) {
-            emit loaderSearchPrev(i, str, sensitivity);
+        request.frame = frame;
+        if (!frame->isLoaded()) {
+            emit loaderSearch(request);
             return;
         } else {
             ApiTraceCall *call = frame->findPrevCall(0, str, sensitivity);
             if (call) {
-                emit findResult(SearchFound, call);
+                emit findResult(request, SearchResult_Found, call);
                 return;
             }
         }
     }
-    emit findResult(SearchWrapped, 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->loaded()) {
+    if (frame->isLoaded()) {
         emit foundFrameStart(frame);
     } else {
         emit loaderFindFrameStart(frame);
@@ -402,7 +419,7 @@ void ApiTrace::findFrameStart(ApiTraceFrame *frame)
 
 void ApiTrace::findFrameEnd(ApiTraceFrame *frame)
 {
-    if (frame->loaded()) {
+    if (frame->isLoaded()) {
         emit foundFrameEnd(frame);
     } else {
         emit loaderFindFrameEnd(frame);
@@ -422,7 +439,7 @@ void ApiTrace::findCallIndex(int index)
     frame = m_frames[frameIdx];
 
     if (frame) {
-        if (frame->loaded()) {
+        if (frame->isLoaded()) {
             ApiTraceCall *call = frame->callWithIndex(index);
             emit foundCallIndex(call);
         } else {
@@ -435,9 +452,9 @@ 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->loaded()
+        unsigned numCallsInFrame =  frame->isLoaded()
                 ? frame->numChildren()
                 : frame->numChildrenToLoad();
         unsigned firstCall = numCalls;
@@ -461,7 +478,7 @@ void ApiTrace::setCallError(const ApiTraceError &error)
     }
     frame = m_frames[frameIdx];
 
-    if (frame->loaded()) {
+    if (frame->isLoaded()) {
         ApiTraceCall *call = frame->callWithIndex(error.callIndex);
         call->setError(error.message);
         if (call->hasError()) {
@@ -471,9 +488,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"
Carl's hacks to apitrace (upstream at https://github.com/apitrace/apitrace)