Implement find prev.

[apitrace] / gui / apitrace.cpp

diff --git a/gui/apitrace.cpp b/gui/apitrace.cpp
index d6a9e41375c2cda6ef5f39eb43084e21d2b35cc0..51520c5e85df38cb2305914b7e798e714355cadc 100644 (file)
--- a/gui/apitrace.cpp
+++ b/gui/apitrace.cpp
@@ -3,6 +3,7 @@
 #include "traceloader.h"
 #include "saverthread.h"
 
+#include <QDebug>
 #include <QDir>
 #include <QThread>
 
@@ -11,12 +12,28 @@ ApiTrace::ApiTrace()
       m_needsSaving(false)
 {
     m_loader = new TraceLoader();
+
     connect(this, SIGNAL(loadTrace(QString)),
             m_loader, SLOT(loadTrace(QString)));
+    connect(this, SIGNAL(requestFrame(ApiTraceFrame*)),
+            m_loader, SLOT(loadFrame(ApiTraceFrame*)));
     connect(m_loader, SIGNAL(framesLoaded(const QList<ApiTraceFrame*>)),
             this, SLOT(addFrames(const QList<ApiTraceFrame*>)));
-    connect(m_loader, SIGNAL(frameLoaded(int,QVector<ApiTraceCall*>,quint64)),
-            this, SLOT(fillFrame(int,QVector<ApiTraceCall*>,quint64)));
+    connect(m_loader,
+            SIGNAL(frameContentsLoaded(ApiTraceFrame*,QVector<ApiTraceCall*>,quint64)),
+            this,
+            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(m_loader,
+            SIGNAL(searchResult(ApiTrace::SearchResult,ApiTraceCall*)),
+            this,
+            SLOT(loaderSearchResult(ApiTrace::SearchResult,ApiTraceCall*)));
+
 
     connect(m_loader, SIGNAL(startedParsing()),
             this, SIGNAL(startedLoadingTrace()));
@@ -94,11 +111,6 @@ QVector<ApiTraceCall*> ApiTrace::calls() const
     return m_calls;
 }
 
-ApiTraceCall * ApiTrace::callAt(int idx) const
-{
-    return m_calls.value(idx);
-}
-
 int ApiTrace::numCalls() const
 {
     return m_calls.count();
@@ -302,9 +314,108 @@ bool ApiTrace::hasErrors() const
     return !m_errors.isEmpty();
 }
 
-void ApiTrace::fillFrame(int frameIdx, const QVector<ApiTraceCall *> &calls,
-                         quint64 binaryDataSize)
+void ApiTrace::loadFrame(ApiTraceFrame *frame)
+{
+    Q_ASSERT(!frame->loaded());
+    emit requestFrame(frame);
+}
+
+void ApiTrace::finishedParsing()
+{
+    ApiTraceFrame *firstFrame = m_frames[0];
+    if (firstFrame && !firstFrame->loaded()) {
+        loadFrame(firstFrame);
+    }
+}
+
+void ApiTrace::loaderFrameLoaded(ApiTraceFrame *frame,
+                                 const QVector<ApiTraceCall*> &calls,
+                                 quint64 binaryDataSize)
+{
+    Q_ASSERT(frame->numChildrenToLoad() == calls.size());
+    emit beginLoadingFrame(frame, calls.size());
+    frame->setCalls(calls, binaryDataSize);
+    emit endLoadingFrame(frame);
+}
+
+void ApiTrace::findNext(ApiTraceFrame *frame,
+                        ApiTraceCall *from,
+                        const QString &str,
+                        Qt::CaseSensitivity sensitivity)
+{
+    ApiTraceCall *foundCall = 0;
+    int frameIdx = m_frames.indexOf(frame);
+
+    if (frame->loaded()) {
+        foundCall = frame->findNextCall(from, str, sensitivity);
+        if (foundCall) {
+            emit findResult(SearchFound, foundCall);
+            return;
+        }
+
+        //if the frame is loaded we already searched it above
+        // so skip it
+        frameIdx += 1;
+    }
+
+    for (int i = frameIdx; i < m_frames.count(); ++i) {
+        ApiTraceFrame *frame = m_frames[i];
+        if (!frame->loaded()) {
+            emit loaderSearchNext(i, str, sensitivity);
+            return;
+        } else {
+            ApiTraceCall *call = frame->findNextCall(0, str, sensitivity);
+            if (call) {
+                emit findResult(SearchFound, call);
+                return;
+            }
+        }
+    }
+    emit findResult(SearchWrapped, 0);
+}
+
+void ApiTrace::findPrev(ApiTraceFrame *frame,
+                        ApiTraceCall *from,
+                        const QString &str,
+                        Qt::CaseSensitivity sensitivity)
+{
+    ApiTraceCall *foundCall = 0;
+    int frameIdx = m_frames.indexOf(frame);
+
+    if (frame->loaded()) {
+        foundCall = frame->findPrevCall(from, str, sensitivity);
+        if (foundCall) {
+            emit findResult(SearchFound, foundCall);
+            return;
+        }
+
+        //if the frame is loaded we already searched it above
+        // so skip it
+        frameIdx -= 1;
+    }
+
+    for (int i = frameIdx; i >= 0; --i) {
+        ApiTraceFrame *frame = m_frames[i];
+        if (!frame->loaded()) {
+            emit loaderSearchPrev(i, str, sensitivity);
+            return;
+        } else {
+            ApiTraceCall *call = frame->findPrevCall(0, str, sensitivity);
+            if (call) {
+                emit findResult(SearchFound, call);
+                return;
+            }
+        }
+    }
+    emit findResult(SearchWrapped, 0);
+}
+
+void ApiTrace::loaderSearchResult(ApiTrace::SearchResult result,
+                                  ApiTraceCall *call)
 {
+    //qDebug()<<"Search result = "<<result
+    //       <<", call is = "<<call;
+    emit findResult(result, call);
 }
 
 #include "apitrace.moc"