Vue d'ensemble du focusFocus Overview

Dans WPFWPF, il existe deux concepts principaux associés au focus : le focus clavier et le focus logique.In WPFWPF there are two main concepts that pertain to focus: keyboard focus and logical focus. Le focus clavier fait référence à l’élément qui reçoit une entrée au clavier, tandis que le focus logique fait référence à l’élément d’une portée de focus qui a le focus.Keyboard focus refers to the element that receives keyboard input and logical focus refers to the element in a focus scope that has focus. Ces concepts sont présentés en détail dans cette vue d’ensemble.These concepts are discussed in detail in this overview. Il est important de bien comprendre les différences entre ces concepts lors de la création d’applications complexes qui comportent plusieurs régions où le focus peut être obtenu.Understanding the difference in these concepts is important for creating complex applications that have multiple regions where focus can be obtained.

Les principales classes impliquées dans la gestion du focus sont les Keyboard (classe), le FocusManager classe et l’élément de base des classes, telles que UIElement et ContentElement.The major classes that participate in focus management are the Keyboard class, the FocusManager class, and the base element classes, such as UIElement and ContentElement. Pour plus d’informations sur les éléments de base, consultez Vue d’ensemble des éléments de base.For more information about the base elements, see the Base Elements Overview.

Le Keyboard classe concerne principalement le focus clavier et la FocusManager concerne principalement avec le focus logique, mais il ne s’agit pas d’une distinction absolue.The Keyboard class is concerned primarily with keyboard focus and the FocusManager is concerned primarily with logical focus, but this is not an absolute distinction. En effet, un élément qui a le focus clavier possède également le focus logique, tandis qu’un élément qui a le focus logique ne possède pas nécessairement le focus clavier.An element that has keyboard focus will also have logical focus, but an element that has logical focus does not necessarily have keyboard focus. Cela est évident lorsque vous utilisez la Keyboard classe pour définir l’élément qui a le focus clavier, pour qu’il définit également le focus logique sur l’élément.This is apparent when you use the Keyboard class to set the element that has keyboard focus, for it also sets logical focus on the element.

Focus clavierKeyboard Focus

Le focus clavier fait référence à l’élément qui reçoit l’entrée au clavier.Keyboard focus refers to the element that is currently receiving keyboard input. Un seul élément de l’ordinateur peut avoir le focus clavier.There can be only one element on the whole desktop that has keyboard focus. Dans WPFWPF, l’élément qui a le focus clavier aura IsKeyboardFocused défini sur true.In WPFWPF, the element that has keyboard focus will have IsKeyboardFocused set to true. La propriété statique FocusedElement sur la Keyboard classe obtient l’élément qui a le focus clavier.The static property FocusedElement on the Keyboard class gets the element that currently has keyboard focus.

Dans l’ordre pour un élément puisse obtenir le focus clavier, la Focusable et IsVisible propriétés sur les éléments de base doivent être définies sur true.In order for an element to obtain keyboard focus, the Focusable and the IsVisible properties on the base elements must be set to true. Certaines classes, telles que la Panel classe de base, ont Focusable définie sur false par défaut ; par conséquent, vous devez définir Focusable à true si vous souhaitez que ce type d’élément puisse obtenir le focus clavier.Some classes, such as the Panel base class, have Focusable set to false by default; therefore, you must set Focusable to true if you want such an element to be able to obtain keyboard focus.

Le focus clavier peut être obtenu par interaction de l’utilisateur avec l’Interface utilisateurUI (tabulation vers un élément ou clic de souris sur certains éléments, par exemple).Keyboard focus can be obtained through user interaction with the Interface utilisateurUI, such as tabbing to an element or clicking the mouse on certain elements. Le focus clavier peut également être obtenu par programmation à l’aide de la Focus méthode sur le Keyboard classe.Keyboard focus can also be obtained programmatically by using the Focus method on the Keyboard class. Le Focus méthode tente de donner le focus clavier de l’élément spécifié.The Focus method attempts to give the specified element keyboard focus. L’élément retourné correspond à l’élément qui a le focus clavier. Il peut s’agir d’un autre élément que celui demandé si l’objet de focus précédent ou nouveau bloque la demande.The returned element is the element that has keyboard focus, which might be a different element than requested if either the old or new focus object block the request.

L’exemple suivant utilise le Focus méthode pour définir le focus clavier sur un Button.The following example uses the Focus method to set keyboard focus on a 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

Le IsKeyboardFocused propriété sur les classes d’élément de base Obtient une valeur indiquant si l’élément a le focus clavier.The IsKeyboardFocused property on the base element classes gets a value indicating whether the element has keyboard focus. Le IsKeyboardFocusWithin propriété sur les classes d’élément de base Obtient une valeur indiquant si l’élément ou l’un de ses éléments enfants visuels a le focus clavier.The IsKeyboardFocusWithin property on the base element classes gets a value indicating whether the element or any one of its visual child elements has keyboard focus.

Lors de la définition du focus initial au démarrage de l’application, l’élément devant recevoir le focus doit être dans l’arborescence visuelle de la fenêtre initiale chargée par l’application, et l’élément doit avoir Focusable et IsVisible défini sur true.When setting initial focus at application startup, the element to receive focus must be in the visual tree of the initial window loaded by the application, and the element must have Focusable and IsVisible set to true. Est recommandé de définir le focus initial dans le Loaded Gestionnaire d’événements.The recommended place to set initial focus is in the Loaded event handler. Un Dispatcher rappel peut également être utilisé en appelant Invoke ou BeginInvoke.A Dispatcher callback can also be used by calling Invoke or BeginInvoke.

Focus logiqueLogical Focus

Le focus logique fait référence à la FocusManager.FocusedElement dans une portée de focus.Logical focus refers to the FocusManager.FocusedElement in a focus scope. Une portée de focus est un élément qui effectue le suivi de le FocusedElement dans son étendue.A focus scope is an element that keeps track of the FocusedElement within its scope. Quand le focus clavier quitte une portée de focus, l’élément ayant le focus perd le focus clavier, mais conserve le focus logique.When keyboard focus leaves a focus scope, the focused element will lose keyboard focus but will retain logical focus. Quand le focus clavier revient dans la portée de focus, l’élément ayant le focus obtient le focus clavier.When keyboard focus returns to the focus scope, the focused element will obtain keyboard focus. Cela permet au focus clavier de changer entre des portées de focus et de s’assurer que l’élément ayant le focus dans la portée de focus retrouve le focus clavier quand le focus revient dans la portée de focus.This allows for keyboard focus to be changed between multiple focus scopes but ensures that the focused element in the focus scope regains keyboard focus when focus returns to the focus scope.

Plusieurs éléments d’une application peuvent avoir le focus logique, mais un seul élément peut avoir le focus logique dans une portée de focus donnée.There can be multiple elements that have logical focus in an application, but there may only be one element that has logical focus in a particular focus scope.

Un élément ayant le focus clavier a également le focus logique pour la portée de focus à laquelle il appartient.An element that has keyboard focus has logical focus for the focus scope it belongs to.

Un élément peut être converti en portée de focus en langage XAML (eXtensible Application Markup Language)Extensible Application Markup Language (XAML) en définissant le FocusManager propriété jointe IsFocusScope à true.An element can be turned into a focus scope in langage XAML (eXtensible Application Markup Language)Extensible Application Markup Language (XAML) by setting the FocusManager attached property IsFocusScope to true. Dans le code, un élément peut être converti en portée de focus en appelant SetIsFocusScope.In code, an element can be turned into a focus scope by calling SetIsFocusScope.

L’exemple suivant effectue une StackPanel dans une portée de focus en définissant le IsFocusScope propriété jointe.The following example makes a StackPanel into a focus scope by setting the IsFocusScope attached property.

<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 la portée de focus pour l’élément spécifié.GetFocusScope returns the focus scope for the specified element.

Classes de WPFWPF constituant des portées de focus par défaut sont Window, MenuItem, ToolBar, et ContextMenu.Classes in WPFWPF which are focus scopes by default are Window, MenuItem, ToolBar, and ContextMenu.

GetFocusedElement Obtient l’élément ayant le focus pour la portée de focus spécifiée.GetFocusedElement gets the focused element for the specified focus scope. SetFocusedElement définit l’élément ayant le focus dans la portée de focus spécifiée.SetFocusedElement sets the focused element in the specified focus scope. SetFocusedElement sert généralement à définir l’élément ayant le focus initial.SetFocusedElement is typically used to set the initial focused element.

L’exemple suivant définit l’élément ayant le focus dans une portée de focus et obtient l’élément ayant le focus d’une portée de focus.The following example sets the focused element on a focus scope and gets the focused element of a focus scope.

// 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 clavierKeyboard Navigation

Le KeyboardNavigation classe est chargée d’implémenter la navigation du focus clavier par défaut lorsque l’utilisateur appuie sur une des touches de navigation.The KeyboardNavigation class is responsible for implementing default keyboard focus navigation when one of the navigation keys is pressed. Les touches de navigation sont : Clés de l’onglet, MAJ + TAB, CTRL + TAB, CTRL + MAJ + TAB, flèche haut, bas, flèche gauche et flèche droite.The navigation keys are: TAB, SHIFT+TAB, CTRL+TAB, CTRL+SHIFT+TAB, UPARROW, DOWNARROW, LEFTARROW, and RIGHTARROW keys.

Le comportement de navigation d’un conteneur de navigation peut être modifié en définissant le fichier joint KeyboardNavigation propriétés TabNavigation, ControlTabNavigation, et DirectionalNavigation.The navigation behavior of a navigation container can be changed by setting the attached KeyboardNavigation properties TabNavigation, ControlTabNavigation, and DirectionalNavigation. Ces propriétés sont de type KeyboardNavigationMode et les valeurs possibles sont Continue, Local, Contained, Cycle, Once, et None.These properties are of type KeyboardNavigationMode and the possible values are Continue, Local, Contained, Cycle, Once, and None. La valeur par défaut est Continue, ce qui signifie que l’élément n’est pas un conteneur de navigation.The default value is Continue, which means the element is not a navigation container.

L’exemple suivant crée un Menu avec un nombre de MenuItem objets.The following example creates a Menu with a number of MenuItem objects. Le TabNavigation propriété jointe est définie Cycle sur le Menu.The TabNavigation attached property is set to Cycle on the Menu. Lorsque le focus est modifié à l’aide de la touche tab dans le Menu, se détache de chaque élément et lorsque le dernier élément est atteint le focus retourne au premier élément.When focus is changed using the tab key within the Menu, focus will move from each element and when the last element is reached focus will return to the first element.

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

API supplémentaire pour travailler avec le focus sont MoveFocus et PredictFocus.Additional API to work with focus are MoveFocus and PredictFocus.

MoveFocus fait basculer le focus vers l’élément suivant dans l’application.MoveFocus changes focus to the next element in the application. Un TraversalRequest est utilisé pour spécifier la direction.A TraversalRequest is used to specify the direction. Le FocusNavigationDirection passé à MoveFocus spécifie les différentes directions du focus, tel que First, Last, Up et Down.The FocusNavigationDirection passed to MoveFocus specifies the different directions focus can be moved, such as First, Last, Up and Down.

L’exemple suivant utilise MoveFocus pour modifier l’élément ayant le focus.The following example uses MoveFocus to change the focused element.

// 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 celui-ci venait à être modifié.PredictFocus returns the object which would receive focus if focus were to be changed. Actuellement, seuls Up, Down, Left, et Right sont pris en charge par PredictFocus.Currently, only Up, Down, Left, and Right are supported by PredictFocus.

Événements de focusFocus Events

Les événements liés au focus clavier sont PreviewGotKeyboardFocus, GotKeyboardFocus et PreviewLostKeyboardFocus, LostKeyboardFocus.The events related to keyboard focus are PreviewGotKeyboardFocus, GotKeyboardFocus and PreviewLostKeyboardFocus, LostKeyboardFocus. Les événements sont définis en tant qu’événements attachés sur la Keyboard classe, mais sont plus facilement accessibles en tant qu’événements routés équivalents dans les classes d’élément de base.The events are defined as attached events on the Keyboard class, but are more readily accessible as equivalent routed events on the base element classes. Pour plus d’informations sur les événements, consultez Vue d’ensemble des événements routés.For more information about events, see the Routed Events Overview.

GotKeyboardFocus est déclenché lorsque l’élément obtient le focus clavier.GotKeyboardFocus is raised when the element obtains keyboard focus. LostKeyboardFocus est déclenché lorsque l’élément perd le focus clavier.LostKeyboardFocus is raised when the element loses keyboard focus. Si le PreviewGotKeyboardFocus événement ou la PreviewLostKeyboardFocusEvent événement est géré et Handled est défini sur true, puis le focus ne change pas.If the PreviewGotKeyboardFocus event or the PreviewLostKeyboardFocusEvent event is handled and Handled is set to true, then focus will not change.

L’exemple suivant attache GotKeyboardFocus et LostKeyboardFocus gestionnaires d’événements à un TextBox.The following example attaches GotKeyboardFocus and LostKeyboardFocus event handlers to a 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 clavier, la Background propriété de la TextBox est remplacée par LightBlue.When the TextBox obtains keyboard focus, the Background property of the TextBox is changed to 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 clavier, la Background propriété de la TextBox repasse au blanc.When the TextBox loses keyboard focus, the Background property of the TextBox is changed back to white.

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.The events related to logical focus are GotFocus and LostFocus. Ces événements sont définis sur le FocusManager en tant qu’événements attachés, mais la FocusManager n’expose pas les wrappers d’événements du CLR.These events are defined on the FocusManager as attached events, but the FocusManager does not expose CLR event wrappers. UIElement et ContentElement exposent ces événements plus facilement.UIElement and ContentElement expose these events more conveniently.

Voir aussiSee also