Környezetfüggő parancsok gyűjteményekhez és listákhoz

Számos alkalmazás tartalmaz listák, rácsok és fák formájában létrehozott tartalomgyűjteményeket, amelyeket a felhasználók kezelhetnek. Előfordulhat például, hogy a felhasználók törölhetik, átnevezhetik, megjelölhetik vagy frissíthetik az elemeket. Ez a cikk bemutatja, hogyan valósíthat meg környezetfüggő parancsokat az ilyen típusú műveletek implementálásához úgy, hogy a lehető legjobb élményt nyújtsa az összes bemeneti típus számára.

Fontos API-k: ICommand felület, UIElement.ContextFlyout tulajdonság, INotifyPropertyChanged felület

Parancsok létrehozása az összes bemeneti típushoz

Mivel a felhasználók számos eszköz és bemenet használatával használhatják a Windows-alkalmazásokat, az alkalmazásnak el kellérhetővé tennie a parancsokat a bemeneti-agnosztikus helyi menük és a bemenetspecifikus gyorsítók mellett. Mindkettő lehetővé teszi, hogy a felhasználó gyorsan meghívja a parancsokat a tartalomon, függetlenül a bemenettől vagy az eszköz típusától.

Ez a táblázat néhány tipikus gyűjteményparancsot és a parancsok nyilvánosságra hozásának módját mutatja be.

• Általánosságban elmondható, hogy egy elem összes parancsát elérhetővé kell tennie az elem helyi menüjében. A helyi menük a bemeneti típustól függetlenül elérhetők a felhasználók számára, és tartalmazniuk kell a felhasználó által végrehajtható összes környezeti parancsot.

• A gyakran használt parancsok esetében fontolja meg a bemeneti gyorsítók használatát. A bemeneti gyorsítók lehetővé teszik a felhasználó számára a műveletek gyors végrehajtását a bemeneti eszközük alapján. A bemeneti gyorsítók a következők:

  • Pöccintés a művelethez (érintésgyorsító)
  • Húzza le az adatok frissítéséhez (érintőgyorsító)
  • Billentyűparancsok (billentyűzetgyorsító)
  • Hívóbetűk (billentyűzetgyorsító)
  • Egér és toll rámutatási gombjai (mutatógyorsító)

Példa: A PodcastObject adatmodell

A parancsokra vonatkozó javaslataink bemutatásához ez a cikk létrehozza a podcastok listáját egy podcast-alkalmazáshoz. A példakód bemutatja, hogyan engedélyezheti a felhasználónak, hogy egy adott podcastot "kedvencként" jelöljön ki egy listából.

Íme a podcast objektum definíciója, amellyel dolgozni fogunk:

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));
    }
}

Figyelje meg, hogy a PodcastObject implementálja az INotifyPropertyChanged parancsot , hogy reagáljon a tulajdonságváltozásokra, amikor a felhasználó bekapcsolja az IsFavorite tulajdonságot.

Parancsok definiálása az ICommand felülettel

Az ICommand felület segítségével definiálhat egy parancsot, amely több bemeneti típushoz is elérhető. Például ahelyett, hogy ugyanazt a kódot írnám egy törlési parancshoz két különböző eseménykezelőben, az egyik az, amikor a felhasználó lenyomja a Delete billentyűt, egyet pedig arra az esetre, ha a felhasználó jobb gombbal a "Törlés" gombra kattint egy helyi menüben, iCommandként egyszer implementálhatja a törlési logikát, majd elérhetővé teheti a különböző bemeneti típusok számára.

Meg kell határoznunk azt az ICommandet, amely a "Kedvenc" műveletet jelöli. A parancs végrehajt metódusát használjuk, hogy kedvencnek jelöljük a podcastokat. Az adott podcast a parancs paraméterein keresztül lesz elérhető a végrehajtási metódus számára, amelyet a CommandParameter tulajdonság segítségével lehet kötni.

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;
    }
}

Ha ugyanazt a parancsot több gyűjtemény és elem használatával szeretné használni, a parancsot erőforrásként tárolhatja az oldalon vagy az alkalmazásban.

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

A parancs végrehajtásához az Execute metódust kell meghívnia.

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

UserControl létrehozása különböző bemenetekre való reagáláshoz

Ha rendelkezik az elemek listájával, és ezeknek az elemeknek több bemenetre kell reagálnia, egyszerűsítheti a kódot úgy, hogy meghatároz egy UserControlt az elemhez, és ezzel definiálja az elemek helyi menüjét és eseménykezelőit.

UserControl létrehozása a Visual Studióban:

1. A Megoldáskezelőben kattintson a jobb gombbal a projektre. Megjelenik egy helyi menü.
2. Válassza az Új elem hozzáadása > ...
   Megjelenik az Új elem hozzáadása párbeszédpanel.
3. Válassza a UserControl lehetőséget az elemek listájából. Adja meg a kívánt nevet, majd kattintson a Hozzáadás gombra. A Visual Studio létrehoz önnek egy stub UserControlt.

A podcast-példánkban minden podcast megjelenik egy listában, amely különböző módokat kínál arra, hogy "Kedvencként jelöljük" a podcastot. A felhasználó a következő műveleteket hajthatja végre a podcast "Kedvenc" állapotában:

• Helyi menü meghívása
• Billentyűparancsok végrehajtása
• Mutat egy lebegtetett gombot
• Pöccintéses kézmozdulat végrehajtása

Ezeknek a viselkedéseknek a beágyazásához és a FavoriteCommand használatához hozzunk létre egy új UserControl nevű "PodcastUserControl"-t, amely egy podcastot jelöl a listában.

A PodcastUserControl szövegblokkként jeleníti meg a PodcastObject mezőit, és reagál a különböző felhasználói interakciókra. Ebben a cikkben a PodcastUserControlra fogunk hivatkozni és kiterjeszteni.

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.
    }
}

Figyelje meg, hogy a PodcastUserControl függőségpropertyként hivatkozik a PodcastObjectre. Ez lehetővé teszi a PodcastObjects kötését a PodcastUserControlhoz.

Miután létrehozott néhány PodcastObjects-et, létrehozhat egy podcastlistát a PodcastObjects listView-hoz kötésével. A PodcastUserControl-objektumok a PodcastObjects vizualizációját írják le, ezért a ListView ItemTemplate használatával vannak beállítva.

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>

Helyi menük létrehozása

A helyi menük parancsok vagy beállítások listáját jelenítik meg, amikor a felhasználó kéri őket. A helyi menük a csatolt elemhez kapcsolódó környezeti parancsokat biztosítanak, és általában az adott elemhez tartozó másodlagos műveletekhez vannak fenntartva.

A felhasználó az alábbi "környezeti műveletek" használatával hívhatja meg a helyi menüket:

Mivel a felhasználó a bemeneti típustól függetlenül megnyithat egy helyi menüt, a helyi menünek tartalmaznia kell a listaelemhez elérhető összes helyi parancsot.

ContextFlyout

A UIElement osztály által definiált ContextFlyout tulajdonság megkönnyíti az összes bemeneti típussal működő helyi menü létrehozását. A MenuFlyout vagy a CommandBarFlyout használatával a helyi menüt jelképező úszó panelt ad meg, és amikor a felhasználó a fent meghatározott "környezeti műveletet" hajt végre, megjelenik az elemnek megfelelő MenuFlyout vagy CommandBarFlyout.

A menük és a helyi menük segítségével azonosíthatja a menü és a helyi menü közötti különbségeket, és útmutatást kaphat arra vonatkozóan, mikor használja a felugró menüt vagy a parancssáv felugrót.

Ebben a példában a MenuFlyoutot fogjuk használni, és először egy ContextFlyout-ot ad hozzá a PodcastUserControlhoz. A ContextFlyoutként megadott MenuFlyout egyetlen elemet tartalmaz, amely lehetővé teszi egy podcast kedvencként való megjelölését. Figyelje meg, hogy ez a MenuFlyoutItem a fent definiált kedvenccommandot használja, és a CommandParameter a PodcastObjecthez van kötve.

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>

Vegye figyelembe, hogy a ContextRequested esemény használatával is válaszolhat a környezeti műveletekre. A ContextRequested esemény nem indul el, ha egy ContextFlyout van megadva.

Bemenetigyorsítók létrehozása

Bár a gyűjtemény minden elemének rendelkeznie kell egy helyi menüvel, amely tartalmazza az összes környezeti parancsot, érdemes lehet engedélyeznie a felhasználóknak, hogy gyorsan végrehajthassák a gyakran végrehajtott parancsok kisebb halmazát. Előfordulhat például, hogy egy levelezőalkalmazás másodlagos parancsokkal rendelkezik, például Válasz, Archívum, Áthelyezés mappába, Jelölő beállítása és Törlés, amelyek a helyi menüben jelennek meg, de a leggyakoribb parancsok a Törlés és a Megjelölés. Miután azonosította, hogy mely parancsok a leggyakoribbak, a bemeneti alapú gyorsítókkal megkönnyítheti a felhasználók számára a parancsok végrehajtását.

A podcast alkalmazásban a gyakran végrehajtott parancs a "Kedvenc" parancs.

Billentyűzetgyorsítók

Billentyűparancsok és közvetlen kulcskezelés

A tartalom típusától függően azonosíthat bizonyos kulcskombinációkat, amelyeknek végre kell hajtaniuk egy műveletet. Egy levelezőalkalmazásban például a DEL-kulcs használható a kijelölt e-mail törléséhez. Egy podcast-alkalmazásban a Ctrl+S vagy F billentyűkkel később is kedvencek lehetnek a podcastok. Bár egyes parancsok gyakran használt, jól ismert billentyűparancsokkal rendelkeznek, például a DEL törlésével, más parancsok alkalmazás- vagy tartományspecifikus billentyűparancsokkal rendelkeznek. Ha lehetséges, használjon jól ismert billentyűparancsokat, vagy adjon meg emlékeztető szöveget egy elemleírásban , hogy megtanítsa a felhasználónak a parancsikont.

Az alkalmazás válaszolhat, ha a felhasználó lenyom egy billentyűt a KeyDown-esemény használatával. Általánosságban elmondható, hogy a felhasználók arra számítanak, hogy az alkalmazás a kulcs első lenyomásakor válaszol, ahelyett, hogy megvárják, amíg fel nem oldják a kulcsot.

Ez a példa bemutatja, hogyan adhat hozzá KeyDown kezelőt a PodcastUserControlhoz, hogy kedvencként válasszon egy podcastot, amikor a felhasználó lenyomja a Ctrl+S vagy az F billentyűkombinációt. Ugyanazt a parancsot használja, mint korábban.

PodcastUserControl.xaml.cs

// Respond to the F and Ctrl+S keys to favorite the focused item.
protected override void OnKeyDown(KeyRoutedEventArgs e)
{
    var ctrlState = Microsoft.UI.Input.InputKeyboardSource.GetKeyStateForCurrentThread(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);
    }
}

Egérgyorsítók

A felhasználók ismerik a jobb gombbal kattintva elérhető helyi menüket, de előfordulhat, hogy lehetővé szeretné tenni, hogy a felhasználók az egér egyetlen kattintásával hajtsanak végre gyakori parancsokat. A felhasználói élmény engedélyezéséhez dedikált gombokat is felvehet a gyűjteményelem vásznára. Ha lehetővé szeretné tenni a felhasználók számára, hogy gyorsan cselekedjenek az egérrel, és a vizuális zsúfoltság minimalizálása érdekében úgy is dönthet, hogy csak akkor jeleníti meg ezeket a gombokat, ha a felhasználó mutatója egy adott listaelemen belül található.

Ebben a példában a Kedvenc parancsot egy közvetlenül a PodcastUserControlban definiált gomb jelöli. Vegye figyelembe, hogy a példában szereplő gomb ugyanazt a parancsot, a FavoriteCommand-ot, használja, mint korábban. A gomb láthatóságának váltásához a VisualStateManager használatával válthat a vizualizációs állapotok között, amikor az egérmutató belép a vezérlőbe, és kilép a vezérlőből.

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>

Az egérmutató gombjainak el kell tűnniük, amikor az egér belép és kilép az elemből. Az egéreseményekre használhatja a PointerEntered és a PointerExited eseményeket a PodcastUserControl-ban.

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);
}

A rámutatási állapotban megjelenő gombok csak a mutató bemeneti típusával lesznek elérhetők. Mivel ezek a gombok csak a mutató bemenetére korlátozódnak, a gomb ikonja körüli kitöltés minimalizálása vagy eltávolítása mellett is dönthet úgy, hogy optimalizálja a mutató bemenetét. Ha ezt választja, győződjön meg arról, hogy a gomb lábnyoma legalább 20x20px, hogy tollal és egérrel használható maradjon.

Érintésgyorsítók

Ellop

A pöccintéses parancsolás egy érintéses gyorsító, amely lehetővé teszi, hogy az érintéses eszközökön lévő felhasználók gyakran másodlagos műveleteket hajtsanak végre érintéssel. A pöccintéssel a felhasználók gyorsan és természetesen kezelhetik a tartalmakat olyan gyakori műveletek használatával, mint a pöccintés a törléshez vagy a pöccintés a meghíváshoz. További információért tekintse meg a pöccintéssel kapcsolatos parancsokat ismertető cikket.

A pöccintés gyűjteménybe való integrálásához két összetevőre van szükség: a parancsokat üzemeltető SwipeItemsre; és egy SwipeControl, amely körbefuttatja az elemet, és lehetővé teszi a pöccintéses interakciót.

A SwipeItems erőforrásként definiálható a PodcastUserControlban. Ebben a példában a SwipeItems egy elemet kedvencként szolgáló parancsot tartalmaz.

<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>

A SwipeControl körbefuttatja az elemet, és lehetővé teszi a felhasználó számára, hogy a pöccintés kézmozdulattal kommunikáljon vele. Figyelje meg, hogy a SwipeControl jobb oldali elemeként tartalmaz egy hivatkozást a SwipeItemsre. A Kedvenc elem akkor jelenik meg, ha a felhasználó jobbról balra pöccint.

<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>

Amikor a felhasználó pöccintéssel meghívja a Kedvenc parancsot, a rendszer meghívja a meghívott metódust.

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);
}

Húzza le a frissítéshez

A lehúzással frissítés lehetővé teszi, hogy a felhasználó érintéses gesztussal lehúzzon egy adatgyűjteményt, hogy további adatokat töltsön be. További információért tekintse meg a lehúzással frissítő funkcióhoz tartozó cikket.

Digitális tollgyorsítók

A toll bemenete a mutató bemenetének pontosságát biztosítja. A felhasználók olyan gyakori műveleteket hajthatnak végre, mint például a helyi menük megnyitása tollalapú gyorsítókkal. Helyi menü megnyitásához a felhasználók koppinthatnak a képernyőn a hordógomb lenyomásával, vagy hosszan lenyomva a tartalmat. A felhasználók a tollal is rámutathatnak a tartalom fölé, így jobban megismerhetik a felhasználói felületet, például elemleírásokat jeleníthetnek meg, vagy megjeleníthetik az egérhez hasonló másodlagos rámutatási műveleteket.

Az alkalmazás tollbemenetre való optimalizálásához tekintse meg a toll és a toll interakciós cikkét .

Recommendations

• Győződjön meg arról, hogy a felhasználók minden windowsos eszközről elérhetik az összes parancsot.
• Adjon meg egy helyi menüt, amely hozzáférést biztosít a gyűjteményelemhez elérhető összes parancshoz.
• Adjon meg bemeneti gyorsítókat a gyakran használt parancsokhoz.
• Parancsok implementálásához használja az ICommand felületet .

Kapcsolódó témakörök

• Parancstervezési alapismeretek Windows-alkalmazásokhoz
• ICommand Interface
• Menük és helyi menük
• Ellop
• Húzza frissítéshez
• Toll és érintőceruza interakciója
• Xbox és TV számára történő tervezés