Skip over filtered calls when searching.

diff --git a/gui/apitrace.cpp b/gui/apitrace.cpp
index edf98b9eb85e33985c1fb9be53151e67db2f6d51..023a094a93f2e2867117d3861153e1f4735b90c0 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*)),
@@ -320,11 +318,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 +333,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 +359,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,28 +374,31 @@ 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)

diff --git a/gui/apitrace.h b/gui/apitrace.h
index b73acd6fd2d08c341b16dd8c168aa2c3db955246..d0a6be4356dc6aee5674a5973ffb85f8d7d2d278 100644 (file)
--- a/gui/apitrace.h
+++ b/gui/apitrace.h
@@ -25,6 +25,31 @@ public:
         SearchResult_Found,
         SearchResult_Wrapped
     };
+    struct SearchRequest {
+        enum Direction {
+            Next,
+            Prev
+        };
+        SearchRequest()
+            : direction(Next)
+        {}
+        SearchRequest(Direction dir,
+                      ApiTraceFrame *f,
+                      ApiTraceCall *call,
+                      QString str,
+                      Qt::CaseSensitivity caseSens)
+            : direction(dir),
+              frame(f),
+              from(call),
+              text(str),
+              cs(caseSens)
+        {}
+        Direction direction;
+        ApiTraceFrame *frame;
+        ApiTraceCall *from;
+        QString text;
+        Qt::CaseSensitivity cs;
+    };
 
     static bool isCallAFrameMarker(const ApiTraceCall *call,
                                    FrameMarker marker);
@@ -87,7 +112,8 @@ signals:
     void changed(ApiTraceCall *call);
     void startedSaving();
     void saved();
-    void findResult(ApiTrace::SearchResult result,
+    void findResult(const ApiTrace::SearchRequest &request,
+                    ApiTrace::SearchResult result,
                     ApiTraceCall *call);
 
     void beginAddingFrames(int oldCount, int numAdded);
@@ -99,12 +125,7 @@ signals:
     void foundCallIndex(ApiTraceCall *call);
 
 signals:
-    void loaderSearchNext(int startFrame,
-                          const QString &str,
-                          Qt::CaseSensitivity sensitivity);
-    void loaderSearchPrev(int startFrame,
-                          const QString &str,
-                          Qt::CaseSensitivity sensitivity);
+    void loaderSearch(const ApiTrace::SearchRequest &request);
     void loaderFindFrameStart(ApiTraceFrame *frame);
     void loaderFindFrameEnd(ApiTraceFrame *frame);
     void loaderFindCallIndex(int index);
@@ -116,7 +137,8 @@ private slots:
     void loaderFrameLoaded(ApiTraceFrame *frame,
                            const QVector<ApiTraceCall*> &calls,
                            quint64 binaryDataSize);
-    void loaderSearchResult(ApiTrace::SearchResult result,
+    void loaderSearchResult(const ApiTrace::SearchRequest &request,
+                            ApiTrace::SearchResult result,
                             ApiTraceCall *call);
 
 private:

diff --git a/gui/main.cpp b/gui/main.cpp
index 6043b750ded5a2b17d513f2e0e67e36e38b24843..3dc473e4fd099d283f752a97c58a4765173f62eb 100644 (file)
--- a/gui/main.cpp
+++ b/gui/main.cpp
@@ -11,7 +11,7 @@ Q_DECLARE_METATYPE(QList<ApiTraceFrame*>);
 Q_DECLARE_METATYPE(QVector<ApiTraceCall*>);
 Q_DECLARE_METATYPE(Qt::CaseSensitivity);
 Q_DECLARE_METATYPE(ApiTrace::SearchResult);
-
+Q_DECLARE_METATYPE(ApiTrace::SearchRequest);
 
 int main(int argc, char **argv)
 {
@@ -22,6 +22,7 @@ int main(int argc, char **argv)
     qRegisterMetaType<ApiTraceState>();
     qRegisterMetaType<Qt::CaseSensitivity>();
     qRegisterMetaType<ApiTrace::SearchResult>();
+    qRegisterMetaType<ApiTrace::SearchRequest>();
     MainWindow window;
 
     window.show();

diff --git a/gui/mainwindow.cpp b/gui/mainwindow.cpp
index 3ee8cc29aab6f68ce30e1c6eb121235b5e6c2cf1..28dd6281a92602bb8dd44521e8cc83b8ad789331 100644 (file)
--- a/gui/mainwindow.cpp
+++ b/gui/mainwindow.cpp
@@ -705,8 +705,8 @@ void MainWindow::initConnections()
             this, SLOT(slotSaved()));
     connect(m_trace, SIGNAL(changed(ApiTraceCall*)),
             this, SLOT(slotTraceChanged(ApiTraceCall*)));
-    connect(m_trace, SIGNAL(findResult(ApiTrace::SearchResult,ApiTraceCall*)),
-            this, SLOT(slotSearchResult(ApiTrace::SearchResult,ApiTraceCall*)));
+    connect(m_trace, SIGNAL(findResult(ApiTrace::SearchRequest,ApiTrace::SearchResult,ApiTraceCall*)),
+            this, SLOT(slotSearchResult(ApiTrace::SearchRequest,ApiTrace::SearchResult,ApiTraceCall*)));
     connect(m_trace, SIGNAL(foundFrameStart(ApiTraceFrame*)),
             this, SLOT(slotFoundFrameStart(ApiTraceFrame*)));
     connect(m_trace, SIGNAL(foundFrameEnd(ApiTraceFrame*)),
@@ -1093,7 +1093,8 @@ void MainWindow::loadProgess(int percent)
     m_progressBar->setValue(percent);
 }
 
-void MainWindow::slotSearchResult(ApiTrace::SearchResult result,
+void MainWindow::slotSearchResult(const ApiTrace::SearchRequest &request,
+                                  ApiTrace::SearchResult result,
                                   ApiTraceCall *call)
 {
     switch (result) {
@@ -1102,8 +1103,28 @@ void MainWindow::slotSearchResult(ApiTrace::SearchResult result,
         break;
     case ApiTrace::SearchResult_Found: {
         QModelIndex index = m_proxyModel->indexForCall(call);
-        m_ui.callView->setCurrentIndex(index);
-        m_searchWidget->setFound(true);
+
+        if (index.isValid()) {
+            m_ui.callView->setCurrentIndex(index);
+            m_searchWidget->setFound(true);
+        } else {
+            //call is filtered out, so continue searching but from the
+            // filtered call
+            if (!call) {
+                qDebug()<<"Error: search success with no call";
+                return;
+            }
+//            qDebug()<<"filtered! search from "<<call->searchText()
+//                   <<", call idx = "<<call->index();
+
+            if (request.direction == ApiTrace::SearchRequest::Next) {
+                m_trace->findNext(call->parentFrame(), call,
+                                  request.text, request.cs);
+            } else {
+                m_trace->findNext(call->parentFrame(), call,
+                                  request.text, request.cs);
+            }
+        }
     }
         break;
     case ApiTrace::SearchResult_Wrapped:

diff --git a/gui/mainwindow.h b/gui/mainwindow.h
index 0ae8ab78e9315c619aa99d843b32f27c873e0ea5..3fde4c60060b95ed609c3a05b482b481c96d3abf 100644 (file)
--- a/gui/mainwindow.h
+++ b/gui/mainwindow.h
@@ -73,7 +73,8 @@ private slots:
     void slotTraceChanged(ApiTraceCall *call);
     void slotRetraceErrors(const QList<ApiTraceError> &errors);
     void slotErrorSelected(QTreeWidgetItem *current);
-    void slotSearchResult(ApiTrace::SearchResult result,
+    void slotSearchResult(const ApiTrace::SearchRequest &request,
+                          ApiTrace::SearchResult result,
                           ApiTraceCall *call);
     void slotFoundFrameStart(ApiTraceFrame *frame);
     void slotFoundFrameEnd(ApiTraceFrame *frame);

diff --git a/gui/traceloader.cpp b/gui/traceloader.cpp
index cf9b37bb4f9485d292f854469e9daf3aa6733886..c6694a16df7892cd1ded6aa5ecd464c7049173c3 100644 (file)
--- a/gui/traceloader.cpp
+++ b/gui/traceloader.cpp
@@ -283,25 +283,25 @@ void TraceLoader::addEnumSignature(unsigned id, ApiTraceEnumSignature *signature
     m_enumSignatures[id] = signature;
 }
 
-void TraceLoader::searchNext(int startFrame,
-                             const QString &str,
-                             Qt::CaseSensitivity sensitivity)
+void TraceLoader::searchNext(const ApiTrace::SearchRequest &request)
 {
     Q_ASSERT(m_parser.supportsOffsets());
     if (m_parser.supportsOffsets()) {
+        int startFrame = m_createdFrames.indexOf(request.frame);
         const FrameBookmark &frameBookmark = m_frameBookmarks[startFrame];
         m_parser.setBookmark(frameBookmark.start);
         Trace::Call *call = 0;
         while ((call = m_parser.parse_call())) {
 
-            if (callContains(call, str, sensitivity)) {
+            if (callContains(call, request.text, request.cs)) {
                 unsigned frameIdx = callInFrame(call->no);
                 ApiTraceFrame *frame = m_createdFrames[frameIdx];
                 const QVector<ApiTraceCall*> calls =
                         fetchFrameContents(frame);
                 for (int i = 0; i < calls.count(); ++i) {
                     if (calls[i]->index() == call->no) {
-                        emit searchResult(ApiTrace::SearchResult_Found, calls[i]);
+                        emit searchResult(request, ApiTrace::SearchResult_Found,
+                                          calls[i]);
                         break;
                     }
                 }
@@ -312,15 +312,14 @@ void TraceLoader::searchNext(int startFrame,
             delete call;
         }
     }
-    emit searchResult(ApiTrace::SearchResult_NotFound, 0);
+    emit searchResult(request, ApiTrace::SearchResult_NotFound, 0);
 }
 
-void TraceLoader::searchPrev(int startFrame,
-                             const QString &str,
-                             Qt::CaseSensitivity sensitivity)
+void TraceLoader::searchPrev(const ApiTrace::SearchRequest &request)
 {
     Q_ASSERT(m_parser.supportsOffsets());
     if (m_parser.supportsOffsets()) {
+        int startFrame = m_createdFrames.indexOf(request.frame);
         Trace::Call *call = 0;
         QList<Trace::Call*> frameCalls;
         int frameIdx = startFrame;
@@ -337,7 +336,7 @@ void TraceLoader::searchPrev(int startFrame,
             if (numCallsToParse == 0) {
                 bool foundCall = searchCallsBackwards(frameCalls,
                                                       frameIdx,
-                                                      str, sensitivity);
+                                                      request);
 
                 qDeleteAll(frameCalls);
                 frameCalls.clear();
@@ -356,23 +355,24 @@ void TraceLoader::searchPrev(int startFrame,
             }
         }
     }
-    emit searchResult(ApiTrace::SearchResult_NotFound, 0);
+    emit searchResult(request, ApiTrace::SearchResult_NotFound, 0);
 }
 
 bool TraceLoader::searchCallsBackwards(const QList<Trace::Call*> &calls,
                                        int frameIdx,
-                                       const QString &str,
-                                       Qt::CaseSensitivity sensitivity)
+                                       const ApiTrace::SearchRequest &request)
 {
     for (int i = calls.count() - 1; i >= 0; --i) {
         Trace::Call *call = calls[i];
-        if (callContains(call, str, sensitivity)) {
+        if (callContains(call, request.text, request.cs)) {
             ApiTraceFrame *frame = m_createdFrames[frameIdx];
             const QVector<ApiTraceCall*> apiCalls =
                     fetchFrameContents(frame);
             for (int i = 0; i < apiCalls.count(); ++i) {
                 if (apiCalls[i]->index() == call->no) {
-                    emit searchResult(ApiTrace::SearchResult_Found, apiCalls[i]);
+                    emit searchResult(request,
+                                      ApiTrace::SearchResult_Found,
+                                      apiCalls[i]);
                     break;
                 }
             }
@@ -502,4 +502,13 @@ void TraceLoader::findCallIndex(int index)
     emit foundCallIndex(call);
 }
 
+void TraceLoader::search(const ApiTrace::SearchRequest &request)
+{
+    if (request.direction == ApiTrace::SearchRequest::Next) {
+        searchNext(request);
+    } else {
+        searchPrev(request);
+    }
+}
+
 #include "traceloader.moc"

diff --git a/gui/traceloader.h b/gui/traceloader.h
index e950b0914bf73b0e81671ec1db4d58cb561d7b40..b36cab8471efcd6408a31829ce52606505f79f57 100644 (file)
--- a/gui/traceloader.h
+++ b/gui/traceloader.h
@@ -28,15 +28,10 @@ public slots:
     void loadTrace(const QString &filename);
     void loadFrame(ApiTraceFrame *frame);
     void setFrameMarker(ApiTrace::FrameMarker marker);
-    void searchNext(int startFrame,
-                    const QString &str,
-                    Qt::CaseSensitivity sensitivity);
-    void searchPrev(int startFrame,
-                    const QString &str,
-                    Qt::CaseSensitivity sensitivity);
     void findFrameStart(ApiTraceFrame *frame);
     void findFrameEnd(ApiTraceFrame *frame);
     void findCallIndex(int index);
+    void search(const ApiTrace::SearchRequest &request);
 
 signals:
     void startedParsing();
@@ -48,7 +43,9 @@ signals:
                              const QVector<ApiTraceCall*> &calls,
                              quint64 binaryDataSize);
 
-    void searchResult(ApiTrace::SearchResult result, ApiTraceCall *call);
+    void searchResult(const ApiTrace::SearchRequest &request,
+                      ApiTrace::SearchResult result,
+                      ApiTraceCall *call);
     void foundFrameStart(ApiTraceFrame *frame);
     void foundFrameEnd(ApiTraceFrame *frame);
     void foundCallIndex(ApiTraceCall *call);
@@ -73,6 +70,9 @@ private:
     void scanTrace();
     void parseTrace();
 
+    void searchNext(const ApiTrace::SearchRequest &request);
+    void searchPrev(const ApiTrace::SearchRequest &request);
+
     int callInFrame(int callIdx) const;
     bool callContains(Trace::Call *call,
                       const QString &str,
@@ -80,8 +80,7 @@ private:
      QVector<ApiTraceCall*> fetchFrameContents(ApiTraceFrame *frame);
      bool searchCallsBackwards(const QList<Trace::Call*> &calls,
                                int frameIdx,
-                               const QString &str,
-                               Qt::CaseSensitivity sensitivity);
+                               const ApiTrace::SearchRequest &request);
 
 private:
     Trace::Parser m_parser;