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;
@@ -212,6 +217,17 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                 }
             });
 
+        _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);
+                }
+            });
+
         UpdateSettings(settings, unfocusedAppearance);
     }
 
@@ -1259,6 +1275,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);
@@ -1457,33 +1478,215 @@ 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 };
+            _updateSearchStatus->Run(searchState);
+        }
+        else
+        {
+            _SelectSearchResult(goForward);
+        }
+    }
 
-        const auto sensitivity = caseSensitive ?
-                                     Search::Sensitivity::CaseSensitive :
-                                     Search::Sensitivity::CaseInsensitive;
+    // 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 };
+        _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();
 
-        ::Search search(*GetRenderData(), text.c_str(), direction, sensitivity);
+            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();
+                }
+            }
+
+            // 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);
+        }
+    }
+
+    // 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())
+        {
+            return til::at(matches.value(), currentMatchIndex);
+        }
+        else
         {
-            _terminal->SetBlockSelection(false);
-            search.Select();
+            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()
@@ -1680,6 +1883,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
             // Start the throttled update of where our hyperlinks are.
             (*_updatePatternLocations)();
+
+            _bufferChangedSinceSearch = true;
         }
         catch (...)
         {

src/cascadia/TerminalControl/ControlCore.h

@@ -50,6 +50,31 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         WINRT_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:
@@ -85,6 +110,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);
@@ -181,6 +207,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,
@@ -278,10 +307,14 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         uint64_t _owningHwnd{ 0 };
 
+        std::optional<SearchState> _searchState;
+        bool _bufferChangedSinceSearch{ true };
+
         winrt::Windows::System::DispatcherQueue _dispatcher{ nullptr };
         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;
 
         bool _setFontSizeUnderLock(float fontSize);
         void _updateFont(const bool initialUpdate = false);
@@ -326,6 +359,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);
+
         inline bool _IsClosing() const noexcept
         {
 #ifndef NDEBUG

src/cascadia/TerminalControl/ControlCore.idl

@@ -115,7 +115,13 @@ namespace Microsoft.Terminal.Control
         Microsoft.Terminal.Core.Point CursorPosition { get; };
         void ResumeRendering();
         void BlinkAttributeTick();
+
         void Search(String text, Boolean goForward, Boolean caseSensitive);
+        void SearchChanged(String text, Boolean goForward, Boolean caseSensitive);
+        void ExitSearch();
+        IVector<Int32> MatchRows { get; };
+
+        Microsoft.Terminal.Core.Color ForegroundColor { get; };
         Microsoft.Terminal.Core.Color BackgroundColor { get; };
 
         Boolean HasSelection { get; };

src/cascadia/TerminalControl/EventArgs.h

@@ -146,6 +146,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         }
 
         WINRT_PROPERTY(bool, FoundMatch);
+        WINRT_PROPERTY(int32_t, TotalMatches);
+        WINRT_PROPERTY(int32_t, CurrentMatch);
     };
 
     struct ShowWindowArgs : public ShowWindowArgsT<ShowWindowArgs>

src/cascadia/TerminalControl/EventArgs.idl

@@ -72,6 +72,8 @@ namespace Microsoft.Terminal.Control
     runtimeclass FoundResultsArgs
     {
         Boolean FoundMatch { get; };
+        Int32 TotalMatches { get; };
+        Int32 CurrentMatch { get; };
     }
 
     runtimeclass ShowWindowArgs