moar progress! (useTransitions -> crash!)

Author: carlos-zamora

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -1670,6 +1670,8 @@ namespace winrt::TerminalApp::implementation
 
         term.ShowWindowChanged({ get_weak(), &TerminalPage::_ShowWindowChangedHandler });
 
+        term.SearchMissingCommand({ get_weak(), &TerminalPage::_SearchMissingCommandHandler });
+
         // Don't even register for the event if the feature is compiled off.
         if constexpr (Feature_ShellCompletions::IsEnabled())
         {
@@ -1688,6 +1690,12 @@ namespace winrt::TerminalApp::implementation
                 page->_PopulateContextMenu(weakTerm.get(), sender.try_as<MUX::Controls::CommandBarFlyout>(), true);
             }
         });
+        term.QuickFixMenu().Opening([weak = get_weak(), weakTerm](auto&& sender, auto&& /*args*/) {
+            if (const auto& page{ weak.get() })
+            {
+                page->_PopulateQuickFixMenu(weakTerm.get(), sender.try_as<Controls::MenuFlyout>());
+            }
+        });
     }
 
     // Method Description:
@@ -2889,6 +2897,180 @@ namespace winrt::TerminalApp::implementation
         ShowWindowChanged.raise(*this, args);
     }
 
+    winrt::fire_and_forget TerminalPage::_SearchMissingCommandHandler(const IInspectable /*sender*/, const Microsoft::Terminal::Control::SearchMissingCommandEventArgs args)
+    {
+        assert(!Dispatcher().HasThreadAccess());
+
+#if 0
+        static constexpr CLSID CLSID_PackageManager = { 0xC53A4F16, 0x787E, 0x42A4, 0xB3, 0x04, 0x29, 0xEF, 0xFB, 0x4B, 0xF5, 0x97 }; //C53A4F16-787E-42A4-B304-29EFFB4BF597
+        static constexpr CLSID CLSID_FindPackagesOptions = { 0x572DED96, 0x9C60, 0x4526, { 0x8F, 0x92, 0xEE, 0x7D, 0x91, 0xD3, 0x8C, 0x1A } }; //572DED96-9C60-4526-8F92-EE7D91D38C1A
+        static constexpr CLSID CLSID_PackageMatchFilter = { 0xD02C9DAF, 0x99DC, 0x429C, { 0xB5, 0x03, 0x4E, 0x50, 0x4E, 0x4A, 0xB0, 0x00 } }; //D02C9DAF-99DC-429C-B503-4E504E4AB000
+
+        static constexpr unsigned int maxSuggestions = 5;
+        bool tooManySuggestions = false;
+
+        // TODO CARLOS: this is where we fail! "Class not registered" error
+        PackageManager pkgManager = winrt::create_instance<PackageManager>(CLSID_PackageManager, CLSCTX_ALL);
+        auto catalogRef = pkgManager.GetPredefinedPackageCatalog(PredefinedPackageCatalog::OpenWindowsCatalog);
+        auto connectResult = catalogRef.Connect();
+        int retryCount = 0;
+        while (connectResult.Status() != ConnectResultStatus::Ok && retryCount < 3)
+        {
+            connectResult = catalogRef.Connect();
+            ++retryCount;
+        }
+        if (connectResult.Status() != ConnectResultStatus::Ok)
+        {
+            return;
+        }
+        auto catalog = connectResult.PackageCatalog();
+
+        // Perform the query (search by command)
+        auto packageMatchFilter = winrt::create_instance<PackageMatchFilter>(CLSID_PackageMatchFilter, CLSCTX_ALL);
+        auto findPackagesOptions = winrt::create_instance<FindPackagesOptions>(CLSID_FindPackagesOptions, CLSCTX_ALL);
+
+        // Helper lambda to apply a filter to the query
+        auto applyPackageMatchFilter = [&packageMatchFilter, &findPackagesOptions](PackageMatchField field, PackageFieldMatchOption matchOption, hstring query) {
+            // Configure filter
+            packageMatchFilter.Field(field);
+            packageMatchFilter.Option(matchOption);
+            packageMatchFilter.Value(query);
+
+            // Apply filter
+            findPackagesOptions.ResultLimit(maxSuggestions + 1u);
+            findPackagesOptions.Filters().Clear();
+            findPackagesOptions.Filters().Append(packageMatchFilter);
+        };
+
+        // Helper lambda to retrieve the best matching package(s) from the query's result
+        auto tryGetBestMatchingPackage = [&tooManySuggestions](IVectorView<MatchResult> matches) {
+            std::vector<CatalogPackage> results;
+            results.reserve(std::min(matches.Size(), maxSuggestions));
+            if (matches.Size() == 1)
+            {
+                // One match --> return the package
+                results.emplace_back(matches.GetAt(0).CatalogPackage());
+            }
+            else if (matches.Size() > 1)
+            {
+                // Multiple matches --> display top 5 matches (prioritize best matches first)
+                std::queue<CatalogPackage> bestExactMatches, secondaryMatches, tertiaryMatches;
+                for (auto match : matches)
+                {
+                    switch (match.MatchCriteria().Option())
+                    {
+                    case PackageFieldMatchOption::EqualsCaseInsensitive:
+                    case PackageFieldMatchOption::Equals:
+                        bestExactMatches.push(match.CatalogPackage());
+                        break;
+                    case PackageFieldMatchOption::StartsWithCaseInsensitive:
+                        secondaryMatches.push(match.CatalogPackage());
+                        break;
+                    case PackageFieldMatchOption::ContainsCaseInsensitive:
+                        tertiaryMatches.push(match.CatalogPackage());
+                        break;
+                    }
+                }
+
+                // Now return the top maxSuggestions
+                while (results.size() < maxSuggestions)
+                {
+                    if (bestExactMatches.size() > 0)
+                    {
+                        results.emplace_back(bestExactMatches.front());
+                        bestExactMatches.pop();
+                    }
+                    else if (secondaryMatches.size() > 0)
+                    {
+                        results.emplace_back(secondaryMatches.front());
+                        secondaryMatches.pop();
+                    }
+                    else if (tertiaryMatches.size() > 0)
+                    {
+                        results.emplace_back(tertiaryMatches.front());
+                        tertiaryMatches.pop();
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+            }
+            tooManySuggestions = matches.Size() > maxSuggestions;
+            return results;
+        };
+
+        // Search by command
+        auto missingCmd = args.MissingCommand();
+        std::wstring searchOption = L"command";
+        applyPackageMatchFilter(PackageMatchField::Command, PackageFieldMatchOption::StartsWithCaseInsensitive, missingCmd);
+        auto findPackagesResult = catalog.FindPackages(findPackagesOptions);
+        auto matches = findPackagesResult.Matches();
+        auto pkgList = tryGetBestMatchingPackage(matches);
+        if (pkgList.empty())
+        {
+            // No matches found --> search by name
+            applyPackageMatchFilter(PackageMatchField::Name, PackageFieldMatchOption::ContainsCaseInsensitive, missingCmd);
+
+            findPackagesResult = catalog.FindPackages(findPackagesOptions);
+            matches = findPackagesResult.Matches();
+            pkgList = tryGetBestMatchingPackage(matches);
+            searchOption = L"name";
+
+            if (pkgList.empty())
+            {
+                // No matches found --> search by moniker
+                applyPackageMatchFilter(PackageMatchField::Moniker, PackageFieldMatchOption::ContainsCaseInsensitive, missingCmd);
+
+                // Perform the query (search by name)
+                findPackagesResult = catalog.FindPackages(findPackagesOptions);
+                matches = findPackagesResult.Matches();
+                pkgList = tryGetBestMatchingPackage(matches);
+                searchOption = L"moniker";
+            }
+        }
+
+        // Display packages in UI
+        if (!pkgList.empty())
+        {
+            std::vector<std::wstring> suggestions;
+            suggestions.reserve(pkgList.size());
+            for (auto pkg : pkgList)
+            {
+                suggestions.emplace_back(fmt::format(L"winget install --id {}", pkg.Id()));
+            }
+
+            std::wstring footer = tooManySuggestions ?
+                                      fmt::format(L"winget search --{} {}", searchOption, missingCmd) :
+                                      L"";
+
+            // TODO CARLOS: no more info bar; replace!
+            //ShowCommandNotFoundInfoBar(suggestions, footer);
+        }
+#elif defined(DEBUG) || defined(_DEBUG) || defined(DBG)
+        //const bool tooManySuggestions = false;
+        //const std::wstring searchOption = L"command";
+        //const std::wstring missingCmd = args.MissingCommand().data();
+        std::vector<std::wstring> pkgList = { L"pkg1", L"pkg2", L"pkg3" };
+        std::vector<hstring> suggestions;
+        suggestions.reserve(pkgList.size());
+        for (auto pkg : pkgList)
+        {
+            suggestions.emplace_back(fmt::format(L"winget install --id {}", pkg));
+        }
+
+        co_await wil::resume_foreground(Dispatcher());
+
+        auto term = _GetActiveControl();
+        if (!term)
+        {
+            co_return;
+        }
+        term.UpdateWinGetSuggestions(single_threaded_vector<hstring>(std::move(suggestions)));
+        term.ShowQuickFixMenu();
+#endif
+    }
+
     // Method Description:
     // - Paste text from the Windows Clipboard to the focused terminal
     void TerminalPage::_PasteText()
@@ -4806,6 +4988,58 @@ namespace winrt::TerminalApp::implementation
         makeItem(RS_(L"TabClose"), L"\xE711", ActionAndArgs{ ShortcutAction::CloseTab, CloseTabArgs{ _GetFocusedTabIndex().value() } });
     }
 
+    void TerminalPage::_PopulateQuickFixMenu(const TermControl& control,
+                                             const Controls::MenuFlyout& menu)
+    {
+        if (!control || !menu)
+        {
+            return;
+        }
+
+        // Helper lambda for dispatching an ActionAndArgs onto the
+        // ShortcutActionDispatch. Used below to wire up each menu entry to the
+        // respective action.
+
+        auto weak = get_weak();
+        auto makeCallback = [weak](const ActionAndArgs& actionAndArgs) {
+            return [weak, actionAndArgs](auto&&, auto&&) {
+                if (auto page{ weak.get() })
+                {
+                    page->_actionDispatch->DoAction(actionAndArgs);
+                }
+            };
+        };
+
+        auto makeItem = [&menu, &makeCallback](const winrt::hstring& label,
+                                               const winrt::hstring& icon,
+                                               const winrt::hstring& suggestion) {
+            MenuFlyoutItem item{};
+
+            if (!icon.empty())
+            {
+                auto iconElement = UI::IconPathConverter::IconWUX(icon);
+                Automation::AutomationProperties::SetAccessibilityView(iconElement, Automation::Peers::AccessibilityView::Raw);
+                item.Icon(iconElement);
+            }
+
+            item.Text(label);
+            item.Click(makeCallback(ActionAndArgs{ ShortcutAction::SendInput, SendInputArgs{ hstring{ L"\u0003" } + suggestion } }));
+            menu.Items().Append(item);
+        };
+
+        // Wire up each item to the action that should be performed. By actually
+        // connecting these to actions, we ensure the implementation is
+        // consistent. This also leaves room for customizing this menu with
+        // actions in the future.
+
+        menu.Items().Clear();
+        const auto quickFixes = control.CommandHistory().QuickFixes();
+        for (const auto& qf : quickFixes)
+        {
+            makeItem(qf, L"\ue74c", qf);
+        }
+    }
+
     // Handler for our WindowProperties's PropertyChanged event. We'll use this
     // to pop the "Identify Window" toast when the user renames our window.
     winrt::fire_and_forget TerminalPage::_windowPropertyChanged(const IInspectable& /*sender*/,

src/cascadia/TerminalApp/TerminalPage.h

@@ -510,6 +510,7 @@ namespace winrt::TerminalApp::implementation
         void _OpenSuggestions(const Microsoft::Terminal::Control::TermControl& sender, Windows::Foundation::Collections::IVector<winrt::Microsoft::Terminal::Settings::Model::Command> commandsCollection, winrt::TerminalApp::SuggestionsMode mode, winrt::hstring filterText);
 
         void _ShowWindowChangedHandler(const IInspectable sender, const winrt::Microsoft::Terminal::Control::ShowWindowArgs args);
+        winrt::fire_and_forget _SearchMissingCommandHandler(const IInspectable sender, const winrt::Microsoft::Terminal::Control::SearchMissingCommandEventArgs args);
 
         winrt::fire_and_forget _windowPropertyChanged(const IInspectable& sender, const winrt::Windows::UI::Xaml::Data::PropertyChangedEventArgs& args);
 
@@ -527,6 +528,7 @@ namespace winrt::TerminalApp::implementation
         void _sendDraggedTabToWindow(const winrt::hstring& windowId, const uint32_t tabIndex, std::optional<til::point> dragPoint);
 
         void _PopulateContextMenu(const Microsoft::Terminal::Control::TermControl& control, const Microsoft::UI::Xaml::Controls::CommandBarFlyout& sender, const bool withSelection);
+        void _PopulateQuickFixMenu(const Microsoft::Terminal::Control::TermControl& control, const Windows::UI::Xaml::Controls::MenuFlyout& sender);
         winrt::Windows::UI::Xaml::Controls::MenuFlyout _CreateRunAsAdminFlyout(int profileIndex);
 
         winrt::Microsoft::Terminal::Control::TermControl _senderOrActiveControl(const winrt::Windows::Foundation::IInspectable& sender);