Show number of search results & positions of hits in scrollbar

src/cascadia/TerminalControl/ControlCore.cpp

@@ -39,8 +39,13 @@ constexpr const auto TsfRedrawInterval = std::chrono::milliseconds(100);
 // The minimum delay between updating the locations of regex patterns
 constexpr const auto UpdatePatternLocationsInterval = std::chrono::milliseconds(500);
 
+// The delay before performing the search after change of search criteria
+constexpr const auto SearchAfterChangeDelay = std::chrono::milliseconds(200);
+
 namespace winrt::Microsoft::Terminal::Control::implementation
 {
+    std::atomic<size_t> SearchState::_searchIdGenerator{ 0 };
+
     static winrt::Microsoft::Terminal::Core::OptionalColor OptionalFromColor(const til::color& c)
     {
         Core::OptionalColor result;
@@ -205,6 +210,17 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                     core->_ScrollPositionChangedHandlers(*core, update);
                 }
             });
+
+        shared->updateSearchStatus = std::make_shared<ThrottledFuncTrailing<SearchState>>(
+            _dispatcher,
+            SearchAfterChangeDelay,
+            [weakThis = get_weak()](const auto& update) {
+                if (auto core{ weakThis.get() })
+                {
+                    core->_searchState.emplace(update);
+                    core->_SearchAsync(std::nullopt);
+                }
+            });
     }
 
     ControlCore::~ControlCore()
@@ -1344,6 +1360,11 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                                        nullptr;
     }
 
+    til::color ControlCore::ForegroundColor() const
+    {
+        return _terminal->GetRenderSettings().GetColorAlias(ColorAlias::DefaultForeground);
+    }
+
     til::color ControlCore::BackgroundColor() const
     {
         return _terminal->GetRenderSettings().GetColorAlias(ColorAlias::DefaultBackground);
@@ -1447,10 +1468,11 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                                                             viewHeight,
                                                             bufferSize) };
 
-        if (_inUnitTests) [[unlikely]]
-        {
-            _ScrollPositionChangedHandlers(*this, update);
-        }
+        if (_inUnitTests)
+            [[unlikely]]
+            {
+                _ScrollPositionChangedHandlers(*this, update);
+            }
         else
         {
             const auto shared = _shared.lock_shared();
@@ -1545,33 +1567,227 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             return;
         }
 
-        const auto direction = goForward ?
-                                   Search::Direction::Forward :
-                                   Search::Direction::Backward;
+        if (_bufferChangedSinceSearch)
+        {
+            const auto sensitivity = caseSensitive ? Search::Sensitivity::CaseSensitive : Search::Sensitivity::CaseInsensitive;
+            const SearchState searchState{ text, sensitivity, goForward };
+
+            const auto shared = _shared.lock_shared();
+            if (shared->updateSearchStatus)
+            {
+                shared->updateSearchStatus->Run(searchState);
+            }
+        }
+        else
+        {
+            _SelectSearchResult(goForward);
+        }
+    }
+
+    // Method Description:
+    // - Search text in text buffer.
+    // This is triggered when the user starts typing, clicks on navigation or
+    // when the search is active and the terminal text is changing
+    // Arguments:
+    // - goForward: optional boolean that represents if the current search direction is forward
+    // - delay: time in milliseconds to wait before performing the search
+    // (grace time to allow next search to start)
+    // Return Value:
+    // - <none>
+    fire_and_forget ControlCore::_SearchAsync(std::optional<bool> goForward)
+    {
+        // Run only if the search state was initialized
+        if (_closing || !_searchState.has_value())
+        {
+            co_return;
+        }
+
+        const auto originalSearchId = _searchState->searchId;
+        auto weakThis{ get_weak() };
+
+        // If no matches were computed it means we need to perform the search
+        if (!_searchState->matches.has_value())
+        {
+            std::vector<std::pair<til::point, til::point>> matches;
+            if (!_searchState->text.empty())
+            {
+                // Collect up all the matches on a BG thread.
+                co_await winrt::resume_background();
+
+                // We perform explicit search forward, so the first result will also be the earliest buffer location
+                // We will use goForward later to decide if we need to select 1 of n or n of n.
+                ::Search search(*GetRenderData(),
+                                _searchState->text.c_str(),
+                                Search::Direction::Forward,
+                                _searchState->sensitivity);
+
+                while (_SearchOne(search))
+                {
+                    // if search box was collapsed or the new one search was triggered - let's cancel this one
+                    if (!_searchState.has_value() ||
+                        _searchState->searchId != originalSearchId)
+                    {
+                        co_return;
+                    }
+
+                    matches.push_back(search.GetFoundLocation());
+                }
+
+                // if search box was collapsed or the new one search was triggered - let's cancel this one
+                if (!_searchState.has_value() ||
+                    _searchState->searchId != originalSearchId)
+                {
+                    co_return;
+                }
+            }
+            _searchState->matches.emplace(std::move(matches));
+            _bufferChangedSinceSearch = false;
+        }
+        if (auto core{ weakThis.get() })
+        {
+            _SelectSearchResult(_searchState->goForward);
+        }
+    }
+
+    void ControlCore::SearchChanged(const winrt::hstring& text,
+                                    const bool goForward,
+                                    const bool caseSensitive)
+    {
+        // Clear the selection reset the anchor
+        _terminal->ClearSelection();
+        _renderer->TriggerSelection();
+
+        const auto sensitivity = caseSensitive ? Search::Sensitivity::CaseSensitive : Search::Sensitivity::CaseInsensitive;
+
+        const SearchState searchState{ text, sensitivity, goForward };
+
+        {
+            const auto shared = _shared.lock_shared();
+            if (shared->updateSearchStatus)
+            {
+                shared->updateSearchStatus->Run(searchState);
+            }
+        }
+    }
+
+    // Method Description:
+    // - Selects one of precomputed search results in the terminal (if exist).
+    // - Updates the search box control accordingly.
+    // - The selection might be preceded by going to next / previous result
+    // - goForward: if true, select next result; if false, select previous result;
+    // if not set, remain at the current result.
+    // Return Value:
+    // - <none>
+    void ControlCore::_SelectSearchResult(std::optional<bool> goForward)
+    {
+        if (_searchState.has_value() && _searchState->matches.has_value())
+        {
+            auto& state = _searchState.value();
+            auto& matches = state.matches.value();
+
+            if (goForward.has_value())
+            {
+                state.UpdateIndex(goForward.value());
+
+                const auto currentMatch = state.GetCurrentMatch();
+                if (currentMatch.has_value())
+                {
+                    auto lock = _terminal->LockForWriting();
+                    _terminal->SetBlockSelection(false);
+                    _terminal->SelectNewRegion(currentMatch->first, currentMatch->second);
+                    _renderer->TriggerSelection();
+                }
+            }
 
-        const auto sensitivity = caseSensitive ?
-                                     Search::Sensitivity::CaseSensitive :
-                                     Search::Sensitivity::CaseInsensitive;
+            // Let the control know we got one
+            auto foundResults = winrt::make_self<implementation::FoundResultsArgs>(true);
+            foundResults->TotalMatches(gsl::narrow<int32_t>(matches.size()));
+            foundResults->CurrentMatch(state.currentMatchIndex);
+            _FoundMatchHandlers(*this, *foundResults);
+        }
+    }
 
-        ::Search search(*GetRenderData(), text.c_str(), direction, sensitivity);
+    // Method Description:
+    // - Search for a single value. Takes the lock for the duration of the search.
+    // Arguments:
+    // - search: search object to use to find the next match.
+    // Return Value:
+    // - <none>
+    bool ControlCore::_SearchOne(::Search& search)
+    {
+        // We don't lock the terminal for the duration of the entire search,
+        // since if the terminal was modified the search ID will be updated.
         auto lock = _terminal->LockForWriting();
-        const auto foundMatch{ search.FindNext() };
-        if (foundMatch)
+        return search.FindNext();
+    }
+
+    // Method Description:
+    // - Updates the index of the current match according to the direction.
+    // The index will remain unchanged (usually -1) if the number of matches is 0
+    // Arguments:
+    // - goForward: if true, move to the next match, else go to previous
+    // Return Value:
+    // - <none>
+    void SearchState::UpdateIndex(bool goForward)
+    {
+        if (matches.has_value())
+        {
+            const int numMatches = ::base::saturated_cast<int>(matches->size());
+            if (numMatches > 0)
+            {
+                if (currentMatchIndex == -1)
+                {
+                    currentMatchIndex = goForward ? 0 : numMatches - 1;
+                }
+                else
+                {
+                    currentMatchIndex = (numMatches + currentMatchIndex + (goForward ? 1 : -1)) % numMatches;
+                }
+            }
+        }
+    }
+
+    // Method Description:
+    // - Retrieves the current match
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - current match, null-opt if current match is invalid
+    // (e.g., when the index is -1 or there are no matches)
+    std::optional<std::pair<til::point, til::point>> SearchState::GetCurrentMatch()
+    {
+        if (matches.has_value() &&
+            currentMatchIndex > -1 &&
+            static_cast<size_t>(currentMatchIndex) < matches->size())
         {
-            _terminal->SetBlockSelection(false);
-            search.Select();
+            return til::at(matches.value(), currentMatchIndex);
+        }
+        else
+        {
+            return std::nullopt;
+        }
+    }
+    void ControlCore::ExitSearch()
+    {
+        _searchState.reset();
+    }
 
-            // this is used for search,
-            // DO NOT call _updateSelectionUI() here.
-            // We don't want to show the markers so manually tell it to clear it.
-            _renderer->TriggerSelection();
-            _UpdateSelectionMarkersHandlers(*this, winrt::make<implementation::UpdateSelectionMarkersEventArgs>(true));
+    Windows::Foundation::Collections::IVector<int32_t> ControlCore::MatchRows()
+    {
+        auto results = winrt::single_threaded_vector<int32_t>();
+        if (_bufferChangedSinceSearch)
+        {
+            return results;
         }
 
-        // Raise a FoundMatch event, which the control will use to notify
-        // narrator if there was any results in the buffer
-        auto foundResults = winrt::make_self<implementation::FoundResultsArgs>(foundMatch);
-        _FoundMatchHandlers(*this, *foundResults);
+        if (_searchState.has_value() && _searchState->matches.has_value())
+        {
+            for (auto&& [start, end] : *(_searchState->matches))
+            {
+                results.Append(start.y);
+            }
+        }
+        return results;
     }
 
     void ControlCore::Close()
@@ -1801,10 +2017,12 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             _terminal->Write(hstr);
 
             // Start the throttled update of where our hyperlinks are.
+
             const auto shared = _shared.lock_shared();
             if (shared->updatePatternLocations)
             {
                 (*shared->updatePatternLocations)();
+                _bufferChangedSinceSearch = true;
             }
         }
         catch (...)

src/cascadia/TerminalControl/ControlCore.h

@@ -54,6 +54,31 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         til::property<bool> IsIndex16;
     };
 
+    struct SearchState
+    {
+    public:
+        static std::atomic<size_t> _searchIdGenerator;
+
+        SearchState(const winrt::hstring& text, const Search::Sensitivity sensitivity, const bool forward) :
+            text(text),
+            sensitivity(sensitivity),
+            goForward(forward),
+            searchId(_searchIdGenerator.fetch_add(1))
+        {
+        }
+
+        std::optional<std::vector<std::pair<til::point, til::point>>> matches;
+
+        void UpdateIndex(bool goForward);
+        std::optional<std::pair<til::point, til::point>> GetCurrentMatch();
+
+        winrt::hstring text;
+        Search::Sensitivity sensitivity;
+        bool goForward{ true };
+        size_t searchId;
+        int32_t currentMatchIndex{ -1 };
+    };
+
     struct ControlCore : ControlCoreT<ControlCore>
     {
     public:
@@ -95,6 +120,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         winrt::hstring FontFaceName() const noexcept;
         uint16_t FontWeight() const noexcept;
 
+        til::color ForegroundColor() const;
         til::color BackgroundColor() const;
 
         void SendInput(const winrt::hstring& wstr);
@@ -197,6 +223,9 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         void Search(const winrt::hstring& text,
                     const bool goForward,
                     const bool caseSensitive);
+        void SearchChanged(const winrt::hstring& text, const bool goForward, const bool caseSensitive);
+        void ExitSearch();
+        Windows::Foundation::Collections::IVector<int32_t> MatchRows();
 
         void LeftClickOnTerminal(const til::point terminalPosition,
                                  const int numberOfClicks,
@@ -270,6 +299,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             std::shared_ptr<ThrottledFuncTrailing<>> tsfTryRedrawCanvas;
             std::unique_ptr<til::throttled_func_trailing<>> updatePatternLocations;
             std::shared_ptr<ThrottledFuncTrailing<Control::ScrollPositionChangedArgs>> updateScrollBar;
+            std::shared_ptr<ThrottledFuncTrailing<SearchState>> updateSearchStatus;
         };
 
         std::atomic<bool> _initializedTerminal{ false };
@@ -318,6 +348,9 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         uint64_t _owningHwnd{ 0 };
 
+        std::optional<SearchState> _searchState;
+        bool _bufferChangedSinceSearch{ true };
+
         winrt::Windows::System::DispatcherQueue _dispatcher{ nullptr };
         til::shared_mutex<SharedState> _shared;
 
@@ -368,6 +401,10 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         bool _isBackgroundTransparent();
         void _focusChanged(bool focused);
 
+        fire_and_forget _SearchAsync(std::optional<bool> goForward);
+        void _SelectSearchResult(std::optional<bool> goForward);
+        bool _SearchOne(::Search& search);
+
         void _selectSpan(til::point_span s);
 
         void _contextMenuSelectMark(