Partager via

Mettre à jour une liste de commandes

Précédent : Ajout de commandes.

Jusqu’à présent, nous avons montré comment retourner une liste d’éléments statiques dans votre extension. Toutefois, vos éléments peuvent également changer, afficher des données en temps réel ou refléter l’état du système. Dans cet article, nous allons vous montrer comment mettre à jour la liste des commandes de votre extension.

Mise à jour d’une commande

Presque tous les objets d’extension de la palette de commandes implémentent l’interface IPropChanged . Cela leur permet de notifier la palette de commandes lorsqu’elles ont changé, et la palette de commandes met à jour l’interface utilisateur pour refléter ces modifications. Si vous utilisez les implémentations de la boîte à outils, cette interface est déjà mise en œuvre pour les propriétés qui la prennent en charge.

Par exemple, vous pouvez mettre à jour le titre de la page. Pour ce faire, vous pouvez ajouter une commande qui met simplement à jour le titre de la page.

public override IListItem[] GetItems()
{
    OpenUrlCommand command = new("https://learn.microsoft.com/windows/powertoys/command-palette/creating-an-extension");

    AnonymousCommand updateCommand = new(action: () => { Title += " Hello"; }) { Result = CommandResult.KeepOpen() };

    return [
        new ListItem(command)
        {
            Title = "Open the Command Palette documentation",
        },
        new ListItem(updateCommand),
    ];
}

Ici, nous utilisons AnonymousCommand pour créer une commande qui mettra à jour le titre de la page. AnonymousCommand est un assistance utile pour créer des commandes simples et légères qui n’ont pas besoin d’être réutilisées.

Vous pouvez bien sûr créer des objets ListItem personnalisés également :

internal sealed partial class IncrementingListItem : ListItem
{
    public IncrementingListItem() :
        base(new NoOpCommand())
    {
        Command = new AnonymousCommand(action: Increment) { Result = CommandResult.KeepOpen() };
        Title = "Increment";
    }

    private void Increment()
    {
        Subtitle = $"Count = {++_count}";
    }

    private int _count;
}

    public override IListItem[] GetItems()
    {
        OpenUrlCommand command = new("https://learn.microsoft.com/windows/powertoys/command-palette/creating-an-extension");
        return [
            new ListItem(command)
            {
                Title = "Open the Command Palette documentation",
            },
            new ListItem(new ShowMessageCommand()),
+            new IncrementingListItem(),
        ];
    }

Vous êtes sur le point de créer votre propre jeu de clic inactif en tant qu’extension de la palette de commandes.

Mise à jour de la liste des commandes

Vous pouvez également modifier la liste des éléments de la page. Cela peut être utile pour les pages qui chargent les résultats de manière asynchrone ou pour les pages qui affichent différentes commandes en fonction de l’état de l’application.

Pour ce faire, vous pouvez utiliser la méthode RaiseItemsChanged sur l’objet ListPage . Cela informe la palette de commandes que la liste des éléments a changé et qu’elle doit récupérer à nouveau la liste des éléments. Par exemple, utilisons l'élément IncrementingListItem ci-dessus pour mettre à jour la liste des éléments de la page.

Mettez à jour votre élément de liste pour obtenir une référence à la page et ajoutez une méthode pour incrémenter le nombre :

internal sealed partial class IncrementingListItem : ListItem
{
    public IncrementingListItem(<ExtensionName>Page page) :
        base(new NoOpCommand())
    {
        _page = page;
        Command = new AnonymousCommand(action: _page.Increment) { Result = CommandResult.KeepOpen() };
        Title = "Increment";
    }

    private <ExtensionName>Page _page;
}

Ensuite, modifiez votre page comme suit :

public <ExtensionName>Page()
{
    Icon = IconHelpers.FromRelativePath("Assets\\StoreLogo.png");
    Title = "My sample extension";
    Name = "Open";

    _items = [new IncrementingListItem(this) { Subtitle = $"Item 0" }]; 
}
public override IListItem[] GetItems()
{
    return _items.ToArray();
}
internal void Increment()
{
    _items.Add(new IncrementingListItem(this) { Subtitle = $"Item {_items.Count}" });
    RaiseItemsChanged();
}
private List<ListItem> _items;

À présent, chaque fois que vous effectuez l’une des commandes IncrementingListItem , la liste des éléments de la page sera mise à jour pour ajouter un autre élément. Nous utilisons une seule liste appartenant à la page pour posséder tous les éléments. Notamment, nous créons les nouveaux éléments de la méthode Increment avant d’appeler RaiseItemsChanged. L’appel d’une commande IInvokableCommand peut prendre autant de temps que vous le souhaitez. Tout votre code s’exécute dans un processus distinct de la palette de commandes. Vous ne bloquerez donc pas l’interface utilisateur. Toutefois, la construction des éléments avant d'appeler RaiseItemsChanged permettra à votre extension de donner l’impression d'être plus réactive.

Affichage d’un spinner de chargement

Jusqu’à présent, tout a été assez instantané. De nombreuses extensions peuvent toutefois avoir besoin d’effectuer un certain travail qui prend beaucoup plus de temps. Dans ce cas, vous pouvez définir Page.IsLoading sur true pour afficher une boucle de progression de chargement. Cela permet d’indiquer que l’extension fait quelque chose en arrière-plan.

Remarque

Si vous travaillez à partir de la section précédente, modifiez le code ci-dessous de Page.IsLoading à this.IsLoading.

internal void Increment()
{
    Page.IsLoading = true;
    Task.Run(() =>
    {
        Thread.Sleep(5000);
        _items.Add(new IncrementingListItem(this) { Subtitle = $"Item {_items.Count}" });
        RaiseItemsChanged();
        Page.IsLoading = false;
    });
}

La meilleure pratique consiste à définir IsLoading sur true avant de commencer le travail. Effectuez ensuite tout le travail de génération de tous les nouveaux ListItems que vous devez afficher à l’utilisateur. Ensuite, une fois les éléments prêts, appelez RaiseItemsChanged et remettez IsLoading sur false. Cela garantit que le spinner de chargement s’affiche pendant toute la durée du travail et que l’interface utilisateur est mise à jour dès que le travail est effectué (sans attendre que votre extension crée de nouveaux objets ListItem ).

Ensuite : ajouter des commandes de niveau supérieur à votre extension

Contenu connexe

  • Last updated on