Remove WinRT composition (inheritance) from PaletteItem

src/cascadia/LocalTests_TerminalApp/FilteredCommandTests.cpp

@@ -2,8 +2,8 @@
 // Licensed under the MIT license.
 
 #include "pch.h"
-#include "../TerminalApp/CommandLinePaletteItem.h"
 #include "../TerminalApp/CommandPalette.h"
+#include "../TerminalApp/BasePaletteItem.h"
 #include "CppWinrtTailored.h"
 
 using namespace Microsoft::Console;
@@ -15,6 +15,19 @@ using namespace winrt::Microsoft::Terminal::Control;
 
 namespace TerminalAppLocalTests
 {
+    struct StringPaletteItem : winrt::implements<StringPaletteItem, winrt::TerminalApp::IPaletteItem, winrt::Windows::UI::Xaml::Data::INotifyPropertyChanged>, winrt::TerminalApp::implementation::BasePaletteItem<StringPaletteItem, winrt::TerminalApp::PaletteItemType::CommandLine>
+    {
+        StringPaletteItem(std::wstring_view value) :
+            _value{ value } {}
+
+        winrt::hstring Name() { return _value; }
+        winrt::hstring KeyChordText() { return {}; }
+        winrt::hstring Icon() { return {}; }
+
+    private:
+        winrt::hstring _value;
+    };
+
     class FilteredCommandTests
     {
         BEGIN_TEST_CLASS(FilteredCommandTests)
@@ -40,7 +53,7 @@ namespace TerminalAppLocalTests
         auto result = RunOnUIThread([]() {
             const WEX::TestExecution::DisableVerifyExceptions disableExceptionsScope;
 
-            const auto paletteItem{ winrt::make<winrt::TerminalApp::implementation::CommandLinePaletteItem>(L"AAAAAABBBBBBCCC") };
+            const auto paletteItem{ winrt::make<StringPaletteItem>(L"AAAAAABBBBBBCCC") };
             const auto filteredCommand = winrt::make_self<winrt::TerminalApp::implementation::FilteredCommand>(paletteItem);
 
             {
@@ -112,7 +125,7 @@ namespace TerminalAppLocalTests
     void FilteredCommandTests::VerifyWeight()
     {
         auto result = RunOnUIThread([]() {
-            const auto paletteItem{ winrt::make<winrt::TerminalApp::implementation::CommandLinePaletteItem>(L"AAAAAABBBBBBCCC") };
+            const auto paletteItem{ winrt::make<StringPaletteItem>(L"AAAAAABBBBBBCCC") };
             const auto filteredCommand = winrt::make_self<winrt::TerminalApp::implementation::FilteredCommand>(paletteItem);
 
             const auto weigh = [&](const wchar_t* str) {
@@ -152,8 +165,8 @@ namespace TerminalAppLocalTests
     void FilteredCommandTests::VerifyCompare()
     {
         auto result = RunOnUIThread([]() {
-            const auto paletteItem{ winrt::make<winrt::TerminalApp::implementation::CommandLinePaletteItem>(L"AAAAAABBBBBBCCC") };
-            const auto paletteItem2{ winrt::make<winrt::TerminalApp::implementation::CommandLinePaletteItem>(L"BBBBBCCC") };
+            const auto paletteItem{ winrt::make<StringPaletteItem>(L"AAAAAABBBBBBCCC") };
+            const auto paletteItem2{ winrt::make<StringPaletteItem>(L"BBBBBCCC") };
             {
                 Log::Comment(L"Testing comparison of commands with no filter");
                 const auto filteredCommand = winrt::make_self<winrt::TerminalApp::implementation::FilteredCommand>(paletteItem);
@@ -192,8 +205,8 @@ namespace TerminalAppLocalTests
     void FilteredCommandTests::VerifyCompareIgnoreCase()
     {
         auto result = RunOnUIThread([]() {
-            const auto paletteItem{ winrt::make<winrt::TerminalApp::implementation::CommandLinePaletteItem>(L"a") };
-            const auto paletteItem2{ winrt::make<winrt::TerminalApp::implementation::CommandLinePaletteItem>(L"B") };
+            const auto paletteItem{ winrt::make<StringPaletteItem>(L"a") };
+            const auto paletteItem2{ winrt::make<StringPaletteItem>(L"B") };
             {
                 const auto filteredCommand = winrt::make_self<winrt::TerminalApp::implementation::FilteredCommand>(paletteItem);
                 const auto filteredCommand2 = winrt::make_self<winrt::TerminalApp::implementation::FilteredCommand>(paletteItem2);

src/cascadia/TerminalApp/BasePaletteItem.h

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#pragma once
+
+namespace winrt::TerminalApp::implementation
+{
+    template<typename T, winrt::TerminalApp::PaletteItemType Ty>
+    struct BasePaletteItem
+    {
+    public:
+        winrt::TerminalApp::PaletteItemType Type() { return Ty; }
+
+        Windows::UI::Xaml::Controls::IconElement ResolvedIcon()
+        {
+            const auto icon{ static_cast<T*>(this)->Icon() };
+            if (!_resolvedIcon && !icon.empty())
+            {
+                const auto resolvedIcon{ Microsoft::Terminal::UI::IconPathConverter::IconWUX(icon) };
+                resolvedIcon.Width(16);
+                resolvedIcon.Height(16);
+                _resolvedIcon = resolvedIcon;
+            }
+            return _resolvedIcon;
+        }
+
+        til::property_changed_event PropertyChanged;
+
+    protected:
+        void BaseRaisePropertyChanged(wil::zwstring_view property)
+        {
+            PropertyChanged.raise(*static_cast<T*>(this), winrt::Windows::UI::Xaml::Data::PropertyChangedEventArgs{ property });
+        }
+
+        void InvalidateResolvedIcon()
+        {
+            _resolvedIcon = nullptr;
+            BaseRaisePropertyChanged(L"ResolvedIcon");
+        }
+
+    private:
+        Windows::UI::Xaml::Controls::IconElement _resolvedIcon{ nullptr };
+    };
+}

src/cascadia/TerminalApp/CommandPalette.cpp

@@ -2,10 +2,8 @@
 // Licensed under the MIT license.
 
 #include "pch.h"
-#include "ActionPaletteItem.h"
-#include "TabPaletteItem.h"
-#include "CommandLinePaletteItem.h"
 #include "CommandPalette.h"
+#include "CommandPaletteItems.h"
 #include <LibraryResources.h>
 
 #include "CommandPalette.g.cpp"
@@ -233,9 +231,11 @@ namespace winrt::TerminalApp::implementation
         }
         else if (_currentMode == CommandPaletteMode::ActionMode && filteredCommand != nullptr)
         {
-            if (const auto actionPaletteItem{ filteredCommand.Item().try_as<winrt::TerminalApp::ActionPaletteItem>() })
+            const auto item{ filteredCommand.Item() };
+            if (item.Type() == PaletteItemType::Action)
             {
-                PreviewAction.raise(*this, actionPaletteItem.Command());
+                const auto actionPaletteItem{ winrt::get_self<ActionPaletteItem>(item) };
+                PreviewAction.raise(*this, actionPaletteItem->Command());
             }
         }
         else if (_currentMode == CommandPaletteMode::CommandlineMode)
@@ -555,10 +555,11 @@ namespace winrt::TerminalApp::implementation
             const auto enteredItem = listViewItem.Content();
             if (const auto filteredCommand{ enteredItem.try_as<winrt::TerminalApp::FilteredCommand>() })
             {
-                if (const auto actionPaletteItem{ filteredCommand.Item().try_as<winrt::TerminalApp::ActionPaletteItem>() })
+                const auto item{ filteredCommand.Item() };
+                if (item.Type() == PaletteItemType::Action)
                 {
-                    // immediately preview the hovered command
-                    PreviewAction.raise(*this, actionPaletteItem.Command());
+                    const auto actionPaletteItem{ winrt::get_self<ActionPaletteItem>(item) };
+                    PreviewAction.raise(*this, actionPaletteItem->Command());
                 }
             }
         }
@@ -589,9 +590,11 @@ namespace winrt::TerminalApp::implementation
                 {
                     if (_currentMode == CommandPaletteMode::ActionMode && filteredCommand)
                     {
-                        if (const auto actionPaletteItem{ filteredCommand.Item().try_as<winrt::TerminalApp::ActionPaletteItem>() })
+                        const auto item{ filteredCommand.Item() };
+                        if (item.Type() == PaletteItemType::Action)
                         {
-                            PreviewAction.raise(*this, actionPaletteItem.Command());
+                            const auto actionPaletteItem{ winrt::get_self<ActionPaletteItem>(item) };
+                            PreviewAction.raise(*this, actionPaletteItem->Command());
                         }
                     }
                 }
@@ -617,7 +620,7 @@ namespace winrt::TerminalApp::implementation
                     const auto selectedCommand = selectedList.GetAt(0);
                     if (const auto filteredCmd = selectedCommand.try_as<TerminalApp::FilteredCommand>())
                     {
-                        if (const auto paletteItem = filteredCmd.Item().try_as<TerminalApp::PaletteItem>())
+                        if (const auto paletteItem = filteredCmd.Item())
                         {
                             automationPeer.RaiseNotificationEvent(
                                 Automation::Peers::AutomationNotificationKind::ItemAdded,
@@ -652,10 +655,13 @@ namespace winrt::TerminalApp::implementation
         if (_nestedActionStack.Size() > 0)
         {
             const auto newPreviousAction{ _nestedActionStack.GetAt(_nestedActionStack.Size() - 1) };
-            const auto actionPaletteItem{ newPreviousAction.Item().try_as<winrt::TerminalApp::ActionPaletteItem>() };
-
-            ParentCommandName(actionPaletteItem.Command().Name());
-            _updateCurrentNestedCommands(actionPaletteItem.Command());
+            const auto item{ newPreviousAction.Item() };
+            if (item.Type() == PaletteItemType::Action)
+            {
+                const auto actionPaletteItem{ winrt::get_self<ActionPaletteItem>(item) };
+                ParentCommandName(actionPaletteItem->Command().Name());
+                _updateCurrentNestedCommands(actionPaletteItem->Command());
+            }
         }
         else
         {
@@ -757,16 +763,19 @@ namespace winrt::TerminalApp::implementation
         }
         else if (filteredCommand)
         {
-            if (const auto actionPaletteItem{ filteredCommand.Item().try_as<winrt::TerminalApp::ActionPaletteItem>() })
+            auto item{ filteredCommand.Item() };
+            if (item.Type() == PaletteItemType::Action)
             {
-                if (actionPaletteItem.Command().HasNestedCommands())
+                const auto actionPaletteItem{ winrt::get_self<ActionPaletteItem>(item) };
+                auto command{ actionPaletteItem->Command() };
+                if (command.HasNestedCommands())
                 {
                     // If this Command had subcommands, then don't dispatch the
                     // action. Instead, display a new list of commands for the user
                     // to pick from.
                     _nestedActionStack.Append(filteredCommand);
-                    ParentCommandName(actionPaletteItem.Command().Name());
-                    _updateCurrentNestedCommands(actionPaletteItem.Command());
+                    ParentCommandName(command.Name());
+                    _updateCurrentNestedCommands(command);
 
                     _updateUIForStackChange();
                 }
@@ -785,9 +794,9 @@ namespace winrt::TerminalApp::implementation
                     // But make an exception for the Toggle Command Palette action: we don't want the dispatch
                     // make the command palette - that was just closed - visible again.
                     // All other actions can just be dispatched.
-                    if (actionPaletteItem.Command().ActionAndArgs().Action() != ShortcutAction::ToggleCommandPalette)
+                    if (command.ActionAndArgs().Action() != ShortcutAction::ToggleCommandPalette)
                     {
-                        DispatchCommandRequested.raise(*this, actionPaletteItem.Command());
+                        DispatchCommandRequested.raise(*this, command);
                     }
 
                     TraceLoggingWrite(
@@ -837,9 +846,11 @@ namespace winrt::TerminalApp::implementation
     {
         if (filteredCommand)
         {
-            if (const auto tabPaletteItem{ filteredCommand.Item().try_as<winrt::TerminalApp::TabPaletteItem>() })
+            const auto item{ filteredCommand.Item() };
+            if (item.Type() == PaletteItemType::Tab)
             {
-                if (const auto tab{ tabPaletteItem.Tab() })
+                const auto tabPaletteItem{ winrt::get_self<TabPaletteItem>(item) };
+                if (const auto tab{ tabPaletteItem->Tab() })
                 {
                     SwitchToTabRequested.raise(*this, tab);
                 }
@@ -867,9 +878,11 @@ namespace winrt::TerminalApp::implementation
                 TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
                 TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage));
 
-            if (const auto commandLinePaletteItem{ filteredCommand.value().Item().try_as<winrt::TerminalApp::CommandLinePaletteItem>() })
+            const auto item{ filteredCommand->Item() };
+            if (item.Type() == PaletteItemType::CommandLine)
             {
-                CommandLineExecutionRequested.raise(*this, commandLinePaletteItem.CommandLine());
+                const auto commandLinePaletteItem{ winrt::get_self<CommandLinePaletteItem>(item) };
+                CommandLineExecutionRequested.raise(*this, commandLinePaletteItem->CommandLine());
                 _close();
             }
         }