Zdarzenia klawiatury

Zdarzenia klawiatury i fokus

Następujące zdarzenia klawiatury mogą wystąpić zarówno dla klawiatur sprzętowych, jak i dotykowych.

Kontrolki w interfejsie użytkownika generują zdarzenia klawiatury tylko wtedy, gdy mają fokus wejściowy. Pojedyncza kontrolka zyskuje fokus, gdy użytkownik klika lub naciska bezpośrednio na tę kontrolkę w obszarze układu lub używa klawisza Tabulacji, aby przejść do sekwencji przejść w obszarze zawartości.

Możesz również wywołać metodę koncentracji uwagi kontrolki, aby wymusić fokus. Jest to konieczne w przypadku implementowania skrótów, ponieważ fokus klawiatury nie jest domyślnie ustawiany podczas ładowania interfejsu użytkownika. Aby uzyskać więcej informacji, zobacz przykład skrótów w dalszej części tego tematu.

Aby kontrolka odbierała fokus danych wejściowych, musi być włączona, widoczna i ma wartości właściwości IsTabStop i HitTestVisibletrue. Jest to domyślny stan większości kontrolek. Gdy kontrolka ma fokus wejściowy, może zgłaszać zdarzenia związane z wprowadzaniem klawiatury i reagować na nie, jak opisano w dalszej części tematu. Możesz również odpowiedzieć na kontrolkę, która odbiera lub traci fokus, obsługując zdarzenia GotFocus i LostFocus .

Domyślnie sekwencja tabulacji kontrolek jest kolejnością, w której są wyświetlane w języku XAML (Extensible Application Markup Language). Można jednak zmodyfikować tę kolejność przy użyciu właściwości TabIndex . Aby uzyskać więcej informacji, zobacz Implementowanie ułatwień dostępu za pomocą klawiatury.

Programy obsługi zdarzeń klawiatury

Procedura obsługi zdarzeń wejściowych implementuje delegata, który udostępnia następujące informacje:

• Nadawca zdarzenia. Nadawca zgłasza obiekt, w którym jest dołączony program obsługi zdarzeń.
• Dane zdarzenia. W przypadku zdarzeń klawiatury te dane będą instancją KeyRoutedEventArgs. Pełnomocnik obsługi to KeyEventHandler. Najbardziej istotne właściwości keyRoutedEventArgs dla większości scenariuszy obsługi to Key i prawdopodobnie KeyStatus.
• OriginalSource. Ponieważ zdarzenia klawiatury są zdarzeniami trasowanymi, dane zdarzenia udostępniają OriginalSource. Jeśli celowo pozwalasz zdarzeniom przemieszczać się w górę po drzewie obiektów, OriginalSource jest czasami ważniejszym obiektem niż nadawca. Jednak zależy to od projektu. Aby uzyskać więcej informacji na temat używania elementu OriginalSource , a nie nadawcy, zobacz sekcję "Zdarzenia kierowane za pomocą klawiatury" w tym temacie lub Omówienie zdarzeń i zdarzeń kierowanych.

Dołączanie obsługi zdarzeń klawiatury

Możesz dołączyć funkcje obsługi zdarzeń klawiatury dla dowolnego obiektu, który zawiera zdarzenie jako składnik. Obejmuje to dowolną klasę pochodną UIElement . W poniższym przykładzie XAML pokazano, jak dołączyć programy obsługi zdarzenia KeyUp dla Grid.

<Grid KeyUp="Grid_KeyUp">
  ...
</Grid>

Program obsługi zdarzeń można również dołączyć w kodzie. Aby uzyskać więcej informacji, zobacz Zdarzenia i zdarzenia routowane omówienie.

Definiowanie procedury obsługi zdarzeń klawiatury

Poniższy przykład przedstawia niekompletną definicję procedury obsługi zdarzeń dla procedury obsługi zdarzeń KeyUp , która została dołączona w poprzednim przykładzie.

void Grid_KeyUp(object sender, KeyRoutedEventArgs e)
{
    //handling code here
}

Private Sub Grid_KeyUp(ByVal sender As Object, ByVal e As KeyRoutedEventArgs)
    ' handling code here
End Sub

void MyProject::MainPage::Grid_KeyUp(
  Platform::Object^ sender,
  Windows::UI::Xaml::Input::KeyRoutedEventArgs^ e)
  {
      //handling code here
  }

Korzystanie z usługi KeyRoutedEventArgs

Wszystkie zdarzenia klawiatury używają KeyRoutedEventArgs jako danych zdarzenia, a KeyRoutedEventArgs zawiera następujące właściwości:

• Klucz
• KeyStatus
• Obsługiwane
• OriginalSource (dziedziczone z RoutedEventArgs)

Klucze wirtualne

Zdarzenie KeyDown jest wywoływane, jeśli klawisz zostanie naciśnięty. Podobnie, KeyUp jest wywoływane, gdy klawisz zostanie zwolniony. Zazwyczaj nasłuchujesz zdarzeń, aby przetworzyć określoną wartość klucza. Aby określić, który klawisz jest naciśnięty lub zwolniony, sprawdź wartość klawisza w danych zdarzenia. Klucz zwraca wartość VirtualKey . Wyliczenie VirtualKey zawiera wszystkie obsługiwane klucze.

Klucze modyfikatora

Klawisze modyfikujące, takie jak Ctrl lub Shift, są to klawisze, które użytkownicy zazwyczaj naciskają w połączeniu z innymi klawiszami. Aplikacja może używać tych kombinacji jako niestandardowych skrótów klawiaturowych do wywoływania poleceń aplikacji.

Kombinacje skrótów można wykrywać w programach obsługi zdarzeń KeyDown i KeyUp . Gdy wystąpi zdarzenie klawiatury dla klawisza niemodyfikującego, możesz następnie sprawdzić, czy klawisz modyfikujący jest w stanie naciśnięcia.

Alternatywnie funkcja GetKeyState()CoreWindow (uzyskana za pośrednictwem CoreWindow.GetForCurrentThread()) może również służyć do sprawdzania stanu modyfikatora, gdy naciśnięty jest klawisz niemodyfikujący.

Poniższe przykłady implementują tę drugą metodę, a także zawierają kod wycinkowy dla pierwszej implementacji.

Przykład klawiszy skrótów

W poniższym przykładzie pokazano, jak zaimplementować zestaw niestandardowych skrótów. W tym przykładzie użytkownicy mogą kontrolować odtwarzanie multimediów przy użyciu przycisków Odtwarzania, Wstrzymywania i Zatrzymywania albo Ctrl+P, Ctrl+A i Ctrl+S skrótów klawiaturowych. Przycisk XAML pokazuje skróty przy użyciu etykietek narzędzi i właściwości AutomationProperties w etykietach przycisków. Ta samodzielna dokumentacja jest ważna, aby zwiększyć użyteczność i dostępność aplikacji. Aby uzyskać więcej informacji, zobacz Ułatwienia dostępu za pomocą klawiatury.

Pamiętaj również, że strona ustawia fokus wejściowy na sam po załadowaniu. Bez tego kroku żadna kontrolka nie ma początkowego fokusu wejściowego, a aplikacja nie zgłasza zdarzeń wejściowych do momentu ręcznego ustawienia fokusu wejściowego (na przykład przez naciśnięcie tabulatora lub kliknięcie kontrolki).

<Grid KeyDown="Grid_KeyDown">

  <Grid.RowDefinitions>
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
  </Grid.RowDefinitions>

  <MediaElement x:Name="DemoMovie" Source="xbox.wmv"
    Width="500" Height="500" Margin="20" HorizontalAlignment="Center" />

  <StackPanel Grid.Row="1" Margin="10"
    Orientation="Horizontal" HorizontalAlignment="Center">

    <Button x:Name="PlayButton" Click="MediaButton_Click"
      ToolTipService.ToolTip="Shortcut key: Ctrl+P"
      AutomationProperties.AcceleratorKey="Control P">
      <TextBlock>Play</TextBlock>
    </Button>

    <Button x:Name="PauseButton" Click="MediaButton_Click"
      ToolTipService.ToolTip="Shortcut key: Ctrl+A"
      AutomationProperties.AcceleratorKey="Control A">
      <TextBlock>Pause</TextBlock>
    </Button>

    <Button x:Name="StopButton" Click="MediaButton_Click"
      ToolTipService.ToolTip="Shortcut key: Ctrl+S"
      AutomationProperties.AcceleratorKey="Control S">
      <TextBlock>Stop</TextBlock>
    </Button>

  </StackPanel>

</Grid>

//showing implementations but not header definitions
void MainPage::OnNavigatedTo(NavigationEventArgs^ e)
{
    (void) e;    // Unused parameter
    this->Loaded+=ref new RoutedEventHandler(this,&MainPage::ProgrammaticFocus);
}
void MainPage::ProgrammaticFocus(Object^ sender, RoutedEventArgs^ e) 
{
    this->Focus(Windows::UI::Xaml::FocusState::Programmatic);
}

void KeyboardSupport::MainPage::MediaButton_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
{
    FrameworkElement^ fe = safe_cast<FrameworkElement^>(sender);
    if (fe->Name == "PlayButton") {DemoMovie->Play();}
    if (fe->Name == "PauseButton") {DemoMovie->Pause();}
    if (fe->Name == "StopButton") {DemoMovie->Stop();}
}


bool KeyboardSupport::MainPage::IsCtrlKeyPressed()
{
    auto ctrlState = CoreWindow::GetForCurrentThread()->GetKeyState(VirtualKey::Control);
    return (ctrlState & CoreVirtualKeyStates::Down) == CoreVirtualKeyStates::Down;
}

void KeyboardSupport::MainPage::Grid_KeyDown(Platform::Object^ sender, Windows::UI::Xaml::Input::KeyRoutedEventArgs^ e)
{
    if (e->Key == VirtualKey::Control) isCtrlKeyPressed = true;
}


void KeyboardSupport::MainPage::Grid_KeyUp(Platform::Object^ sender, Windows::UI::Xaml::Input::KeyRoutedEventArgs^ e)
{
    if (IsCtrlKeyPressed()) 
    {
        if (e->Key==VirtualKey::P) { DemoMovie->Play(); }
        if (e->Key==VirtualKey::A) { DemoMovie->Pause(); }
        if (e->Key==VirtualKey::S) { DemoMovie->Stop(); }
    }
}

protected override void OnNavigatedTo(NavigationEventArgs e)
{
    // Set the input focus to ensure that keyboard events are raised.
    this.Loaded += delegate { this.Focus(FocusState.Programmatic); };
}

private void MediaButton_Click(object sender, RoutedEventArgs e)
{
    switch ((sender as Button).Name)
    {
        case "PlayButton": DemoMovie.Play(); break;
        case "PauseButton": DemoMovie.Pause(); break;
        case "StopButton": DemoMovie.Stop(); break;
    }
}

private static bool IsCtrlKeyPressed()
{
    var ctrlState = CoreWindow.GetForCurrentThread().GetKeyState(VirtualKey.Control);
    return (ctrlState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
}

private void Grid_KeyDown(object sender, KeyRoutedEventArgs e)
{
    if (IsCtrlKeyPressed())
    {
        switch (e.Key)
        {
            case VirtualKey.P: DemoMovie.Play(); break;
            case VirtualKey.A: DemoMovie.Pause(); break;
            case VirtualKey.S: DemoMovie.Stop(); break;
        }
    }
}

Private isCtrlKeyPressed As Boolean
Protected Overrides Sub OnNavigatedTo(e As Navigation.NavigationEventArgs)

End Sub

Private Function IsCtrlKeyPressed As Boolean
    Dim ctrlState As CoreVirtualKeyStates = CoreWindow.GetForCurrentThread().GetKeyState(VirtualKey.Control);
    Return (ctrlState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
End Function

Private Sub Grid_KeyDown(sender As Object, e As KeyRoutedEventArgs)
    If IsCtrlKeyPressed() Then
        Select Case e.Key
            Case Windows.System.VirtualKey.P
                DemoMovie.Play()
            Case Windows.System.VirtualKey.A
                DemoMovie.Pause()
            Case Windows.System.VirtualKey.S
                DemoMovie.Stop()
        End Select
    End If
End Sub

Private Sub MediaButton_Click(sender As Object, e As RoutedEventArgs)
    Dim fe As FrameworkElement = CType(sender, FrameworkElement)
    Select Case fe.Name
        Case "PlayButton"
            DemoMovie.Play()
        Case "PauseButton"
            DemoMovie.Pause()
        Case "StopButton"
            DemoMovie.Stop()
    End Select
End Sub

Zdarzenia kierowane za pomocą klawiatury

Niektóre zdarzenia to zdarzenia kierowane, w tym KeyDown i KeyUp. Zdarzenia kierowane używają strategii routingu bubbling. Strategia routingu bąbelkowego oznacza, że zdarzenie pochodzi z obiektu podrzędnego, a następnie jest przekazywane do kolejnych obiektów nadrzędnych w drzewie obiektów. Stanowi to kolejną okazję do obsługi tego samego zdarzenia i interakcji z tymi samymi danymi zdarzenia.

Rozważmy następujący przykład XAML, który obsługuje zdarzenia KeyUp dla Canvas i dwóch obiektów typu Button. W takim przypadku, jeśli zwolnisz klawisz, gdy fokus jest przytrzymywany przez dowolny obiekt Button, zgłaszane jest zdarzenie KeyUp. Zdarzenie jest następnie przekazywane do nadrzędnego Canvas.

<StackPanel KeyUp="StackPanel_KeyUp">
  <Button Name="ButtonA" Content="Button A"/>
  <Button Name="ButtonB" Content="Button B"/>
  <TextBlock Name="statusTextBlock"/>
</StackPanel>

W poniższym przykładzie pokazano, jak zaimplementować procedurę obsługi zdarzeń KeyUp dla odpowiedniej zawartości XAML w poprzednim przykładzie.

void StackPanel_KeyUp(object sender, KeyRoutedEventArgs e)
{
    statusTextBlock.Text = String.Format(
        "The key {0} was pressed while focus was on {1}",
        e.Key.ToString(), (e.OriginalSource as FrameworkElement).Name);
}

Zwróć uwagę na użycie właściwości OriginalSource w poprzedniej procedurze obsługi. Tutaj OriginalSource wskazuje obiekt, który spowodował zdarzenie. Nie można umieścić obiektu StackPanel , ponieważ element StackPanel nie jest kontrolką i nie może mieć fokusu. Tylko jeden z dwóch przycisków w StackPanel mógł potencjalnie wywołać zdarzenie, ale który? Element OriginalSource służy do odróżnienia rzeczywistego obiektu źródła zdarzeń, jeśli obsługujesz zdarzenie w obiekcie nadrzędnym.

Właściwość 'Handled' w danych zdarzenia

W zależności od strategii obsługi zdarzeń może być konieczne, aby tylko jedna procedura obsługi zdarzeń zareagowała na zdarzenie bubbling. Jeśli na przykład masz określoną procedurę obsługi KeyUp dołączoną do jednego z kontrolek Przycisk , będzie to miało pierwszą okazję do obsługi tego zdarzenia. W takim przypadku możesz nie chcieć, aby panel nadrzędny także obsługiwał to zdarzenie. W tym scenariuszu można użyć właściwości Obsługiwane w danych zdarzenia.

Celem właściwości Obsłużone w klasie danych zdarzeń kierowanych jest powiadomienie, że inna procedura obsługująca zarejestrowana wcześniej na ścieżce zdarzeń została już wykonana. Ma to wpływ na działanie systemu obsługi zdarzeń. Po ustawieniu Handled na true w procedurze obsługi zdarzeń, to zdarzenie zatrzymuje routing i nie jest wysyłane do kolejnych elementów nadrzędnych.

AddHandler i już obsługiwane zdarzenia klawiatury

Możesz użyć specjalnej techniki dołączania procedur obsługi, które mogą działać na zdarzeniach, które zostały już oznaczone jako obsługiwane. Ta technika używa metody AddHandler do rejestrowania programów obsługi zamiast używać atrybutów XAML lub składni właściwej dla danego języka do dodawania programów obsługi, takich jak += w języku C#.

Ogólne ograniczenie tej techniki polega na tym, że interfejs API programu AddHandler przyjmuje parametr typu RoutedEvent identyfikujący zdarzenie kierowane. Nie wszystkie zdarzenia kierowane zawierają identyfikator RoutedEvent , a zatem to zagadnienie wpływa na to, które zdarzenia kierowane mogą być nadal obsługiwane w obsłużonej sprawie. Zdarzenia KeyDown i KeyUp mają identyfikatory zdarzeń pośrednich (KeyDownEvent i KeyUpEvent) w UIElement. Jednak inne zdarzenia, takie jak TextBox.TextChanged, nie mają identyfikatorów zdarzeń kierowanych i dlatego nie mogą być używane z techniką AddHandler.

Przesłanianie zdarzeń i zachowania klawiatury

Możesz zastąpić kluczowe zdarzenia dla określonych kontrolek (takich jak GridView), aby zapewnić spójną nawigację fokusu dla różnych urządzeń wejściowych, w tym klawiatury i gamepad.

W poniższym przykładzie tworzymy podklasę kontrolki i zastępujemy zachowanie metody KeyDown, aby przenieść fokus do zawartości GridView po naciśnięciu dowolnego klawisza strzałki.

  public class CustomGridView : GridView
  {
    protected override void OnKeyDown(KeyRoutedEventArgs e)
    {
      // Override arrow key behaviors.
      if (e.Key != Windows.System.VirtualKey.Left && e.Key !=
        Windows.System.VirtualKey.Right && e.Key !=
          Windows.System.VirtualKey.Down && e.Key !=
            Windows.System.VirtualKey.Up)
              base.OnKeyDown(e);
      else
        FocusManager.TryMoveFocus(FocusNavigationDirection.Down);
    }
  }

Komendanta

Niewielka liczba elementów interfejsu użytkownika zapewnia wbudowaną obsługę poleceń. Polecenie używa zdarzeń routingu powiązanych z danymi wejściowymi w swojej podstawowej implementacji. Umożliwia przetwarzanie powiązanych danych wejściowych interfejsu użytkownika, takich jak określona akcja wskaźnika lub określony klucz akceleratora, wywołując jedną procedurę obsługi poleceń.

Jeśli polecenie jest dostępne dla elementu interfejsu użytkownika, rozważ użycie jego interfejsów API do poleceń zamiast pojedynczych zdarzeń wejściowych. Aby uzyskać więcej informacji, zobacz ButtonBase.Command.

Można również zaimplementować funkcję ICommand , aby hermetyzować funkcje poleceń wywoływane z zwykłych programów obsługi zdarzeń. Dzięki temu można używać poleceń nawet wtedy, gdy nie ma dostępnej właściwości Command .

Wprowadzanie tekstu i kontrolki

Niektóre kontrolki reagują na zdarzenia klawiatury przy użyciu własnego mechanizmu obsługi. Na przykład TextBox to kontrolka przeznaczona do przechwytywania, a następnie wizualnie reprezentująca tekst wprowadzony za pomocą klawiatury. Używa KeyUp i KeyDown we własnej logice do przechwytywania naciśnięć klawiszy, a następnie zgłasza własne zdarzenie TextChanged, jeśli tekst rzeczywiście uległ zmianie.

Nadal można ogólnie dodawać procedury obsługi zdarzeń KeyUp i KeyDown do kontrolki TextBox lub dowolnej powiązanej kontrolki, która jest przeznaczona do przetwarzania wprowadzania tekstu. Jednak w ramach zamierzonego projektu kontrolka może nie odpowiadać na wszystkie wartości klucza, które są kierowane do niego za pośrednictwem kluczowych zdarzeń. Zachowanie jest specyficzne dla każdej kontrolki.

Na przykład ButtonBase (klasa podstawowa dla Button) przetwarza KeyUp, aby można było sprawdzić naciśnięcie klawisza Spacja lub Enter. ButtonBase traktuje KeyUp jako odpowiednik naciśnięcia lewego przycisku myszy w celu wygenerowania zdarzenia Click. To przetwarzanie zdarzenia jest realizowane, gdy metoda ButtonBase zastępuje metodę wirtualną OnKeyUp. W jej implementacji ustawia wartość Obsłużona na wartość true. Wynikiem jest to, że każdy element nadrzędny przycisku, który nasłuchuje zdarzenia klucza, w przypadku paska spacji, nie otrzyma już obsługiwanego zdarzenia dla własnych procedur obsługi.

Innym przykładem jest TextBox. Niektóre klawisze, takie jak strzałki, nie są traktowane jako tekst przez TextBox i są uważane za specyficzne dla zachowania interfejsu użytkownika kontrolki. Pole TextBox oznacza te przypadki zdarzeń jako obsłużone.

Kontrolki niestandardowe mogą implementować własne podobne zachowanie zastąpienia dla kluczowych zdarzeń przez zastąpienie onKeyDown / OnKeyUp. Jeśli kontrolka niestandardowa przetwarza określone klucze akceleratora lub ma zachowanie sterowania lub ustawiania fokusu podobne do scenariusza opisanego dla kontrolki TextBox, powinieneś umieścić tę logikę we własnych przesłonięciach OnKeyDown / OnKeyUp.

Klawiatura dotykowa

Kontrolki wprowadzania tekstu zapewniają automatyczną obsługę klawiatury dotykowej. Gdy użytkownik ustawia fokus wejściowy na kontrolkę tekstu przy użyciu wprowadzania dotykowego, klawiatura dotykowa jest wyświetlana automatycznie. Gdy fokus wejściowy nie znajduje się w kontrolce tekstu, klawiatura dotykowa jest ukryta.

Gdy pojawi się klawiatura dotykowa, automatycznie zmienia położenie interfejsu użytkownika, aby upewnić się, że element ukierunkowany pozostaje widoczny. Może to spowodować, że inne ważne obszary interfejsu użytkownika zostaną przesunięte poza ekran. Można jednak wyłączyć zachowanie domyślne i wprowadzić własne korekty interfejsu użytkownika po wyświetleniu klawiatury dotykowej. Aby uzyskać więcej informacji, zobacz przykład klawiatury dotykowej.

Jeśli tworzysz kontrolkę niestandardową, która wymaga wprowadzania tekstu, ale nie pochodzi ze standardowej kontrolki wprowadzania tekstu, możesz dodać obsługę klawiatury dotykowej, implementując poprawne wzorce kontrolek automatyzacji interfejsu użytkownika. Aby uzyskać więcej informacji, zobacz przykład klawiatury dotykowej.

Naciśnięcie na klawiaturze dotykowej wywołuje zdarzenia KeyDown i KeyUp , podobnie jak naciśnięcia na klawiaturach sprzętowych. Jednak klawiatura dotykowa nie będzie zgłaszać zdarzeń wejściowych dla Ctrl+A, Ctrl+Z, Ctrl+X, Ctrl+C i Ctrl+V, które są zarezerwowane do manipulacji tekstem w kontrolce wejściowej.

Możesz znacznie szybciej i łatwiej użytkownikom wprowadzać dane w aplikacji, ustawiając zakres wejściowy kontrolki tekstu tak, aby był zgodny z rodzajem danych, które mają być wprowadzane przez użytkownika. Zakres wejściowy zawiera wskazówkę dotyczącą typu wprowadzania tekstu oczekiwanego przez kontrolkę, dzięki czemu system może zapewnić wyspecjalizowany układ klawiatury dotykowej dla typu wejściowego. Jeśli na przykład pole tekstowe jest używane tylko do wprowadzania 4-cyfrowego numeru PIN, ustaw właściwość InputScope na Number. Dzięki temu system wyświetli układ klawiatury liczbowej, co ułatwia użytkownikowi wprowadzenie numeru PIN. Aby uzyskać więcej szczegółów, zobacz Używanie zakresu wprowadzania w celu zmiany klawiatury dotykowej.

Powiązane artykuły

Developers

• interakcje z klawiaturą
• Identyfikowanie urządzeń wejściowych
• Reagowanie na obecność klawiatury dotykowej

Projektantów

• Wskazówki dotyczące projektowania klawiatury

Samples

• Przykład klawiatury dotykowej
• Podstawowy przykład danych wejściowych
• Przykład danych wejściowych o małym opóźnieniu
• Przykładowe wizualizacje stanu fokusu

Archiwalne przykłady

• Przykład danych wejściowych
• Dane wejściowe: przykład możliwości urządzenia
• Dane wejściowe: Przykład klawiatury dotykowej
• Reagowanie na wygląd klawiatury ekranowej - przykład
• przykład edytowania tekstu XAML