Kontekstowe polecenia dla kolekcji i list

Wiele aplikacji zawiera kolekcje zawartości w postaci list, siatek i drzew, którymi użytkownicy mogą manipulować. Na przykład użytkownicy mogą mieć możliwość usunięcia, zmiany nazwy, flagi lub odświeżenia elementów. W tym artykule pokazano, jak używać poleceń kontekstowych do implementowania tego rodzaju akcji w sposób zapewniający najlepsze możliwe środowisko dla wszystkich typów danych wejściowych.

Ważne interfejsy API: interfejs ICommand, właściwość UIElement.ContextFlyout, interfejs INotifyPropertyChanged

Użyj różnych danych wejściowych, aby wykonać polecenie Ulubione

Tworzenie poleceń dla wszystkich typów danych wejściowych

Ponieważ użytkownicy mogą wchodzić w interakcje z aplikacją systemu Windows przy użyciu szerokiego zakresu urządzeń i danych wejściowych, aplikacja powinna uwidaczniać polecenia zarówno za pomocą menu kontekstowych niezależnych od rodzaju danych wejściowych, jak i akceleratorów specyficznych dla danych wejściowych. Włączenie obu umożliwia użytkownikowi szybkie wywoływanie poleceń w zawartości, niezależnie od typu danych wejściowych lub urządzeń.

W tej tabeli przedstawiono niektóre typowe polecenia kolekcji i sposoby uwidocznienia tych poleceń.

Command	Niezależny od danych wejściowych	Akceleracja myszy	Akcelerator klawiatury	Akcelerator dotykowy
Usuń element	Menu kontekstowe	Przycisk aktywowania	Klawisz DEL	Szybkie przesunięcie w celu usunięcia
Element flagi	Menu kontekstowe	Przycisk aktywowania	Ctrl+Shift+G	Przesuń, aby oznaczyć flagą
Odświeżanie danych	Menu kontekstowe	N/A	F5	Przeciągnij, aby odświeżyć
Dodaj element do ulubionych	Menu kontekstowe	Przycisk aktywowania	F, Ctrl+S	Szybkie przesunięcie do ulubionych

Ogólnie rzecz biorąc, należy udostępnić wszystkie polecenia dla elementu w menu kontekstowym elementu. Menu kontekstowe są dostępne dla użytkowników niezależnie od typu danych wejściowych i powinny zawierać wszystkie kontekstowe polecenia, które użytkownik może wykonać.
W przypadku często używanych poleceń rozważ użycie akceleratorów wejściowych. Akceleratory wejściowe umożliwiają użytkownikowi szybkie wykonywanie akcji w zależności od używanego urządzenia wejściowego. Akceleratory wejściowe obejmują:
- Szybkie przesunięcie do akcji (akcelerator dotykowy)
- Przeciągnij, aby odświeżyć dane (przycisk dotykowy)
- Skróty klawiaturowe (akcelerator klawiatury)
- Klawisze dostępu (akcelerator klawiatury)
- Przyciski najazdu kursorem myszy i rysika (akcelerator wskaźnika)

Uwaga / Notatka

Użytkownicy powinni mieć dostęp do wszystkich poleceń z dowolnego typu urządzenia. Na przykład, jeśli polecenia aplikacji są dostępne tylko za pomocą akceleratorów przycisków kursora na najechaniu, użytkownicy korzystający z dotyku nie będą mogli uzyskać do nich dostępu. Co najmniej użyj menu kontekstowego, aby zapewnić dostęp do wszystkich poleceń.

Przykład: model danych PodcastObject

Aby zademonstrować nasze wiodące rekomendacje, w tym artykule tworzymy listę podcastów dla aplikacji do podcastów. Przykładowy kod pokazuje, jak umożliwić użytkownikowi oznaczenie jako ulubionego konkretnego podcastu z listy.

Oto definicja obiektu podcastu, z którymi będziemy pracować:

public class PodcastObject : INotifyPropertyChanged
{
    // The title of the podcast
    public String Title { get; set; }

    // The podcast's description
    public String Description { get; set; }

    // Describes if the user has set this podcast as a favorite
    public bool IsFavorite
    {
        get
        {
            return _isFavorite;
        }
        set
        {
            _isFavorite = value;
            OnPropertyChanged("IsFavorite");
        }
    }
    private bool _isFavorite = false;

    public event PropertyChangedEventHandler PropertyChanged;

    private void OnPropertyChanged(String property)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(property));
    }
}

Zwróć uwagę, że obiekt PodcastObject implementuje właściwość INotifyPropertyChanged , aby reagować na zmiany właściwości, gdy użytkownik przełącza właściwość IsFavorite.

Definiowanie poleceń za pomocą interfejsu ICommand

Interfejs ICommand ułatwia zdefiniowanie polecenia dostępnego dla wielu typów danych wejściowych. Na przykład zamiast pisać ten sam kod dla polecenia usuwania w dwóch różnych programach obsługi zdarzeń, jeden na wypadek, gdy użytkownik naciska Delete i jeden, gdy użytkownik kliknie prawym przyciskiem myszy pozycję "Usuń" w menu kontekstowym, możesz zaimplementować logikę usuwania raz, jako ICommand, a następnie udostępnić go różnym typom danych wejściowych.

Musimy zdefiniować akcję ICommand reprezentującą akcję "Ulubione". Użyjemy metody polecenia Execute, aby ulubić podcast. Określony podcast zostanie udostępniony metodzie execute za pomocą parametru polecenia, który można powiązać za pomocą właściwości CommandParameter.

public class FavoriteCommand: ICommand
{
    public event EventHandler CanExecuteChanged;

    public bool CanExecute(object parameter)
    {
        return true;
    }
    public void Execute(object parameter)
    {
        // Perform the logic to "favorite" an item.
        (parameter as PodcastObject).IsFavorite = true;
    }
}

Aby użyć tego samego polecenia z wieloma kolekcjami i elementami, możesz zapisać polecenie jako zasób na stronie lub w aplikacji.

<Application.Resources>
    <local:FavoriteCommand x:Key="favoriteCommand" />
</Application.Resources>

Aby wykonać polecenie, wywołasz jego metodę Execute .

// Favorite the item using the defined command
var favoriteCommand = Application.Current.Resources["favoriteCommand"] as ICommand;
favoriteCommand.Execute(PodcastObject);

Tworzenie kontrolki UserControl w celu reagowania na różne dane wejściowe

Jeśli masz listę elementów i każdy z tych elementów powinien odpowiadać na wiele danych wejściowych, możesz uprościć kod, definiując element UserControl dla elementu i używając go do definiowania menu kontekstowego elementów i procedur obsługi zdarzeń.

Aby utworzyć element UserControl w programie Visual Studio:

W Eksploratorze rozwiązań kliknij prawym przyciskiem myszy projekt. Zostanie wyświetlone menu kontekstowe.
Wybierz Dodaj > nowy element...
Zostanie wyświetlone okno dialogowe Dodawanie nowego elementu .
Wybierz pozycję UserControl z listy elementów. Nadaj jej nazwę, a następnie kliknij przycisk Dodaj. Program Visual Studio wygeneruje dla Ciebie wycinkę UserControl.

W naszym przykładzie podcastu, każdy podcast będzie wyświetlany na liście, co umożliwi różne sposoby oznaczania podcastu jako ulubiony. Użytkownik będzie mógł wykonać następujące akcje, aby dodać podcast do "Ulubionych":

Wywoływanie menu kontekstowego
Wykonywanie skrótów klawiaturowych
Pokaż przycisk najechania kursorem
Wykonywanie gestu przesunięcia

Aby ująć te zachowania i użyć polecenia FavoriteCommand, utwórzmy nowy element UserControl o nazwie "PodcastUserControl", aby reprezentować podcast na liście.

Element PodcastUserControl wyświetla pola obiektu PodcastObject jako TextBlocks i reaguje na różne interakcje użytkownika. W tym artykule będziemy odnosić się do PodcastUserControl i rozwijać jego tematykę.

PodcastUserControl.xaml

<UserControl
    x:Class="ContextCommanding.PodcastUserControl"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    IsTabStop="True" UseSystemFocusVisuals="True"
    >
    <Grid Margin="12,0,12,0">
        <StackPanel>
            <TextBlock Text="{x:Bind PodcastObject.Title, Mode=OneWay}" Style="{StaticResource TitleTextBlockStyle}" />
            <TextBlock Text="{x:Bind PodcastObject.Description, Mode=OneWay}" Style="{StaticResource SubtitleTextBlockStyle}" />
            <TextBlock Text="{x:Bind PodcastObject.IsFavorite, Mode=OneWay}" Style="{StaticResource SubtitleTextBlockStyle}"/>
        </StackPanel>
    </Grid>
</UserControl>

PodcastUserControl.xaml.cs

public sealed partial class PodcastUserControl : UserControl
{
    public static readonly DependencyProperty PodcastObjectProperty =
        DependencyProperty.Register(
            "PodcastObject",
            typeof(PodcastObject),
            typeof(PodcastUserControl),
            new PropertyMetadata(null));

    public PodcastObject PodcastObject
    {
        get { return (PodcastObject)GetValue(PodcastObjectProperty); }
        set { SetValue(PodcastObjectProperty, value); }
    }

    public PodcastUserControl()
    {
        this.InitializeComponent();

        // TODO: We will add event handlers here.
    }
}

Zwróć uwagę, że element PodcastUserControl utrzymuje odwołanie do obiektu PodcastObject jako właściwość DependencyProperty. Dzięki temu możemy powiązać obiekty PodcastObjects z elementem PodcastUserControl.

Po wygenerowaniu niektórych obiektów PodcastObject można utworzyć listę podcastów przez powiązanie obiektów PodcastObjects z listview. Obiekty PodcastUserControl opisują wizualizację obiektu PodcastObjects i dlatego są ustawiane przy użyciu elementu ItemTemplate elementu ListView.

MainPage.xaml

<ListView x:Name="ListOfPodcasts"
            ItemsSource="{x:Bind podcasts}">
    <ListView.ItemTemplate>
        <DataTemplate x:DataType="local:PodcastObject">
            <local:PodcastUserControl PodcastObject="{x:Bind Mode=OneWay}" />
        </DataTemplate>
    </ListView.ItemTemplate>
    <ListView.ItemContainerStyle>
        <!-- The PodcastUserControl will entirely fill the ListView item and handle tabbing within itself. -->
        <Style TargetType="ListViewItem" BasedOn="{StaticResource ListViewItemRevealStyle}">
            <Setter Property="HorizontalContentAlignment" Value="Stretch" />
            <Setter Property="Padding" Value="0"/>
            <Setter Property="IsTabStop" Value="False"/>
        </Style>
    </ListView.ItemContainerStyle>
</ListView>

Tworzenie menu kontekstowych

Menu kontekstowe wyświetlają listę poleceń lub opcji, gdy użytkownik zażąda ich. Menu kontekstowe udostępniają kontekstowe polecenia związane z dołączonym elementem i są zazwyczaj zarezerwowane dla akcji pomocniczych specyficznych dla tego elementu.

Pokaż menu kontekstowe w elemencie

Użytkownik może wywoływać menu kontekstowe przy użyciu następujących "akcji kontekstowych":

Input	Akcja kontekstu
mysz	Kliknij prawym przyciskiem myszy
Keyboard	Shift+F10, przycisk Menu
Touch	Długie naciśnięcie elementu
Pióro	Naciśnięcie przycisku beczkowego, długie naciśnięcie elementu
Kontroler	Przycisk menu

Ponieważ użytkownik może otworzyć menu kontekstowe niezależnie od typu danych wejściowych, menu kontekstowe powinno zawierać wszystkie polecenia kontekstowe dostępne dla elementu listy.

ContextFlyout

Właściwość ContextFlyout zdefiniowana przez klasę UIElement ułatwia tworzenie menu kontekstowego, które współpracuje ze wszystkimi typami danych wejściowych. Udostępniasz okno wysuwane reprezentujące twoje menu kontekstowe, używając MenuFlyout lub CommandBarFlyout, a gdy użytkownik wykona "akcję kontekstową", jak zdefiniowano powyżej, zostanie wyświetlone odpowiednie menu.

Zobacz menu i menu kontekstowe, aby uzyskać pomoc w identyfikowaniu scenariuszy menu i menu kontekstowego oraz wskazówek dotyczących tego, kiedy używać menu wysuwane czy menu rozwijane paska poleceń.

W tym przykładzie użyjemy MenuFlyout i zaczniemy od dodania ContextFlyout do PodcastUserControl. MenuFlyout określony jako ContextFlyout zawiera pojedynczy element pozwalający oznaczyć podcast jako ulubiony. Zwróć uwagę, że ten element MenuFlyoutItem używa elementu favoriteCommand zdefiniowanego powyżej z parametrem CommandParameter powiązanym z obiektem PodcastObject.

PodcastUserControl.xaml

<UserControl>
    <UserControl.ContextFlyout>
        <MenuFlyout>
            <MenuFlyoutItem Text="Favorite" Command="{StaticResource favoriteCommand}" CommandParameter="{x:Bind PodcastObject, Mode=OneWay}" />
        </MenuFlyout>
    </UserControl.ContextFlyout>
    <Grid Margin="12,0,12,0">
        <!-- ... -->
    </Grid>
</UserControl>

Należy pamiętać, że możesz również użyć zdarzenia ContextRequested , aby odpowiedzieć na akcje kontekstu. Zdarzenie ContextRequested nie zostanie wyzwolone, jeśli określono element ContextFlyout.

Tworzenie akceleratorów wejściowych

Mimo że każdy element w kolekcji powinien mieć menu kontekstowe zawierające wszystkie polecenia kontekstowe, warto umożliwić użytkownikom szybkie wykonywanie mniejszego zestawu często wykonywanych poleceń. Na przykład aplikacja do obsługi poczty może mieć pomocnicze polecenia, takie jak Reply, Archive, Move to Folder, Set Flag i Delete, które są wyświetlane w menu kontekstowym, ale najczęściej używane polecenia to Delete i Flag. Po zidentyfikowaniu, które polecenia są najbardziej typowe, można użyć akceleratorów opartych na danych wejściowych, aby ułatwić wykonywanie tych poleceń przez użytkownika.

W aplikacji podcast często wykonywane polecenie to polecenie "Ulubione".

Akceleratory klawiatury

Skróty i obsługa klawiszy bezpośrednich

Naciśnij Ctrl i F, aby wykonać akcję

W zależności od typu zawartości można zidentyfikować pewne kombinacje, które powinny wykonać akcję. Na przykład w aplikacji poczty e-mail klucz DEL może służyć do usunięcia wybranej wiadomości e-mail. W aplikacji do podcastów klawisze Ctrl+S lub F mogą dodawać podcast do ulubionych na później. Chociaż niektóre polecenia mają typowe, znane skróty klawiaturowe, takie jak DEL do usunięcia, inne polecenia mają skróty specyficzne dla aplikacji lub domeny. Jeśli to możliwe, użyj dobrze znanych skrótów lub rozważ podanie tekstu przypomnienia w etykietce narzędzia , aby nauczyć użytkownika o poleceniu skrótu.

Aplikacja może odpowiedzieć, gdy użytkownik naciśnie klawisz, używając zdarzenia KeyDown. Ogólnie rzecz biorąc, użytkownicy oczekują, że aplikacja odpowie, kiedy po raz pierwszy naciskają klawisz, zamiast czekać, aż go zwolnią.

W tym przykładzie pokazano, jak dodać obsługę zdarzeń KeyDown do elementu PodcastUserControl w celu oznaczenia podcastu jako ulubionego, gdy użytkownik naciska Ctrl+S lub F. Używa on tego samego polecenia co wcześniej.

PodcastUserControl.xaml.cs

// Respond to the F and Ctrl+S keys to favorite the focused item.
protected override void OnKeyDown(KeyRoutedEventArgs e)
{
    var ctrlState = CoreWindow.GetForCurrentThread().GetKeyState(VirtualKey.Control);
    var isCtrlPressed = (ctrlState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down || (ctrlState & CoreVirtualKeyStates.Locked) == CoreVirtualKeyStates.Locked;

    if (e.Key == Windows.System.VirtualKey.F || (e.Key == Windows.System.VirtualKey.S && isCtrlPressed))
    {
        // Favorite the item using the defined command
        var favoriteCommand = Application.Current.Resources["favoriteCommand"] as ICommand;
        favoriteCommand.Execute(PodcastObject);
    }
}

Przyspieszacze myszy

Umieść kursor myszy na elemencie, aby wyświetlić przycisk

Użytkownicy znają menu kontekstowe klikane prawym przyciskiem myszy, ale możesz umożliwić użytkownikom wykonywanie typowych poleceń przy użyciu tylko jednego kliknięcia myszy. Aby włączyć to doświadczenie, możesz dodać dedykowane przyciski na płótnie elementu kolekcji. Aby umożliwić użytkownikom szybkie działanie za pomocą myszy i zminimalizowanie bałaganu wizualnego, można wybrać wyświetlanie tylko tych przycisków, gdy użytkownik ma wskaźnik w określonym elemencie listy.

W tym przykładzie polecenie ulubione jest przedstawione przez przycisk zdefiniowany bezpośrednio w module PodcastUserControl. Należy pamiętać, że przycisk w tym przykładzie używa tego samego polecenia, FavoriteCommand, jak poprzednio. Aby przełączyć widoczność tego przycisku, możesz użyć kontrolki VisualStateManager, aby przełączać się między stanami wizualizacji, gdy wskaźnik przechodzi i zamyka kontrolkę.

PodcastUserControl.xaml

<UserControl>
    <UserControl.ContextFlyout>
        <!-- ... -->
    </UserControl.ContextFlyout>
    <Grid Margin="12,0,12,0">
        <VisualStateManager.VisualStateGroups>
            <VisualStateGroup x:Name="HoveringStates">
                <VisualState x:Name="HoverButtonsShown">
                    <VisualState.Setters>
                        <Setter Target="hoverArea.Visibility" Value="Visible" />
                    </VisualState.Setters>
                </VisualState>
                <VisualState x:Name="HoverButtonsHidden" />
            </VisualStateGroup>
        </VisualStateManager.VisualStateGroups>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="*" />
            <ColumnDefinition Width="Auto" />
        </Grid.ColumnDefinitions>
        <StackPanel>
            <TextBlock Text="{x:Bind PodcastObject.Title, Mode=OneWay}" Style="{StaticResource TitleTextBlockStyle}" />
            <TextBlock Text="{x:Bind PodcastObject.Description, Mode=OneWay}" Style="{StaticResource SubtitleTextBlockStyle}" />
            <TextBlock Text="{x:Bind PodcastObject.IsFavorite, Mode=OneWay}" Style="{StaticResource SubtitleTextBlockStyle}"/>
        </StackPanel>
        <Grid Grid.Column="1" x:Name="hoverArea" Visibility="Collapsed" VerticalAlignment="Stretch">
            <AppBarButton Icon="OutlineStar" Label="Favorite" Command="{StaticResource favoriteCommand}" CommandParameter="{x:Bind PodcastObject, Mode=OneWay}" IsTabStop="False" VerticalAlignment="Stretch"  />
        </Grid>
    </Grid>
</UserControl>

Przyciski aktywowania powinny pojawić się i zniknąć po wejściu myszy i zamknięciu elementu. Aby reagować na zdarzenia myszy, możesz użyć zdarzeń PointerEntered i PointerExited na PodcastUserControl.

PodcastUserControl.xaml.cs

protected override void OnPointerEntered(PointerRoutedEventArgs e)
{
    base.OnPointerEntered(e);

    // Only show hover buttons when the user is using mouse or pen.
    if (e.Pointer.PointerDeviceType == Windows.Devices.Input.PointerDeviceType.Mouse || e.Pointer.PointerDeviceType == Windows.Devices.Input.PointerDeviceType.Pen)
    {
        VisualStateManager.GoToState(this, "HoverButtonsShown", true);
    }
}

protected override void OnPointerExited(PointerRoutedEventArgs e)
{
    base.OnPointerExited(e);

    VisualStateManager.GoToState(this, "HoverButtonsHidden", true);
}

Przyciski wyświetlane w stanie najechania będą dostępne tylko za pośrednictwem typu wejściowego za pomocą wskaźnika. Ponieważ te przyciski są ograniczone do danych wejściowych wskaźnika, możesz zminimalizować lub usunąć wypełnienie wokół ikony przycisku, aby zoptymalizować dane wejściowe wskaźnika. Jeśli zdecydujesz się to zrobić, upewnij się, że ślad przycisku wynosi co najmniej 20x20px, aby zachować możliwość użycia piórem i myszą.

Akceleratory dotykowe

Swipe

Szybko przesuń element, aby wyświetlić polecenie

Polecenia przesuwania to akcelerator dotykowy, który umożliwia użytkownikom urządzeń dotykowych wykonywanie typowych czynności drugorzędnych za pomocą dotyku. Przesunięcie umożliwia użytkownikom korzystającym z ekranów dotykowych szybkie i naturalne interakcje z zawartością przy użyciu typowych akcji, takich jak przesunięcie do usunięcia lub wywołania. Aby dowiedzieć się więcej, zobacz artykuł o użyciu poleceń przez przesunięcie.

Aby zintegrować przeciągnięcie z kolekcją, potrzebne są dwa składniki: SwipeItems, które zawierają polecenia, oraz SwipeControl, który obejmuje element i umożliwia interakcję poprzez przeciągnięcie.

Element SwipeItems można zdefiniować jako zasób w PodkastUserControl. W tym przykładzie SwipeItems zawiera polecenie, aby oznaczyć element jako Ulubiony.

<UserControl.Resources>
    <SymbolIconSource x:Key="FavoriteIcon" Symbol="Favorite"/>
    <SwipeItems x:Key="RevealOtherCommands" Mode="Reveal">
        <SwipeItem IconSource="{StaticResource FavoriteIcon}" Text="Favorite" Background="Yellow" Invoked="SwipeItem_Invoked"/>
    </SwipeItems>
</UserControl.Resources>

Funkcja SwipeControl opakowuje element i umożliwia użytkownikowi interakcję z nim za pomocą gestu przesunięcia. Zwróć uwagę, że element SwipeControl zawiera odwołanie do elementu SwipeItems jako jego rightItems. Element Ulubione będzie wyświetlany, gdy użytkownik przesuwa palcem od prawej do lewej.

<SwipeControl x:Name="swipeContainer" RightItems="{StaticResource RevealOtherCommands}">
   <!-- The visual state groups moved from the Grid to the SwipeControl, since the SwipeControl wraps the Grid. -->
   <VisualStateManager.VisualStateGroups>
       <VisualStateGroup x:Name="HoveringStates">
           <VisualState x:Name="HoverButtonsShown">
               <VisualState.Setters>
                   <Setter Target="hoverArea.Visibility" Value="Visible" />
               </VisualState.Setters>
           </VisualState>
           <VisualState x:Name="HoverButtonsHidden" />
       </VisualStateGroup>
   </VisualStateManager.VisualStateGroups>
   <Grid Margin="12,0,12,0">
       <Grid.ColumnDefinitions>
           <ColumnDefinition Width="*" />
           <ColumnDefinition Width="Auto" />
       </Grid.ColumnDefinitions>
       <StackPanel>
           <TextBlock Text="{x:Bind PodcastObject.Title, Mode=OneWay}" Style="{StaticResource TitleTextBlockStyle}" />
           <TextBlock Text="{x:Bind PodcastObject.Description, Mode=OneWay}" Style="{StaticResource SubtitleTextBlockStyle}" />
           <TextBlock Text="{x:Bind PodcastObject.IsFavorite, Mode=OneWay}" Style="{StaticResource SubtitleTextBlockStyle}"/>
       </StackPanel>
       <Grid Grid.Column="1" x:Name="hoverArea" Visibility="Collapsed" VerticalAlignment="Stretch">
           <AppBarButton Icon="OutlineStar" Command="{StaticResource favoriteCommand}" CommandParameter="{x:Bind PodcastObject, Mode=OneWay}" IsTabStop="False" LabelPosition="Collapsed" VerticalAlignment="Stretch"  />
       </Grid>
   </Grid>
</SwipeControl>

Gdy użytkownik przesunie palcem, aby wywołać polecenie Ulubione, zostaje wywołana metoda Invoked.

private void SwipeItem_Invoked(SwipeItem sender, SwipeItemInvokedEventArgs args)
{
    // Favorite the item using the defined command
    var favoriteCommand = Application.Current.Resources["favoriteCommand"] as ICommand;
    favoriteCommand.Execute(PodcastObject);
}

Przeciągnij, aby odświeżyć

Funkcja pull to refresh umożliwia użytkownikowi ściąganie kolekcji danych przy użyciu dotyku w celu pobrania większej ilości danych. Aby dowiedzieć się więcej, zobacz artykuł pull to refresh (Przeciąganie w dół, aby odświeżyć).

Akceleratory pióra cyfrowego

Typ wejściowy pióra zapewnia precyzję wejścia wskaźnika. Użytkownicy mogą wykonywać typowe akcje, takie jak otwieranie menu kontekstowych przy użyciu akceleratorów opartych na piórach. Aby otworzyć menu kontekstowe, użytkownicy mogą nacisnąć ekran z naciśniętym przyciskiem baryłki lub nacisnąć długo na zawartości. Użytkownicy mogą również użyć pióra, aby umieścić kursor nad zawartością, aby lepiej zrozumieć interfejs użytkownika, taki jak wyświetlanie etykietek narzędzi, lub wyświetlić dodatkowe akcje aktywowania, podobne do myszy.

Aby zoptymalizować aplikację pod kątem danych wejściowych piórem, zobacz artykuł dotyczący interakcji pióra i rysika .

Rekomendacje

Upewnij się, że użytkownicy mogą uzyskiwać dostęp do wszystkich poleceń ze wszystkich typów urządzeń z systemem Windows.
Dołącz menu kontekstowe, które zapewnia dostęp do wszystkich poleceń dostępnych dla elementu kolekcji.
Podaj akceleratory wejściowe dla często używanych poleceń.
Użyj interfejsu ICommand , aby zaimplementować polecenia.

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-11-25

Udostępnij przez

Kontekstowe polecenia dla kolekcji i list

Tworzenie poleceń dla wszystkich typów danych wejściowych

Przykład: model danych PodcastObject

Definiowanie poleceń za pomocą interfejsu ICommand

Tworzenie kontrolki UserControl w celu reagowania na różne dane wejściowe

Tworzenie menu kontekstowych

ContextFlyout

Tworzenie akceleratorów wejściowych

Akceleratory klawiatury

Skróty i obsługa klawiszy bezpośrednich

Przyspieszacze myszy

Akceleratory dotykowe

Swipe

Przeciągnij, aby odświeżyć

Akceleratory pióra cyfrowego

Rekomendacje

Tematy pokrewne

Sprzężenie zwrotne

Dodatkowe źródła