Cleanup some of the code.

[apitrace] / gui / apitrace.cpp

diff --git a/gui/apitrace.cpp b/gui/apitrace.cpp
index 6254d2cb2481d8587fdcc293a96b057ae6914548..bc862097099c75c0d48ce1a093ba3aff70711866 100644 (file)
--- a/gui/apitrace.cpp
+++ b/gui/apitrace.cpp
@@ -78,8 +78,9 @@ ApiTrace::~ApiTrace()
 bool ApiTrace::isCallAFrameMarker(const ApiTraceCall *call,
                                   ApiTrace::FrameMarker marker)
 {
-    if (!call)
+    if (!call) {
         return false;
+    }
 
     switch (marker) {
     case FrameMarker_SwapBuffers:
@@ -106,8 +107,9 @@ bool ApiTrace::isEmpty() const
 
 QString ApiTrace::fileName() const
 {
-    if (edited())
+    if (edited()) {
         return m_tempFileName;
+    }
 
     return m_fileName;
 }
@@ -135,10 +137,11 @@ 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)
@@ -152,14 +155,12 @@ void ApiTrace::setFileName(const QString &name)
         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 +168,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 +179,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,10 +189,16 @@ ApiTraceCall * ApiTrace::callWithIndex(int idx) const
 ApiTraceState ApiTrace::defaultState() const
 {
     ApiTraceFrame *frame = frameAt(0);
-    if (!frame || !frame->hasState())
+    if (!frame || !frame->isLoaded() || frame->isEmpty()) {
         return ApiTraceState();
+    }
 
-    return *frame->state();
+    ApiTraceCall *firstCall = frame->calls().first();
+    if (!firstCall->hasState()) {
+        return ApiTraceState();
+    }
+
+    return *firstCall->state();
 }
 
 void ApiTrace::callEdited(ApiTraceCall *call)
@@ -237,8 +242,9 @@ void ApiTrace::save()
     QDir dir;
     emit startedSaving();
     dir.mkpath(fi.absolutePath());
-    Q_ASSERT(!"saving not implemented");
-    m_saver->saveFile(m_tempFileName, QVector<ApiTraceCall*>());
+    m_saver->saveFile(m_tempFileName,
+                      m_fileName,
+                      m_editedCalls);
 }
 
 void ApiTrace::slotSaved()
@@ -251,18 +257,6 @@ bool ApiTrace::isSaving() const
     return m_saver->isRunning();
 }
 
-void ApiTrace::callError(ApiTraceCall *call)
-{
-    Q_ASSERT(call);
-
-    if (call->hasError())
-        m_errors.insert(call);
-    else
-        m_errors.remove(call);
-
-    emit changed(call);
-}
-
 bool ApiTrace::hasErrors() const
 {
     return !m_errors.isEmpty();
@@ -270,14 +264,14 @@ bool ApiTrace::hasErrors() const
 
 void ApiTrace::loadFrame(ApiTraceFrame *frame)
 {
-    Q_ASSERT(!frame->loaded());
+    Q_ASSERT(!frame->isLoaded());
     emit requestFrame(frame);
 }
 
 void ApiTrace::finishedParsing()
 {
     ApiTraceFrame *firstFrame = m_frames[0];
-    if (firstFrame && !firstFrame->loaded()) {
+    if (firstFrame && !firstFrame->isLoaded()) {
         loadFrame(firstFrame);
     }
 }
@@ -290,6 +284,31 @@ void ApiTrace::loaderFrameLoaded(ApiTraceFrame *frame,
     emit beginLoadingFrame(frame, calls.size());
     frame->setCalls(calls, binaryDataSize);
     emit endLoadingFrame(frame);
+
+    if (!m_queuedErrors.isEmpty()) {
+        QList< QPair<ApiTraceFrame*, ApiTraceError> >::iterator itr;
+        for (itr = m_queuedErrors.begin(); itr != m_queuedErrors.end();
+             ++itr) {
+            const ApiTraceError &error = (*itr).second;
+            if ((*itr).first == frame) {
+                ApiTraceCall *call = frame->callWithIndex(error.callIndex);
+
+                if (!call) {
+                    continue;
+                }
+
+                call->setError(error.message);
+                m_queuedErrors.erase(itr);
+
+                if (call->hasError()) {
+                    m_errors.insert(call);
+                } else {
+                    m_errors.remove(call);
+                }
+                emit changed(call);
+            }
+        }
+    }
 }
 
 void ApiTrace::findNext(ApiTraceFrame *frame,
@@ -300,10 +319,10 @@ void ApiTrace::findNext(ApiTraceFrame *frame,
     ApiTraceCall *foundCall = 0;
     int frameIdx = m_frames.indexOf(frame);
 
-    if (frame->loaded()) {
+    if (frame->isLoaded()) {
         foundCall = frame->findNextCall(from, str, sensitivity);
         if (foundCall) {
-            emit findResult(SearchFound, foundCall);
+            emit findResult(SearchResult_Found, foundCall);
             return;
         }
 
@@ -314,18 +333,18 @@ void ApiTrace::findNext(ApiTraceFrame *frame,
 
     for (int i = frameIdx; i < m_frames.count(); ++i) {
         ApiTraceFrame *frame = m_frames[i];
-        if (!frame->loaded()) {
+        if (!frame->isLoaded()) {
             emit loaderSearchNext(i, str, sensitivity);
             return;
         } else {
             ApiTraceCall *call = frame->findNextCall(0, str, sensitivity);
             if (call) {
-                emit findResult(SearchFound, call);
+                emit findResult(SearchResult_Found, call);
                 return;
             }
         }
     }
-    emit findResult(SearchWrapped, 0);
+    emit findResult(SearchResult_Wrapped, 0);
 }
 
 void ApiTrace::findPrev(ApiTraceFrame *frame,
@@ -336,10 +355,10 @@ void ApiTrace::findPrev(ApiTraceFrame *frame,
     ApiTraceCall *foundCall = 0;
     int frameIdx = m_frames.indexOf(frame);
 
-    if (frame->loaded()) {
+    if (frame->isLoaded()) {
         foundCall = frame->findPrevCall(from, str, sensitivity);
         if (foundCall) {
-            emit findResult(SearchFound, foundCall);
+            emit findResult(SearchResult_Found, foundCall);
             return;
         }
 
@@ -350,18 +369,18 @@ void ApiTrace::findPrev(ApiTraceFrame *frame,
 
     for (int i = frameIdx; i >= 0; --i) {
         ApiTraceFrame *frame = m_frames[i];
-        if (!frame->loaded()) {
+        if (!frame->isLoaded()) {
             emit loaderSearchPrev(i, str, sensitivity);
             return;
         } else {
             ApiTraceCall *call = frame->findPrevCall(0, str, sensitivity);
             if (call) {
-                emit findResult(SearchFound, call);
+                emit findResult(SearchResult_Found, call);
                 return;
             }
         }
     }
-    emit findResult(SearchWrapped, 0);
+    emit findResult(SearchResult_Wrapped, 0);
 }
 
 void ApiTrace::loaderSearchResult(ApiTrace::SearchResult result,
@@ -374,7 +393,7 @@ void ApiTrace::loaderSearchResult(ApiTrace::SearchResult result,
 
 void ApiTrace::findFrameStart(ApiTraceFrame *frame)
 {
-    if (frame->loaded()) {
+    if (frame->isLoaded()) {
         emit foundFrameStart(frame);
     } else {
         emit loaderFindFrameStart(frame);
@@ -383,7 +402,7 @@ void ApiTrace::findFrameStart(ApiTraceFrame *frame)
 
 void ApiTrace::findFrameEnd(ApiTraceFrame *frame)
 {
-    if (frame->loaded()) {
+    if (frame->isLoaded()) {
         emit foundFrameEnd(frame);
     } else {
         emit loaderFindFrameEnd(frame);
@@ -403,7 +422,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 {
@@ -418,7 +437,7 @@ int ApiTrace::callInFrame(int callIdx) const
 
     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;
@@ -432,4 +451,29 @@ int ApiTrace::callInFrame(int callIdx) const
     return -1;
 }
 
+void ApiTrace::setCallError(const ApiTraceError &error)
+{
+    int frameIdx = callInFrame(error.callIndex);
+    ApiTraceFrame *frame = 0;
+
+    if (frameIdx < 0) {
+        return;
+    }
+    frame = m_frames[frameIdx];
+
+    if (frame->isLoaded()) {
+        ApiTraceCall *call = frame->callWithIndex(error.callIndex);
+        call->setError(error.message);
+        if (call->hasError()) {
+            m_errors.insert(call);
+        } else {
+            m_errors.remove(call);
+        }
+        emit changed(call);
+    } else {
+        emit requestFrame(frame);
+        m_queuedErrors.append(qMakePair(frame, error));
+    }
+}
+
 #include "apitrace.moc"