Merge pull request #5506 from MicrosoftDocs/main

Merged by Learn.Build PR Management system

Author: learn-build-service-prod[bot]

hub/images/command-palette/reload.png

@@ -15,15 +15,15 @@ So far, you've only added commands to a single page within your extension. You c
 
 ## Adding the top-level commands
 
-To do that, head on over to the `ExtensionNameCommandsProvider.cs` file. This file is where you'll add commands that should be shown at the top-level of the Command Palette. As you can see, there's currently only a single item there:
+To do that, head on over to the `<ExtensionName>CommandsProvider.cs` file. This file is where you'll add commands that should be shown at the top-level of the Command Palette. As you can see, there's currently only a single item there:
 
 ```csharp
-public ExtensionNameCommandsProvider()
+public <ExtensionName>CommandsProvider()
 {
     DisplayName = "My sample extension";
     Icon = IconHelpers.FromRelativePath("Assets\\StoreLogo.png");
     _commands = [
-        new CommandItem(new ExtensionNamePage()) { Title = DisplayName },
+        new CommandItem(new <ExtensionName>Page()) { Title = DisplayName },
     ];
 }
 
@@ -38,12 +38,12 @@ This sample extension creates a list of commands when the extension is created a
 If you want to add another command to the top-level list of commands, you can add another **CommandItem**:
 
 ```csharp
-public ExtensionNameCommandsProvider()
+public <ExtensionName>CommandsProvider()
 {
     DisplayName = "My sample extension";
     Icon = IconHelpers.FromRelativePath("Assets\\StoreLogo.png");
     _commands = [
-        new CommandItem(new ExtensionNamePage()) { Title = DisplayName },
+        new CommandItem(new <ExtensionName>Page()) { Title = DisplayName },
         new CommandItem(new ShowMessageCommand()) { Title = "Send a message" },
     ];
 }

hub/powertoys/command-palette/add-top-level-commands-to-your-extension.md

@@ -15,10 +15,10 @@ Now that you've created your extension, it's time to add some commands to it.
 
 ## Add some commands
 
-We can start by navigating to the `ExtensionNamePage.cs` file. This file is the [ListPage](./microsoft-commandpalette-extensions-toolkit/listpage.md) that will be displayed when the user selects your extension. In there you should see:
+We can start by navigating to the `<ExtensionName>Page.cs` file. This file is the [ListPage](./microsoft-commandpalette-extensions-toolkit/listpage.md) that will be displayed when the user selects your extension. In there you should see:
 
 ```csharp   
-public ExtensionNamePage()
+public <ExtensionName>Page()
 {
     Icon = IconHelpers.FromRelativePath("Assets\\StoreLogo.png");
     Title = "My sample extension";
@@ -56,7 +56,7 @@ The **OpenUrlCommand** is a helper for opening a URL in the user's default web b
 ```csharp
 using System.Runtime.InteropServices;
 
-namespace ExtensionName;
+namespace <ExtensionName>;
 
 internal sealed partial class ShowMessageCommand : InvokableCommand
 {
@@ -76,7 +76,7 @@ internal sealed partial class ShowMessageCommand : InvokableCommand
 }
 ```
 
-Now we can add this command to the list of commands in the `ExtensionNamePage.cs` file:
+Now we can add this command to the list of commands in the `<ExtensionName>Page.cs` file:
 
 ```csharp
 public override IListItem[] GetItems()
@@ -121,7 +121,7 @@ Start by adding a new page that shows a list of commands. Create a new class tha
 using Microsoft.CommandPalette.Extensions.Toolkit;
 using System.Linq;
 
-namespace ExtensionName;
+namespace <ExtensionName>;
 
 internal sealed partial class MySecondPage : ListPage
 {
@@ -145,7 +145,7 @@ internal sealed partial class MySecondPage : ListPage
 }
 ```
 
-Next, update the `ExtensionNamePage.cs` to include this new page:
+Next, update the `<ExtensionName>Page.cs` to include this new page:
 
 ```diff
     public override IListItem[] GetItems()

hub/powertoys/command-palette/adding-commands.md

@@ -13,7 +13,10 @@ no-loc: [PowerToys, Windows, Insider]
 
 An [IInvokableCommand](./microsoft-commandpalette-extensions/iinvokablecommand.md) is a fundamental unit of *do something* in the Command Palette. The [Invoke](./microsoft-commandpalette-extensions/iinvokablecommand.md) method is called when the user selects the command, and it's where you *do something* in your extension. The **Invoke** method returns an **ICommandResult**, which tells the Command Palette what to do after the command has been invoked. This page details what's possible with each type of command result.
 
-The toolkit provides a number of helper methods to create command results. These are all static methods on the **CommandResult** class. Calling these methods on their own won't do anything. You must return those objects as the result of a **Invoke** method, for Command Palette to handle them. 
+The toolkit provides a number of helper methods to create command results. These are all static methods on the **CommandResult** class. Calling these methods on their own won't do anything. You must return those objects as the result of a **Invoke** method, for Command Palette to handle them.
+
+> [!NOTE]
+> There are code examples for the various CommandResult methods listed on this page.
 
 <!-- GoToPage currently omitted from these docs, because it's not remotely implemented -->
 
@@ -38,7 +41,7 @@ This result takes the user back to the main page of the Command Palette. It will
 
 ## Dismiss command result
 
-This result hides the Command Palette after the action is executed, and takes it back to the home page. On the next launch, the Command Palette will start from the main page with a blank query. This is useful for commands that are one-off actions, or that don't need to keep the Command Palette open. 
+This result hides the Command Palette after the action is executed, and takes it back to the home page. On the next launch, the Command Palette will start from the main page with a blank query. This is useful for commands that are one-off actions, or that don't need to keep the Command Palette open.
 
 If you don't know what else to use, this should be your default. Ideally, users should come into the palette, find what they need, and be done with it. 
 
@@ -60,6 +63,9 @@ This is useful for commands that might have destructive actions, or that need to
 
 As an example, here's a page with one command for each kind of command result:
 
+> [!NOTE]
+> If working from prior section, modify the code below from `CommandResultsPage` to `<ExtensionName>Page`.
+
 ```csharp
 
 using Microsoft.CommandPalette.Extensions;

hub/powertoys/command-palette/command-results.md

@@ -15,7 +15,7 @@ Extensions are written in C#. The fastest way to get started writing extensions
 
 The form will ask you for the following information:
 
-- **ExtensionName**: The name of your extension. This will be used as the name of the project and the name of the class that implements your commands. Make sure it's a valid C# class name - it shouldn't have any spaces or special characters, and should start with a capital letter.
+- **ExtensionName**: The name of your extension. This will be used as the name of the project and the name of the class that implements your commands. Make sure it's a valid C# class name - it shouldn't have any spaces or special characters, and should start with a capital letter. Reference in docs as `<ExtensionName>`.
 - **Extension Display Name**: The name of your extension as it will appear in the Command Palette. This can be a more human-readable name. 
 - **Output Path**: The folder where the project will be created. 
   - The project will be created in a subdirectory of the path you provided. 
@@ -26,38 +26,38 @@ The form will ask you for the following information:
 Once you submit the form, Command Palette will automatically generate the project for you. At this point, your projects structure should look like the following:
 
 ```plaintext
-ExtensionName/
+<ExtensionName>/
 │   Directory.Build.props
 │   Directory.Packages.props
 │   nuget.config
-│   ExtensionName.sln
-└───ExtensionName
+│   <ExtensionName>.sln
+└───<ExtensionName>
     │   app.manifest
     │   Package.appxmanifest
     │   Program.cs
-    │   ExtensionName.cs
-    │   ExtensionName.csproj
-    │   ExtensionNameCommandsProvider.cs
+    │   <ExtensionName>.cs
+    │   <ExtensionName>.csproj
+    │   <ExtensionName>CommandsProvider.cs
     ├───Assets
     │   <A bunch of placeholder images>
     ├───Pages
-    │   ExtensionNamePage.cs
+    │   <ExtensionName>Page.cs
     └───Properties
         │   launchSettings.json
         └───PublishProfiles
                 win-arm64.pubxml
                 win-x64.pubxml
 ```
 
-(with `ExtensionName` replaced with the name you provided)
+(with `<ExtensionName>` replaced with the name you provided)
 
-From here, you can immediately build the project and run it. Once your package is deployed and running, Command Palette will automatically discover your extension and load it into the palette. 
+From here, you can immediately build the project and run it. Once your package is deployed and running, Command Palette will automatically discover your extension and load it into the palette.
 
 > [!TIP]
 > Make sure you _deploy_ your app! Just **build**ing your application won't update the package in the same way that deploying it will.
 
 > [!WARNING]
-> Running "ExtensionName (Unpackaged)" from Visual Studio will not **deploy** your app package.
+> Running "\<ExtensionName\> (Unpackaged)" from Visual Studio will not **deploy** your app package.
 > 
 > If you're using `git` for source control, and you used the standard `.gitignore` file for C#, you'll want to remove the following two lines from your `.gitignore` file:
 > ```
@@ -74,6 +74,9 @@ Congrats! You've made your first extension! Now let's go ahead and actually add
 
 When you make changes to your extension, you can rebuild your project and deploy it again. Command Palette will **not** notice changes to packages that are re-ran through Visual Studio, so you'll need to manually run the "**Reload**" command to force Command Palette to re-instantiate your extension.
 
+![Screenshot of reload](../../images/command-palette/reload.png)
+
+
 ### Next up: [Add commands to your extension](adding-commands.md)
 
 ## Related content

hub/powertoys/command-palette/creating-an-extension.md

@@ -15,7 +15,7 @@ So far we've shown how to return a list of static items in your extension. Howev
 
 ## Updating a command
 
-Almost all extension objects in the Command Palette implement the **IPropChanged** interface. This allows them to notify the Command Palette when they've changed, and the Command Palette will update the UI to reflect those changes. If you're using the toolkit implementations, this interface has already been implemented for you for properties that support it.
+Almost all extension objects in the Command Palette implement the **IPropChanged** interface. This allows them to notify the Command Palette when they've changed, and the Command Palette will update the UI to reflect those changes. If you're using the [toolkit](/windows/powertoys/command-palette/microsoft-commandpalette-extensions-toolkit/microsoft-commandpalette-extensions-toolkit) implementations, this interface has already been implemented for you for properties that support it.
 
 As a simple example, you can update the title of the page. To do this, you can add a command which will simply update the title of the page.
 
@@ -87,36 +87,36 @@ Update your list item to take a reference to the page, and add a method to incre
 ```csharp
 internal sealed partial class IncrementingListItem : ListItem
 {
-    public IncrementingListItem(ExtensionNamePage page) :
+    public IncrementingListItem(<ExtensionName>Page page) :
         base(new NoOpCommand())
     {
         _page = page;
         Command = new AnonymousCommand(action: _page.Increment) { Result = CommandResult.KeepOpen() };
         Title = "Increment";
     }
 
-    private ExtensionNamePage _page;
+    private <ExtensionName>Page _page;
 }
 ```
 
 Then, change your page as follows:
 
 ```cs
-public ExtensionNamePage()
+public <ExtensionName>Page()
 {
     Icon = IconHelpers.FromRelativePath("Assets\\StoreLogo.png");
     Title = "My sample extension";
     Name = "Open";
 
-    _items = [new IncrementingListItem2this) { Subtitle = $"Item 0" }];
+    _items = [new IncrementingListItem(this) { Subtitle = $"Item 0" }]; 
 }
 public override IListItem[] GetItems()
 {
     return _items.ToArray();
 }
 internal void Increment()
 {
-    _items += new IncrementingListItem(this) { Subtitle = $"Item {_items.Count}" };
+    _items.Add(new IncrementingListItem(this) { Subtitle = $"Item {_items.Count}" });
     RaiseItemsChanged();
 }
 private List<ListItem> _items;
@@ -128,20 +128,24 @@ Now, every time you perform one of the **IncrementingListItem** commands, the li
 
 Everything so far has been pretty instantaneous. Many extensions however may need to do some work that takes a lot longer. In that case, you can set **Page.IsLoading** to `true` to show a loading spinner. This will help indicate that the extension is doing something in the background.
 
+> [!NOTE]
+> If working from prior section, modify the code below from `Page.IsLoading` to `this.IsLoading`.
+
 ```csharp
 internal void Increment()
 {
     Page.IsLoading = true;
     Task.Run(() =>
     {
         Thread.Sleep(5000);
-        _items += new IncrementingListItem(this) { Subtitle = $"Item {_items.Count}" };
+        _items.Add(new IncrementingListItem(this) { Subtitle = $"Item {_items.Count}" });
         RaiseItemsChanged();
         Page.IsLoading = false;
     });
 }
 ```
 
+
 Best practice is to set **IsLoading** to `true` before starting the work. Then do all the work to build all the new **ListItems** you need to display to the user. Then, once the items are ready, call **RaiseItemsChanged** and set **IsLoading** back to `false`. This will ensure that the loading spinner is shown for the entire duration of the work, and that the UI is updated as soon as the work is done (without waiting for your extension to construct new **ListItem** objects).
 
 ### Next up: [Add top-level commands to your extension](add-top-level-commands-to-your-extension.md)

hub/powertoys/command-palette/update-a-list-of-commands.md

@@ -19,6 +19,9 @@ So far, we've only shown how to display a list of commands in a **ListPage**. Ho
 
 As a simple example, we can create the following page:
 
+> [!NOTE]
+> If working from prior sections, modify the code below from `MarkdownPage` to `<ExtensionName>Page`.
+
 ```csharp
 public class MarkdownPage : ContentPage
 {

hub/powertoys/command-palette/using-markdown-content.md

@@ -430,6 +430,8 @@ To search for Windows services, [enable the plugin](#plugin-manager), open Power
 
 With the Window Walker plugin, you can switch to other windows, close them, or kill the window process.
 
+You can enter the **Direct activation command** `<` to search for open windows. The plugin will search for the window title and the name of the process that owns the window.
+
 #### Kill a window process
 
 With the Window Walker plugin, you can kill the process of a window if it stops responding.