Partager via

Vue d’ensemble du focus

Dans WPF, il existe deux concepts principaux qui concernent le focus : le focus clavier et le focus logique. Le focus clavier fait référence à l’élément qui reçoit l’entrée du clavier et le focus logique fait référence à l’élément dans une étendue de focus qui a le focus. Ces concepts sont abordés en détail dans cette vue d’ensemble. La compréhension de la différence dans ces concepts est importante pour créer des applications complexes qui ont plusieurs régions où le focus peut être obtenu.

Les classes principales qui participent à la gestion du focus sont la Keyboard classe, la FocusManager classe et les classes d’éléments de base, telles que UIElement et ContentElement. Pour plus d’informations sur les éléments de base, consultez la vue d’ensemble des éléments de base.

La Keyboard classe se concentre principalement sur la mise au point clavier et la FocusManager classe s'occupe principalement du focus logique, mais ce n'est pas une distinction absolue. Un élément qui a le focus clavier aura également le focus logique, mais un élément qui a le focus logique n’a pas nécessairement le focus clavier. Cela est apparent lorsque vous utilisez la Keyboard classe pour définir l’élément qui a le focus clavier, car il définit également le focus logique sur l’élément.

Focus clavier

Le focus clavier fait référence à l’élément qui reçoit actuellement l’entrée du clavier. Il ne peut y avoir qu’un seul élément sur l’ensemble du bureau recevant le focus du clavier. Dans WPF, l’élément qui a le focus clavier aura IsKeyboardFocused réglé à true. La propriété statique FocusedElement de la classe Keyboard obtient l'élément qui a actuellement le focus du clavier.

Pour qu’un élément obtienne le focus clavier, les propriétés Focusable et IsVisible des éléments de base doivent être définies à true. Certaines classes, telles que la classe de base Panel, ont Focusable défini sur false par défaut ; par conséquent, vous devez définir Focusable sur true si vous souhaitez qu'un tel élément puisse obtenir le focus clavier.

Le focus clavier peut être obtenu par le biais d’une interaction utilisateur avec l’interface utilisateur, par exemple en naviguant avec la touche tabulation jusqu'à un élément ou en cliquant sur certains éléments. Le focus clavier peut également être obtenu par programmation à l’aide de la méthode Focus sur la classe Keyboard. La méthode Focus tente d’accorder le focus clavier à l’élément spécifié. L’élément retourné est l’élément qui a le focus clavier, qui peut être un élément différent de celui demandé si l’ancien ou le nouvel objet focus bloque la requête.

L’exemple suivant utilise la méthode Focus pour définir le focus clavier sur un Button.

private void OnLoaded(object sender, RoutedEventArgs e)
{
    // Sets keyboard focus on the first Button in the sample.
    Keyboard.Focus(firstButton);
}

Private Sub OnLoaded(ByVal sender As Object, ByVal e As RoutedEventArgs)
    ' Sets keyboard focus on the first Button in the sample.
    Keyboard.Focus(firstButton)
End Sub

La IsKeyboardFocused propriété sur les classes d’éléments de base obtient une valeur indiquant si l’élément a le focus clavier. La propriété IsKeyboardFocusWithin des classes d'éléments de base renvoie une valeur indiquant si l'élément ou l'un de ses éléments enfants visuels est focalisé par le clavier.

Lorsque vous définissez le focus initial au démarrage de l'application, l'élément qui doit recevoir le focus doit se trouver dans l'arborescence visuelle de la fenêtre initiale chargée par l'application, et l’élément doit avoir Focusable et IsVisible définis sur true. L’emplacement recommandé pour définir le focus initial se trouve dans le gestionnaire d’événements Loaded . Un Dispatcher rappel peut également être utilisé en appelant Invoke ou BeginInvoke.

Focus logique

Le focus logique fait référence au FocusManager.FocusedElement dans une étendue de focus. Un périmètre de focalisation est un élément qui suit une entité FocusedElement dans son périmètre. Lorsque le focus clavier quitte une portée de focus, l'élément focalisé perd le focus clavier, mais conserve le focus logique. Lorsque le focus clavier revient au périmètre du focus, l'élément focalisé obtient le focus clavier. Cela permet de changer le focus clavier entre plusieurs étendues de focus, mais garantit que l’élément concentré dans l’étendue de focus récupère le focus clavier lorsque le focus revient à l’étendue du focus.

Il peut y avoir plusieurs éléments qui ont le focus logique dans une application, mais il ne peut y avoir qu’un seul élément qui a le focus logique dans une étendue de focus particulière.

Un élément ayant la focalisation du clavier a la focalisation logique pour la portée du focus à laquelle il appartient.

Un élément peut être transformé en scope de mise au point dans XAML (Extensible Application Markup Language) en définissant la propriété jointe FocusManagerIsFocusScope à true. Dans le code, un élément peut être transformé en une étendue de focus en appelant SetIsFocusScope.

L’exemple suivant transforme un StackPanel en une portée de focus en définissant la propriété associée IsFocusScope.

<StackPanel Name="focusScope1" 
            FocusManager.IsFocusScope="True"
            Height="200" Width="200">
  <Button Name="button1" Height="50" Width="50"/>
  <Button Name="button2" Height="50" Width="50"/>
</StackPanel>

StackPanel focuseScope2 = new StackPanel();
FocusManager.SetIsFocusScope(focuseScope2, true);

Dim focuseScope2 As New StackPanel()
FocusManager.SetIsFocusScope(focuseScope2, True)

GetFocusScope retourne l’étendue du focus pour l’élément spécifié.

Les classes dans WPF qui sont des étendues de focus par défaut sont Window, MenuItem, ToolBaret ContextMenu.

GetFocusedElement obtient l'élément focalisé pour la portée de focus spécifiée. SetFocusedElement définit l’élément prioritaire dans l’étendue de focus spécifiée. SetFocusedElement est généralement utilisé pour définir l’élément prioritaire initial.

L’exemple suivant définit l’élément focalisé sur une étendue de focus et obtient l’élément focalisé d’une étendue de focus.

// Sets the focused element in focusScope1
// focusScope1 is a StackPanel.
FocusManager.SetFocusedElement(focusScope1, button2);

// Gets the focused element for focusScope 1
IInputElement focusedElement = FocusManager.GetFocusedElement(focusScope1);

' Sets the focused element in focusScope1
' focusScope1 is a StackPanel.
FocusManager.SetFocusedElement(focusScope1, button2)

' Gets the focused element for focusScope 1
Dim focusedElement As IInputElement = FocusManager.GetFocusedElement(focusScope1)

Navigation au clavier

La KeyboardNavigation classe est responsable de l’implémentation de la navigation par défaut du focus clavier lorsque l’une des touches de navigation est enfoncée. Les touches de navigation sont les suivantes : Tab, Maj+Tab, Ctrl+Tab, Ctrl+Maj+Tab, UPARROW, DownARROW, LEFTARROW et RIGHTARROW.

Le comportement de navigation d’un conteneur de navigation peut être modifié en définissant les propriétés KeyboardNavigationjointes TabNavigation , ControlTabNavigationet DirectionalNavigation. Ces propriétés sont de type KeyboardNavigationMode et les valeurs possibles sont Continue, , LocalContained, Cycle, , Onceet None. La valeur par défaut est Continue, ce qui signifie que l’élément n’est pas un conteneur de navigation.

L'exemple suivant crée un Menu avec un nombre d'objets MenuItem. La TabNavigation propriété jointe est réglée à Cycle sur le Menu. Lorsque le focus est modifié à l’aide de la touche tabulation dans le Menu, le focus se déplace de chaque élément et lorsque le dernier élément est atteint, le focus revient au premier élément.

<Menu KeyboardNavigation.TabNavigation="Cycle">
  <MenuItem Header="Menu Item 1" />
  <MenuItem Header="Menu Item 2" />
  <MenuItem Header="Menu Item 3" />
  <MenuItem Header="Menu Item 4" />
</Menu>

Menu navigationMenu = new Menu();
MenuItem item1 = new MenuItem();
MenuItem item2 = new MenuItem();
MenuItem item3 = new MenuItem();
MenuItem item4 = new MenuItem();

navigationMenu.Items.Add(item1);
navigationMenu.Items.Add(item2);
navigationMenu.Items.Add(item3);
navigationMenu.Items.Add(item4);

KeyboardNavigation.SetTabNavigation(navigationMenu,
    KeyboardNavigationMode.Cycle);

Dim navigationMenu As New Menu()
Dim item1 As New MenuItem()
Dim item2 As New MenuItem()
Dim item3 As New MenuItem()
Dim item4 As New MenuItem()

navigationMenu.Items.Add(item1)
navigationMenu.Items.Add(item2)
navigationMenu.Items.Add(item3)
navigationMenu.Items.Add(item4)

KeyboardNavigation.SetTabNavigation(navigationMenu, KeyboardNavigationMode.Cycle)

Une API supplémentaire pour travailler avec focus est MoveFocus et PredictFocus.

MoveFocus modifie le focus sur l’élément suivant dans l’application. A TraversalRequest est utilisé pour spécifier la direction. FocusNavigationDirection passé à MoveFocus spécifie les différentes directions dans lesquelles le focus peut être déplacé, comme First, Last, Up et Down.

L’exemple suivant utilise MoveFocus pour modifier l’élément prioritaire.

// Creating a FocusNavigationDirection object and setting it to a
// local field that contains the direction selected.
FocusNavigationDirection focusDirection = _focusMoveValue;

// MoveFocus takes a TraveralReqest as its argument.
TraversalRequest request = new TraversalRequest(focusDirection);

// Gets the element with keyboard focus.
UIElement elementWithFocus = Keyboard.FocusedElement as UIElement;

// Change keyboard focus.
if (elementWithFocus != null)
{
    elementWithFocus.MoveFocus(request);
}

' Creating a FocusNavigationDirection object and setting it to a
' local field that contains the direction selected.
Dim focusDirection As FocusNavigationDirection = _focusMoveValue

' MoveFocus takes a TraveralReqest as its argument.
Dim request As New TraversalRequest(focusDirection)

' Gets the element with keyboard focus.
Dim elementWithFocus As UIElement = TryCast(Keyboard.FocusedElement, UIElement)

' Change keyboard focus.
If elementWithFocus IsNot Nothing Then
    elementWithFocus.MoveFocus(request)
End If

PredictFocus retourne l’objet qui recevrait le focus si le focus devait être modifié. Actuellement, seuls Up, , DownLeft, et Right sont pris en charge par PredictFocus.

Événements de focus

Les événements liés au focus clavier sont PreviewGotKeyboardFocus, GotKeyboardFocus et PreviewLostKeyboardFocus, LostKeyboardFocus. Les événements sont définis comme des événements attachés sur la Keyboard classe, mais sont plus facilement accessibles en tant qu’événements routés équivalents sur les classes d’éléments de base. Pour plus d’informations sur les événements, consultez la vue d’ensemble des événements routés.

GotKeyboardFocus est déclenché lorsque l’élément obtient le focus clavier. LostKeyboardFocus est déclenché lorsque l’élément perd le focus clavier. Si l’événement PreviewGotKeyboardFocus ou l’événement PreviewLostKeyboardFocusEvent est géré et Handled est défini à true, alors le focus ne change pas.

L’exemple suivant attache les gestionnaires d’événements GotKeyboardFocus et LostKeyboardFocus à un TextBox.

<Border BorderBrush="Black" BorderThickness="1"
        Width="200" Height="100" Margin="5">
  <StackPanel>
    <Label HorizontalAlignment="Center" Content="Type Text In This TextBox" />
    <TextBox Width="175"
             Height="50" 
             Margin="5"
             TextWrapping="Wrap"
             HorizontalAlignment="Center"
             VerticalScrollBarVisibility="Auto"
             GotKeyboardFocus="TextBoxGotKeyboardFocus"
             LostKeyboardFocus="TextBoxLostKeyboardFocus"
             KeyDown="SourceTextKeyDown"/>
  </StackPanel>
</Border>

Lorsque le TextBox obtient le focus du clavier, la Background propriété du TextBox est modifiée en LightBlue.

private void TextBoxGotKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
{
    TextBox source = e.Source as TextBox;

    if (source != null)
    {
        // Change the TextBox color when it obtains focus.
        source.Background = Brushes.LightBlue;

        // Clear the TextBox.
        source.Clear();
    }
}

Private Sub TextBoxGotKeyboardFocus(ByVal sender As Object, ByVal e As KeyboardFocusChangedEventArgs)
    Dim source As TextBox = TryCast(e.Source, TextBox)

    If source IsNot Nothing Then
        ' Change the TextBox color when it obtains focus.
        source.Background = Brushes.LightBlue

        ' Clear the TextBox.
        source.Clear()
    End If
End Sub

Lorsque le TextBox perd le focus du clavier, la propriété Background du TextBox est remplacée par le blanc.

private void TextBoxLostKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
{
    TextBox source = e.Source as TextBox;

    if (source != null)
    {
        // Change the TextBox color when it loses focus.
        source.Background = Brushes.White;

        // Set the  hit counter back to zero and updates the display.
        this.ResetCounter();
    }
}

Private Sub TextBoxLostKeyboardFocus(ByVal sender As Object, ByVal e As KeyboardFocusChangedEventArgs)
    Dim source As TextBox = TryCast(e.Source, TextBox)

    If source IsNot Nothing Then
        ' Change the TextBox color when it loses focus.
        source.Background = Brushes.White

        ' Set the  hit counter back to zero and updates the display.
        Me.ResetCounter()
    End If
End Sub

Les événements liés au focus logique sont GotFocus et LostFocus. Ces événements sont définis dans le contexte des FocusManager événements attachés, mais le FocusManager n’expose pas de wrappers d’événements CLR. UIElement et ContentElement rendent l'exposition de ces événements plus pratique.

Voir aussi

  • Last updated on