Vue d'ensemble des entréesInput Overview

Le Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) sous-système fournit une API puissante pour obtenir des entrées à partir d’un large éventail d’appareils, notamment la souris, le clavier, le toucher et le stylet.The Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) subsystem provides a powerful API for obtaining input from a variety of devices, including the mouse, keyboard, touch, and stylus. Cette rubrique décrit les services fournis par WPFWPF et explique l’architecture des systèmes d’entrée.This topic describes the services provided by WPFWPF and explains the architecture of the input systems.

API d’entréeInput API

L’exposition principale de l’API d’entrée se trouve dans les classes UIElementd' ContentElementéléments de base FrameworkContentElement:,, FrameworkElementet.The primary input API exposure is found on the base element classes: UIElement, ContentElement, FrameworkElement, and FrameworkContentElement. 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 Base Elements Overview. Ces classes fournissent la fonctionnalité pour les événements d’entrée associés aux appuis sur les boutons, aux boutons de la souris, à la roulette de la souris, au déplacement de la souris, à la gestion du focus et à la capture de la souris, entre autres.These classes provide functionality for input events related to key presses, mouse buttons, mouse wheel, mouse movement, focus management, and mouse capture, to name a few. En plaçant l’API d’entrée sur les éléments de base, au lieu de traiter tous les événements d’entrée en tant que service, l’architecture d’entrée permet de sourcer les événements d’entrée par un objet particulier dans l’interface utilisateur et de prendre en charge un schéma de routage d’événements dans lequel plusieurs éléments ont un élément opp. ortunity pour gérer un événement d’entrée.By placing the input API on the base elements, rather than treating all input events as a service, the input architecture enables the input events to be sourced by a particular object in the UI, and to support an event routing scheme whereby more than one element has an opportunity to handle an input event. De nombreux événements d’entrée sont associés à une paire d’événements.Many input events have a pair of events associated with them. Par exemple, l’événement touche enfoncée est associé KeyDown aux PreviewKeyDown événements et.For example, the key down event is associated with the KeyDown and PreviewKeyDown events. La différence entre ces événements réside dans la façon dont ils sont acheminés vers l’élément cible.The difference in these events is in how they are routed to the target element. Les événements Preview parcourent l’arborescence d’éléments de l’élément racine vers l’élément cible.Preview events tunnel down the element tree from the root element to the target element. Les événements de propagation se propagent de l’élément cible vers l’élément racine.Bubbling events bubble up from the target element to the root element. Le routage d’événements dans WPFWPF est discuté plus en détail plus loin dans cet article et dans la rubrique Vue d’ensemble des événements routés.Event routing in WPFWPF is discussed in more detail later in this overview and in the Routed Events Overview.

Classes de souris et de clavierKeyboard and Mouse Classes

En plus de l’API d’entrée sur les classes d’éléments de Keyboard base, Mouse la classe et les classes fournissent une API supplémentaire pour l’utilisation de l’entrée au clavier et à la souris.In addition to the input API on the base element classes, the Keyboard class and Mouse classes provide additional API for working with keyboard and mouse input.

Les exemples d’API d’entrée Keyboard sur la classe Modifiers sont la propriété, qui ModifierKeys retourne le actuellement enfoncé et IsKeyDown la méthode, qui détermine si une touche spécifiée est enfoncée.Examples of input API on the Keyboard class are the Modifiers property, which returns the ModifierKeys currently pressed, and the IsKeyDown method, which determines whether a specified key is pressed.

L’exemple suivant utilise la GetKeyStates méthode pour déterminer si un Key est à l’état inactif.The following example uses the GetKeyStates method to determine if a Key is in the down state.

// Uses the Keyboard.GetKeyStates to determine if a key is down.
// A bitwise AND operation is used in the comparison. 
// e is an instance of KeyEventArgs.
if ((Keyboard.GetKeyStates(Key.Return) & KeyStates.Down) > 0)
{
    btnNone.Background = Brushes.Red;
}
' Uses the Keyboard.GetKeyStates to determine if a key is down.
' A bitwise AND operation is used in the comparison. 
' e is an instance of KeyEventArgs.
If (Keyboard.GetKeyStates(Key.Return) And KeyStates.Down) > 0 Then
    btnNone.Background = Brushes.Red

Les exemples d’API d’entrée Mouse sur la MiddleButtonclasse sont, qui obtiennent l’état du bouton central de la souris DirectlyOver, et, qui obtient l’élément sur lequel le pointeur de la souris se trouve actuellement.Examples of input API on the Mouse class are MiddleButton, which obtains the state of the middle mouse button, and DirectlyOver, which gets the element the mouse pointer is currently over.

L’exemple suivant détermine si le LeftButton sur la souris est dans l' Pressed État.The following example determines whether the LeftButton on the mouse is in the Pressed state.

if (Mouse.LeftButton == MouseButtonState.Pressed)
{
    UpdateSampleResults("Left Button Pressed");
}
If Mouse.LeftButton = MouseButtonState.Pressed Then
    UpdateSampleResults("Left Button Pressed")
End If

Les Mouse classes Keyboard et sont décrites plus en détail dans cette vue d’ensemble.The Mouse and Keyboard classes are covered in more detail throughout this overview.

Entrée du styletStylus Input

WPFWPFa intégré la Stylusprise en charge de.has integrated support for the Stylus. Est une entrée de stylet rendue populaire par Tablet PCTablet PCle. StylusThe Stylus is a pen input made popular by the Tablet PCTablet PC. WPFWPFles applications peuvent traiter le stylet comme une souris à l’aide de l’API WPFWPF Mouse, mais elle expose également une abstraction d’appareil de stylet qui utilise un modèle semblable au clavier et à la souris.applications can treat the stylus as a mouse by using the mouse API, but WPFWPF also exposes a stylus device abstraction that use a model similar to the keyboard and mouse. Toutes les API liées à Stylus contiennent le mot «Stylus».All stylus-related APIs contain the word "Stylus".

Étant donné que le stylet peut agir comme une souris, les applications qui prennent uniquement en charge l’entrée de la souris peuvent quand même bénéficier automatiquement d’un certain niveau de prise en charge du stylet.Because the stylus can act as a mouse, applications that support only mouse input can still obtain some level of stylus support automatically. Quand le stylet est utilisé de cette manière, l’application a la possibilité de gérer l’événement de stylet approprié, et elle gère ensuite l’événement de souris correspondant.When the stylus is used in such a manner, the application is given the opportunity to handle the appropriate stylus event and then handles the corresponding mouse event. En outre, les services de niveau supérieur tels que l’entrée d’encre sont également disponibles grâce à l’abstraction du stylet.In addition, higher-level services such as ink input are also available through the stylus device abstraction. Pour plus d’informations sur l’encre comme entrée, consultez Débuter avec l’encre.For more information about ink as input, see Getting Started with Ink.

Routage d’événementsEvent Routing

Un FrameworkElement peut contenir d’autres éléments en tant qu’éléments enfants dans son modèle de contenu, formant une arborescence d’éléments.A FrameworkElement can contain other elements as child elements in its content model, forming a tree of elements. Dans WPFWPF, l’élément parent peut participer à l’entrée dirigée vers ses éléments enfants ou à d’autres descendants en gérant les événements.In WPFWPF, the parent element can participate in input directed to its child elements or other descendants by handing events. Ceci est particulièrement utile pour la création de contrôles à partir de contrôles plus petits, un processus appelé « composition de contrôle » ou simplement « composition ».This is especially useful for building controls out of smaller controls, a process known as "control composition" or "compositing." Pour plus d’informations sur les arborescences d’éléments et sur les relations entre les arborescences d’éléments et les itinéraires des événements, consultez Arborescences dans WPF.For more information about element trees and how element trees relate to event routes, see Trees in WPF.

Le routage d’événements est le processus qui consiste à transférer des événements à plusieurs éléments, afin qu’un objet ou un élément sur l’itinéraire puisse choisir de fournir une réponse significative (par l’intermédiaire de la gestion) à un événement ayant pu avoir comme source un autre élément.Event routing is the process of forwarding events to multiple elements, so that a particular object or element along the route can choose to offer a significant response (through handling) to an event that might have been sourced by a different element. Les événements routés utilisent l’un des trois mécanismes de routage suivants : direct, par propagation et par tunneling.Routed events use one of three routing mechanisms: direct, bubbling, and tunneling. Avec le routage direct, l’élément source est le seul élément notifié, et l’événement n’est pas acheminé vers d’autres éléments.In direct routing, the source element is the only element notified, and the event is not routed to any other elements. Toutefois, l’événement routé direct offre toujours des fonctionnalités supplémentaires qui sont uniquement présentes pour les événements routés, par opposition aux événements CLR standard.However, the direct routed event still offers some additional capabilities that are only present for routed events as opposed to standard CLR events. La propagation remonte l’arborescence d’éléments en notifiant d’abord l’élément à l’origine de l’événement, puis l’élément parent, et ainsi de suite.Bubbling works up the element tree by first notifying the element that sourced the event, then the parent element, and so on. Le tunneling commence à la racine de l’arborescence d’éléments puis descend, en finissant à l’élément source d’origine.Tunneling starts at the root of the element tree and works down, ending with the original source element. Pour plus d’informations sur les événements routés, consultez Vue d’ensemble des événements routés.For more information about routed events, see Routed Events Overview.

Les événements d’entrée WPFWPF existent généralement par paires, constituées d’un événement de tunneling et d’un événement de propagation.WPFWPF input events generally come in pairs that consists of a tunneling event and a bubbling event. Les événements de tunneling se distinguent des événements de propagation par le préfixe « Preview ».Tunneling events are distinguished from bubbling events with the "Preview" prefix. Par exemple, PreviewMouseMove est la version de tunneling d’un événement de déplacement MouseMove de la souris et est la version de propagation de cet événement.For instance, PreviewMouseMove is the tunneling version of a mouse move event and MouseMove is the bubbling version of this event. Cet appariement d’événements est une convention implémentée au niveau de l’élément. Ce n’est pas une fonctionnalité inhérente au système d’événements WPFWPF.This event pairing is a convention that is implemented at the element level and is not an inherent capability of the WPFWPF event system. Pour plus d’informations, consultez la section Événements d’entrée WPF dans Vue d’ensemble des événements routés.For details, see the WPF Input Events section in Routed Events Overview.

Gestion des événements d’entréeHandling Input Events

Pour recevoir une entrée sur un élément, un gestionnaire d’événements doit être associé à cet événement particulier.To receive input on an element, an event handler must be associated with that particular event. Dans XAMLXAML, c’est simple : vous référencez le nom de l’événement en tant qu’attribut de l’élément qui écoute cet événement.In XAMLXAML this is straightforward: you reference the name of the event as an attribute of the element that will be listening for this event. Ensuite, vous affectez comme valeur de l’attribut le nom du gestionnaire d’événements que vous définissez, en fonction d’un délégué.Then, you set the value of the attribute to the name of the event handler that you define, based on a delegate. Le gestionnaire d’événements doit être écrit dans du code C# tel que et peut être inclus dans un fichier code-behind.The event handler must be written in code such as C# and can be included in a code-behind file.

Les événements de clavier se produisent quand le système d’exploitation signale des actions de touches qui ont lieu pendant que le focus clavier se trouve sur un élément.Keyboard events occur when the operating system reports key actions that occur while keyboard focus is on an element. Les événements de souris et de stylet appartiennent chacun à deux catégories : les événements qui signalent des changements de la position du pointeur par rapport à l’élément, et les événements qui signalent des changements d’état des boutons du périphérique.Mouse and stylus events each fall into two categories: events that report changes in pointer position relative to the element, and events that report changes in the state of device buttons.

Exemple d’événement d’entrée de clavierKeyboard Input Event Example

L’exemple suivant détecte un appui sur la touche de direction gauche.The following example listens for a left arrow key press. Un StackPanel est créé avec un Button.A StackPanel is created that has a Button. Un gestionnaire d’événements pour écouter l’appui sur la touche de direction gauche est Button attaché à l’instance.An event handler to listen for the left arrow key press is attached to the Button instance.

La première section de l’exemple crée le StackPanel et le Button et attache le gestionnaire d’événements pour le KeyDown.The first section of the example creates the StackPanel and the Button and attaches the event handler for the KeyDown.

<StackPanel>
  <Button Background="AliceBlue"
          KeyDown="OnButtonKeyDown"
          Content="Button1"/>
</StackPanel>
// Create the UI elements.
StackPanel keyboardStackPanel = new StackPanel();
Button keyboardButton1 = new Button();

// Set properties on Buttons.
keyboardButton1.Background = Brushes.AliceBlue;
keyboardButton1.Content = "Button 1";

// Attach Buttons to StackPanel.
keyboardStackPanel.Children.Add(keyboardButton1);

// Attach event handler.
keyboardButton1.KeyDown += new KeyEventHandler(OnButtonKeyDown);
' Create the UI elements.
Dim keyboardStackPanel As New StackPanel()
Dim keyboardButton1 As New Button()

' Set properties on Buttons.
keyboardButton1.Background = Brushes.AliceBlue
keyboardButton1.Content = "Button 1"

' Attach Buttons to StackPanel.
keyboardStackPanel.Children.Add(keyboardButton1)

' Attach event handler.
AddHandler keyboardButton1.KeyDown, AddressOf OnButtonKeyDown

La deuxième section est écrite en code et définit le gestionnaire d’événements.The second section is written in code and defines the event handler. Quand la touche de direction gauche est enfoncée et que le a le Button focus clavier, le gestionnaire s’exécute et la Background couleur du Button est modifiée.When the left arrow key is pressed and the Button has keyboard focus, the handler runs and the Background color of the Button is changed. Si la touche est enfoncée, mais qu’il ne s’agit pas de Background la touche Button de direction gauche, la couleur du est rétablie à sa couleur de départ.If the key is pressed, but it is not the left arrow key, the Background color of the Button is changed back to its starting color.

private void OnButtonKeyDown(object sender, KeyEventArgs e)
{
    Button source = e.Source as Button;
    if (source != null)
    {
        if (e.Key == Key.Left)
        {
            source.Background = Brushes.LemonChiffon;
        }
        else
        {
            source.Background = Brushes.AliceBlue;
        }
    }
}
Private Sub OnButtonKeyDown(ByVal sender As Object, ByVal e As KeyEventArgs)
    Dim source As Button = TryCast(e.Source, Button)
    If source IsNot Nothing Then
        If e.Key = Key.Left Then
            source.Background = Brushes.LemonChiffon
        Else
            source.Background = Brushes.AliceBlue
        End If
    End If
End Sub

Exemple d’événement d’entrée de sourisMouse Input Event Example

Dans l’exemple suivant, la Background couleur d’un Button est modifiée lorsque le pointeur de la souris Buttonentre dans le.In the following example, the Background color of a Button is changed when the mouse pointer enters the Button. La Background couleur est restaurée lorsque la souris quitte Buttonle.The Background color is restored when the mouse leaves the Button.

La première section de l’exemple crée le StackPanel et le Button contrôle et attache les gestionnaires d’événements pour Buttonles MouseEnter événements et MouseLeave à.The first section of the example creates the StackPanel and the Button control and attaches the event handlers for the MouseEnter and MouseLeave events to the Button.

<StackPanel>
  <Button Background="AliceBlue"
          MouseEnter="OnMouseExampleMouseEnter"
          MouseLeave="OnMosueExampleMouseLeave">Button
          
  </Button>
</StackPanel>
// Create the UI elements.
StackPanel mouseMoveStackPanel = new StackPanel();
Button mouseMoveButton = new Button();

// Set properties on Button.
mouseMoveButton.Background = Brushes.AliceBlue;
mouseMoveButton.Content = "Button";

// Attach Buttons to StackPanel.
mouseMoveStackPanel.Children.Add(mouseMoveButton);

// Attach event handler.
mouseMoveButton.MouseEnter += new MouseEventHandler(OnMouseExampleMouseEnter);
mouseMoveButton.MouseLeave += new MouseEventHandler(OnMosueExampleMouseLeave);
' Create the UI elements.
Dim mouseMoveStackPanel As New StackPanel()
Dim mouseMoveButton As New Button()

' Set properties on Button.
mouseMoveButton.Background = Brushes.AliceBlue
mouseMoveButton.Content = "Button"

' Attach Buttons to StackPanel.
mouseMoveStackPanel.Children.Add(mouseMoveButton)

' Attach event handler.
AddHandler mouseMoveButton.MouseEnter, AddressOf OnMouseExampleMouseEnter
AddHandler mouseMoveButton.MouseLeave, AddressOf OnMosueExampleMouseLeave

La deuxième section est écrite en code et définit le gestionnaire d’événements.The second section of the example is written in code and defines the event handlers. ButtonLorsque la souris entre dans, la Background couleur du Button est remplacée par SlateGray.When the mouse enters the Button, the Background color of the Button is changed to SlateGray. Lorsque la souris quitte le Button Background , la couleur du Button est rétablie AliceBlue.When the mouse leaves the Button, the Background color of the Button is changed back to AliceBlue.

private void OnMouseExampleMouseEnter(object sender, MouseEventArgs e)
{
    // Cast the source of the event to a Button.
    Button source = e.Source as Button;

    // If source is a Button.
    if (source != null)
    {
        source.Background = Brushes.SlateGray;
    }
}
Private Sub OnMouseExampleMouseEnter(ByVal sender As Object, ByVal e As MouseEventArgs)
    ' Cast the source of the event to a Button.
    Dim source As Button = TryCast(e.Source, Button)

    ' If source is a Button.
    If source IsNot Nothing Then
        source.Background = Brushes.SlateGray
    End If
End Sub
private void OnMosueExampleMouseLeave(object sender, MouseEventArgs e)
{
    // Cast the source of the event to a Button.
    Button source = e.Source as Button;

    // If source is a Button.
    if (source != null)
    {
        source.Background = Brushes.AliceBlue;
    }
}
Private Sub OnMosueExampleMouseLeave(ByVal sender As Object, ByVal e As MouseEventArgs)
    ' Cast the source of the event to a Button.
    Dim source As Button = TryCast(e.Source, Button)

    ' If source is a Button.
    If source IsNot Nothing Then
        source.Background = Brushes.AliceBlue
    End If
End Sub

Entrée de texteText Input

L' TextInput événement vous permet d’écouter l’entrée de texte d’une manière indépendante du périphérique.The TextInput event enables you to listen for text input in a device-independent manner. Le clavier est le principal moyen d’entrer du texte, mais la voix, l’écriture manuscrite et d’autres périphériques d’entrée peuvent aussi générer du texte.The keyboard is the primary means of text input, but speech, handwriting, and other input devices can generate text input also.

Pour les entrées au WPFWPF clavier, envoie d' KeyDown abord les événements appropriés /. KeyUpFor keyboard input, WPFWPF first sends the appropriate KeyDown/KeyUp events. Si ces événements ne sont pas gérés et que la clé est textuelle (au lieu d’une touche de contrôle telle que des flèches directionnelles ou TextInput des touches de fonction), un événement est déclenché.If those events are not handled and the key is textual (rather than a control key such as directional arrows or function keys), then a TextInput event is raised. Il n’existe pas toujours un mappage un-à-un simple KeyDown entre TextInput / KeyUp des événements et, car plusieurs séquences de touches peuvent générer un caractère unique d’entrée de texte et les séquences de touches peuvent générer plusieurs caractères celles.There is not always a simple one-to-one mapping between KeyDown/KeyUp and TextInput events because multiple keystrokes can generate a single character of text input and single keystrokes can generate multi-character strings. Cela est particulièrement vrai pour les langues telles que le chinois, le japonais et le coréen qui utilisent des éditeurs de méthode d’entrée (IME) pour générer les milliers de caractères possibles dans les alphabets correspondants.This is especially true for languages such as Chinese, Japanese, and Korean which use Input Method Editors (IMEs) to generate the thousands of possible characters in their corresponding alphabets.

Lorsque WPFWPF envoie un KeyUp Key.System TextInput événement, aKey la valeur si les séquences de touches peuvent faire partie d’un événement (en appuyant sur ALT + S, par exemple). / KeyDownWhen WPFWPF sends a KeyUp/KeyDown event, Key is set to Key.System if the keystrokes could become part of a TextInput event (if ALT+S is pressed, for example). Cela permet au code dans KeyDown un gestionnaire d’événements de Key.System vérifier et, s’il existe, de conserver le traitement du gestionnaire de TextInput l’événement déclenché par la suite.This allows code in a KeyDown event handler to check for Key.System and, if found, leave processing for the handler of the subsequently raised TextInput event. Dans ces cas, les différentes propriétés de l' TextCompositionEventArgs argument peuvent être utilisées pour déterminer les séquences de touches d’origine.In these cases, the various properties of the TextCompositionEventArgs argument can be used to determine the original keystrokes. De même, si un IME est actif, Key a la valeur et Key.ImeProcessed ImeProcessedKey donne la séquence d’origine ou les séquences de touches.Similarly, if an IME is active, Key has the value of Key.ImeProcessed, and ImeProcessedKey gives the original keystroke or keystrokes.

L’exemple suivant définit un gestionnaire pour l' Click événement et un gestionnaire pour l' KeyDown événement.The following example defines a handler for the Click event and a handler for the KeyDown event.

Le premier segment de code ou de balisage crée l’interface utilisateur.The first segment of code or markup creates the user interface.

<StackPanel KeyDown="OnTextInputKeyDown">
  <Button Click="OnTextInputButtonClick"
          Content="Open" />
  <TextBox> . . . </TextBox>
</StackPanel>
// Create the UI elements.
StackPanel textInputStackPanel = new StackPanel();
Button textInputeButton = new Button();
TextBox textInputTextBox = new TextBox();
textInputeButton.Content = "Open";

// Attach elements to StackPanel.
textInputStackPanel.Children.Add(textInputeButton);
textInputStackPanel.Children.Add(textInputTextBox);

// Attach event handlers.
textInputStackPanel.KeyDown += new KeyEventHandler(OnTextInputKeyDown);
textInputeButton.Click += new RoutedEventHandler(OnTextInputButtonClick);
' Create the UI elements.
Dim textInputStackPanel As New StackPanel()
Dim textInputeButton As New Button()
Dim textInputTextBox As New TextBox()
textInputeButton.Content = "Open"

' Attach elements to StackPanel.
textInputStackPanel.Children.Add(textInputeButton)
textInputStackPanel.Children.Add(textInputTextBox)

' Attach event handlers.
AddHandler textInputStackPanel.KeyDown, AddressOf OnTextInputKeyDown
AddHandler textInputeButton.Click, AddressOf OnTextInputButtonClick

Le deuxième segment de code contient les gestionnaires d’événements.The second segment of code contains the event handlers.

private void OnTextInputKeyDown(object sender, KeyEventArgs e)
{
    if (e.Key == Key.O && Keyboard.Modifiers == ModifierKeys.Control)
    {
        handle();
        e.Handled = true;
    }
}

private void OnTextInputButtonClick(object sender, RoutedEventArgs e)
{
    handle();
    e.Handled = true;
} 

public void handle()
{
    MessageBox.Show("Pretend this opens a file");
}
Private Sub OnTextInputKeyDown(ByVal sender As Object, ByVal e As KeyEventArgs)
    If e.Key = Key.O AndAlso Keyboard.Modifiers = ModifierKeys.Control Then
        handle()
        e.Handled = True
    End If
End Sub

Private Sub OnTextInputButtonClick(ByVal sender As Object, ByVal e As RoutedEventArgs)
    handle()
    e.Handled = True
End Sub

Public Sub handle()
    MessageBox.Show("Pretend this opens a file")
End Sub

Étant donné que les événements d’entrée propagent StackPanel l’itinéraire des événements, le reçoit l’entrée quel que soit l’élément qui a le focus clavier.Because input events bubble up the event route, the StackPanel receives the input regardless of which element has keyboard focus. Le TextBox contrôle est notifié en premier et OnTextInputKeyDown le gestionnaire est appelé uniquement si TextBox le n’a pas géré l’entrée.The TextBox control is notified first and the OnTextInputKeyDown handler is called only if the TextBox did not handle the input. Si l' PreviewKeyDown événement est utilisé à la place KeyDown de l’événement OnTextInputKeyDown , le gestionnaire est appelé en premier.If the PreviewKeyDown event is used instead of the KeyDown event, the OnTextInputKeyDown handler is called first.

Dans cet exemple, la logique de gestion est écrite deux fois : une fois pour Ctrl+O et une autre fois pour l’événement de clic du bouton.In this example, the handling logic is written two times—one time for CTRL+O, and again for button's click event. Vous pouvez simplifier cela en utilisant des commandes, au lieu de traiter les événements d’entrée directement.This can be simplified by using commands, instead of handling the input events directly. Les commandes sont traitées dans cet article et dans Vue d’ensemble des commandes.Commands are discussed in this overview and in Commanding Overview.

Entrée tactile et manipulationTouch and Manipulation

Du nouveau matériel et une nouvelle API dans le système d’exploitation Windows 7 permettent aux applications de recevoir une entrée à partir de plusieurs entrées tactiles simultanément.New hardware and API in the Windows 7 operating system provide applications the ability to receive input from multiple touches simultaneously. WPFWPF permet aux applications de détecter et de répondre aux entrées tactiles d’une manière similaire à d’autres types d’entrée, tels que la souris ou le clavier, en déclenchant des événements quand les entrées tactiles se produisent.enables applications to detect and respond to touch in a manner similar to responding to other input, such as the mouse or keyboard, by raising events when touch occurs.

WPFWPF expose deux types d’événements quand des entrées tactiles se produisent : les événements tactiles et les événements de manipulation.exposes two types of events when touch occurs: touch events and manipulation events. Les événements tactiles fournissent des données brutes relatives à chaque doigt sur un écran tactile et à leur déplacement.Touch events provide raw data about each finger on a touchscreen and its movement. Les événements de manipulation interprètent l’entrée comme des actions spécifiques.Manipulation events interpret the input as certain actions. Les deux types d’événements sont présentés dans cette section.Both types of events are discussed in this section.

PrérequisPrerequisites

Vous devez disposer des composants suivants pour développer une application qui répond aux entrées tactiles.You need the following components to develop an application that responds to touch.

  • Visual Studio 2010.Visual Studio 2010.

  • Windows 7.Windows 7.

  • Un appareil, tel qu’un écran tactile, qui prend en charge l’interface tactile Windows.A device, such as a touchscreen, that supports Windows Touch.

TerminologieTerminology

Les termes suivants sont utilisés quand l’entrée tactile est abordée.The following terms are used when touch is discussed.

  • L’entrée tactile est un type d’entrée d’utilisateur reconnu par Windows 7.Touch is a type of user input that is recognized by Windows 7. En règle générale, l’entrée tactile est démarrée en plaçant des doigts sur un écran tactile.Usually, touch is initiated by putting fingers on a touch-sensitive screen. Notez que les appareils tels que les pavés tactiles qui sont courants sur les ordinateurs portables ne gèrent pas l’entrée tactile si l’appareil ne fait que convertir la position et le déplacement du doigt en tant qu’entrée de la souris.Note that devices such as a touchpad that is common on laptop computers do not support touch if the device merely converts the finger's position and movement as mouse input.

  • L’interaction tactile multipoint est une entrée tactile qui se produit simultanément à partir de plusieurs points.Multitouch is touch that occurs from more than one point simultaneously. Windows 7 et WPFWPF prennent en charge l’interaction tactile multipoint.Windows 7 and WPFWPF supports multitouch. Chaque fois que l’entrée tactile est abordée dans la documentation WPFWPF, les concepts s’appliquent à l’interaction tactile multipoint.Whenever touch is discussed in the documentation for WPFWPF, the concepts apply to multitouch.

  • Une manipulation se produit quand l’entrée tactile est interprétée comme une action physique appliquée à un objet.A manipulation occurs when touch is interpreted as a physical action that is applied to an object. Dans WPFWPF, les événements de manipulation interprètent l’entrée comme une manipulation de translation, d’expansion ou de rotation.In WPFWPF, manipulation events interpret input as a translation, expansion, or rotation manipulation.

  • Un touch device représente un périphérique qui génère une entrée tactile, par exemple un seul doigt sur un écran tactile.A touch device represents a device that produces touch input, such as a single finger on a touchscreen.

Contrôles qui répondent aux entrées tactilesControls that Respond to Touch

Les contrôles suivants peuvent être parcourus en faisant glisser un doigt sur le contrôle, s’il a du contenu qui défile hors de l’affichage.The following controls can be scrolled by dragging a finger across the control if it has content that is scrolled out of view.

Définit la propriété ScrollViewer.PanningMode jointe qui vous permet de spécifier si le panoramique tactile est activé horizontalement, verticalement, les deux ou aucune des deux. ScrollViewerThe ScrollViewer defines the ScrollViewer.PanningMode attached property that enables you to specify whether touch panning is enabled horizontally, vertically, both, or neither. La ScrollViewer.PanningDeceleration propriété spécifie la vitesse de ralentissement du défilement lorsque l’utilisateur soulève le doigt de l’écran tactile.The ScrollViewer.PanningDeceleration property specifies how quickly the scrolling slows down when the user lifts the finger from the touchscreen. La ScrollViewer.PanningRatio propriété jointe spécifie le ratio de décalage de défilement pour traduire le décalage de manipulation.The ScrollViewer.PanningRatio attached property specifies the ratio of scrolling offset to translate manipulation offset.

Événements tactilesTouch Events

Les classes de base UIElement, UIElement3D, et ContentElement, définissent les événements auxquels vous pouvez vous abonner pour que votre application réponde à Touch.The base classes, UIElement, UIElement3D, and ContentElement, define events that you can subscribe to so your application will respond to touch. Les événements tactiles sont utiles quand votre application interprète l’entrée tactile comme autre chose que la manipulation d’un objet.Touch events are useful when your application interprets touch as something other than manipulating an object. Par exemple, une application qui permet à un utilisateur de dessiner avec un ou plusieurs doigts doit s’abonner aux événements tactiles.For example, an application that enables a user to draw with one or more fingers would subscribe to touch events.

Les trois classes définissent les événements suivants, qui se comportent de la même manière quelle que soit la classe de définition.All three classes define the following events, which behave similarly, regardless of the defining class.

Comme les événements de clavier et de souris, les événements tactiles sont des événements routés.Like keyboard and mouse events, the touch events are routed events. Les événements qui commencent par Preview sont des événements de tunneling et les événements qui commencent par Touch sont des événements de propagation.The events that begin with Preview are tunneling events and the events that begin with Touch are bubbling events. Pour plus d’informations sur les événements routés, consultez Vue d’ensemble des événements routés.For more information about routed events, see Routed Events Overview. Lorsque vous gérez ces événements, vous pouvez récupérer la position de l’entrée, par rapport à tout élément, en appelant GetTouchPoint la GetIntermediateTouchPoints méthode ou.When you handle these events, you can get the position of the input, relative to any element, by calling the GetTouchPoint or GetIntermediateTouchPoints method.

Pour comprendre l’interaction entre les événements tactiles, considérez le scénario où un utilisateur place un doigt sur un élément, déplace son doigt dans l’élément, puis retire son doigt de l’élément.To understand the interaction among the touch events, consider the scenario where a user puts one finger on an element, moves the finger in the element, and then lifts the finger from the element. L’illustration suivante montre l’exécution des événements de propagation (les événements de tunneling sont omis par souci de simplicité).The following illustration shows the execution of the bubbling events (the tunneling events are omitted for simplicity).

Séquence d’événements tactiles. Événements tactilesThe sequence of touch events. Touch events

La liste suivante décrit la séquence des événements dans l’illustration précédente.The following list describes the sequence of the events in the preceding illustration.

  1. L' TouchEnter événement se produit une fois lorsque l’utilisateur place un doigt sur l’élément.The TouchEnter event occurs one time when the user puts a finger on the element.

  2. L' TouchDown événement se produit une fois.The TouchDown event occurs one time.

  3. L' TouchMove événement se produit plusieurs fois lorsque l’utilisateur déplace le doigt dans l’élément.The TouchMove event occurs multiple times as the user moves the finger within the element.

  4. L' TouchUp événement se produit une fois lorsque l’utilisateur soulève le doigt de l’élément.The TouchUp event occurs one time when the user lifts the finger from the element.

  5. L' TouchLeave événement se produit une fois.The TouchLeave event occurs one time.

Quand plusieurs doigts sont utilisés, les événements se produisent pour chaque doigt.When more than two fingers are used, the events occur for each finger.

Événements de manipulationManipulation Events

Dans les cas où une application permet à un utilisateur de manipuler un objet UIElement , la classe définit des événements de manipulation.For cases where an application enables a user to manipulate an object, the UIElement class defines manipulation events. Contrairement aux événements tactiles qui signalent simplement la position de l’entrée tactile, les événements de manipulation signalent comment l’entrée peut être interprétée.Unlike the touch events that simply report the position of touch, the manipulation events report how the input can be interpreted. Il existe trois types de manipulations : translation, expansion et rotation.There are three types of manipulations, translation, expansion, and rotation. La liste suivante décrit comment appeler les trois types de manipulations.The following list describes how to invoke the three types of manipulations.

  • Placez un doigt sur un objet et déplacez le doigt sur l’écran tactile pour appeler une manipulation de translation.Put a finger on an object and move the finger across the touchscreen to invoke a translation manipulation. Cela déplace habituellement l’objet.This usually moves the object.

  • Placez deux doigts sur un objet et rapprochez ou éloignez les doigts pour appeler une manipulation d’expansion.Put two fingers on an object and move the fingers closer together or farther apart from one another to invoke an expansion manipulation. Cela redimensionne habituellement l’objet.This usually resizes the object.

  • Placez deux doigts sur un objet et faites pivoter les doigts pour appeler une manipulation de rotation.Put two fingers on an object and rotate the fingers around each other to invoke a rotation manipulation. Cela fait pivoter habituellement l’objet.This usually rotates the object.

Plusieurs types de manipulations peuvent se produire simultanément.More than one type of manipulation can occur simultaneously.

Quand vous faites en sorte que des objets répondent à des manipulations, vous pouvez donner à l’objet une apparence d’inertie.When you cause objects to respond to manipulations, you can have the object appear to have inertia. Ainsi, vos objets peuvent simuler le monde physique.This can make your objects simulate the physical world. Par exemple, quand vous poussez un livre sur une table, si vous le poussez assez fort il continuera à se déplacer une fois que vous l’aurez relâché.For example, when you push a book across a table, if you push hard enough the book will continue to move after you release it. WPFWPF vous permet de simuler ce comportement en déclenchant des événements de manipulation après que les doigts de l’utilisateur ont relâché l’objet.enables you to simulate this behavior by raising manipulation events after the user's fingers releases the object.

Pour plus d’informations sur la création d’une application qui permet à l’utilisateur de déplacer, redimensionner et faire pivoter un objet, consultez procédure pas à pas: Création de votre première applicationTouch.For information about how to create an application that enables the user to move, resize, and rotate an object, see Walkthrough: Creating Your First Touch Application.

UIElement Définit les événements de manipulation suivants.The UIElement defines the following manipulation events.

Par défaut, un UIElement ne reçoit pas ces événements de manipulation.By default, a UIElement does not receive these manipulation events. Pour recevoir des événements de manipulation UIElementsur un UIElement.IsManipulationEnabled , trueaffectez à la valeur.To receive manipulation events on a UIElement, set UIElement.IsManipulationEnabled to true.

Chemin d’exécution des événements de manipulationThe Execution Path of Manipulation Events

Imaginez un scénario où un utilisateur « jette » un objet.Consider a scenario where a user "throws" an object. L’utilisateur place un doigt sur l’objet, déplace son doigt sur l’écran tactile sur une courte distance, puis retire son doigt pendant qu’il le déplace.The user puts a finger on the object, moves the finger across the touchscreen for a short distance, and then lifts the finger while it is moving. La conséquence est que l’objet se déplace sous le doigt de l’utilisateur et continue à se déplacer après que l’utilisateur a retiré son doigt.The result of this is that the object will move under the user's finger and continue to move after the user lifts the finger.

L’illustration suivante montre le chemin d’exécution des événements de manipulation et des informations importantes sur chaque événement.The following illustration shows the execution path of manipulation events and important information about each event.

Séquence des événements de manipulation. Événements de manipulationThe sequence of manipulation events. Manipulation events

La liste suivante décrit la séquence des événements dans l’illustration précédente.The following list describes the sequence of the events in the preceding illustration.

  1. L' ManipulationStarting événement se produit lorsque l’utilisateur place un doigt sur l’objet.The ManipulationStarting event occurs when the user places a finger on the object. Entre autres choses, cet événement vous permet de définir la ManipulationContainer propriété.Among other things, this event allows you to set the ManipulationContainer property. Dans les événements suivants, la position de la manipulation sera relative à ManipulationContainer.In the subsequent events, the position of the manipulation will be relative to the ManipulationContainer. Dans les événements autres ManipulationStartingque, cette propriété est en lecture seule, l' ManipulationStarting événement est donc la seule heure à laquelle vous pouvez définir cette propriété.In events other than ManipulationStarting, this property is read-only, so the ManipulationStarting event is the only time that you can set this property.

  2. L' ManipulationStarted événement se produit ensuite.The ManipulationStarted event occurs next. Cet événement signale l’origine de la manipulation.This event reports the origin of the manipulation.

  3. L' ManipulationDelta événement se produit plusieurs fois lorsque les doigts d’un utilisateur se déplacent sur un écran tactile.The ManipulationDelta event occurs multiple times as a user's fingers move on a touchscreen. La DeltaManipulation propriété de la ManipulationDeltaEventArgs classe indique si la manipulation est interprétée comme un mouvement, une expansion ou une traduction.The DeltaManipulation property of the ManipulationDeltaEventArgs class reports whether the manipulation is interpreted as movement, expansion, or translation. C’est là que vous effectuez la plupart du travail de manipulation d’un objet.This is where you perform most of the work of manipulating an object.

  4. L' ManipulationInertiaStarting événement se produit lorsque les doigts de l’utilisateur perdent le contact avec l’objet.The ManipulationInertiaStarting event occurs when the user's fingers lose contact with the object. Cet événement vous permet de spécifier la décélération des manipulations pendant l’inertie,This event enables you to specify the deceleration of the manipulations during inertia. ceci afin que votre objet puisse émuler différents attributs ou espaces physiques si vous le souhaitez.This is so your object can emulate different physical spaces or attributes if you choose. Par exemple, supposez que votre application a deux objets qui représentent des éléments dans le monde physique, et que l’un d’eux a un poids supérieur à l’autre.For example, suppose your application has two objects that represent items in the physical world, and one is heavier than the other. Vous pouvez faire en sorte que l’objet le plus lourd décélère plus rapidement que l’objet plus léger.You can make the heavier object decelerate faster than the lighter object.

  5. L' ManipulationDelta événement se produit plusieurs fois pendant l’inertie.The ManipulationDelta event occurs multiple times as inertia occurs. Notez que cet événement se produit quand les doigts de l’utilisateur se déplacent sur l’écran tactile et quand WPFWPF simule l’inertie.Note that this event occurs when the user's fingers move across the touchscreen and when WPFWPF simulates inertia. En d’autres termes ManipulationDelta , se produit avant et ManipulationInertiaStarting après l’événement.In other words, ManipulationDelta occurs before and after the ManipulationInertiaStarting event. La ManipulationDeltaEventArgs.IsInertial propriété indique si l' ManipulationDelta événement se produit pendant l’inertie, ce qui vous permet de vérifier cette propriété et d’effectuer différentes actions, en fonction de sa valeur.The ManipulationDeltaEventArgs.IsInertial property reports whether the ManipulationDelta event occurs during inertia, so you can check that property and perform different actions, depending on its value.

  6. L' ManipulationCompleted événement se produit lorsque la manipulation et l’inertie se terminent.The ManipulationCompleted event occurs when the manipulation and any inertia ends. Autrement dit, une fois tous ManipulationDelta les événements survenus, l' ManipulationCompleted événement se produit pour signaler que la manipulation est terminée.That is, after all the ManipulationDelta events occur, the ManipulationCompleted event occurs to signal that the manipulation is complete.

Définit également l' ManipulationBoundaryFeedbackévénement. UIElementThe UIElement also defines the ManipulationBoundaryFeedback event. Cet événement se produit lorsque ReportBoundaryFeedback la méthode est appelée dans ManipulationDelta l’événement.This event occurs when the ReportBoundaryFeedback method is called in the ManipulationDelta event. L' ManipulationBoundaryFeedback événement permet aux applications ou aux composants de fournir des commentaires visuels lorsqu’un objet atteint une limite.The ManipulationBoundaryFeedback event enables applications or components to provide visual feedback when an object hits a boundary. Par exemple, la Window classe gère l' ManipulationBoundaryFeedback événement pour faire en sorte que la fenêtre se déplace légèrement lorsque son bord est rencontré.For example, the Window class handles the ManipulationBoundaryFeedback event to cause the window to slightly move when its edge is encountered.

Vous pouvez annuler la manipulation en appelant la Cancel méthode sur les arguments d’événement dans n’importe quel ManipulationBoundaryFeedback événement de manipulation, à l’exception de l’événement.You can cancel the manipulation by calling the Cancel method on the event arguments in any manipulation event except ManipulationBoundaryFeedback event. Lorsque vous appelez Cancel, les événements de manipulation ne sont plus déclenchés et les événements de souris se produisent pour les fonctions tactiles.When you call Cancel, the manipulation events are no longer raised and mouse events occur for touch. Le tableau suivant décrit la relation entre le moment où la manipulation est annulée et les événements de souris qui se produisent.The following table describes the relationship between the time the manipulation is canceled and the mouse events that occur.

Événement pendant lequel Cancel est appeléThe event that Cancel is called in Événements de souris qui se produisent pour une entrée qui a déjà eu lieuThe mouse events that occur for input that already occurred
ManipulationStarting et ManipulationStartedManipulationStarting and ManipulationStarted Événements mouse down.Mouse down events.
ManipulationDelta Événements mouse down et mouse move.Mouse down and mouse move events.
ManipulationInertiaStarting et ManipulationCompletedManipulationInertiaStarting and ManipulationCompleted Événements mouse down, mouse move et mouse up.Mouse down, mouse move, and mouse up events.

Notez que si vous appelez Cancel lorsque la manipulation est en inertie, la méthode false retourne et l’entrée ne déclenche pas d’événements de souris.Note that if you call Cancel when the manipulation is in inertia, the method returns false and the input does not raise mouse events.

Relation entre les événements tactiles et les événements de manipulationThe Relationship Between Touch and Manipulation Events

Un UIElement peut toujours recevoir des événements tactiles.A UIElement can always receive touch events. Lorsque la IsManipulationEnabled propriété a la valeur true, un UIElement peut recevoir à la fois des événements tactiles et des événements de manipulation.When the IsManipulationEnabled property is set to true, a UIElement can receive both touch and manipulation events. Si l' TouchDown événement n’est pas géré (autrement dit, Handled si la falsepropriété a la valeur), la logique de manipulation capture le toucher à l’élément et génère les événements de manipulation.If the TouchDown event is not handled (that is, the Handled property is false), the manipulation logic captures the touch to the element and generates the manipulation events. Si la true propriété a la valeur dans l' TouchDown événement, la logique de manipulation ne génère pas d’événements de manipulation. HandledIf the Handled property is set to true in the TouchDown event, the manipulation logic does not generate manipulation events. L’illustration suivante montre la relation entre les événements tactiles et les événements de manipulation.The following illustration shows the relationship between touch events and manipulation events.

Relation entre les événements tactiles et les événements de manipulation Événements tactiles et de manipulationRelationship between touch and manipulation events Touch and manipulation events

La liste suivante décrit la relation entre les événements tactiles et les événements de manipulation indiquée dans l’illustration précédente.The following list describes the relationship between the touch and manipulation events that is shown in the preceding illustration.

FocusFocus

Il existe deux concepts principaux associés au focus dans WPFWPF : le focus clavier et le focus logique.There are two main concepts that pertain to focus in WPFWPF: keyboard focus and logical focus.

Focus clavierKeyboard Focus

Le focus clavier fait référence à l’élément qui reçoit actuellement l’entrée au clavier.Keyboard focus refers to the element that is 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 IsKeyboardFocused aura la valeur true.In WPFWPF, the element that has keyboard focus will have IsKeyboardFocused set to true. La méthode Keyboard FocusedElement statique retourne l’élément qui a actuellement le focus clavier.The static Keyboard method FocusedElement returns the element that currently has keyboard focus.

Le focus clavier peut être obtenu par tabulation à un élément ou en cliquant avec la souris sur certains éléments, tels TextBoxqu’un.Keyboard focus can be obtained by tabbing to an element or by clicking the mouse on certain elements, such as a TextBox. Le focus clavier peut également être obtenu par programmation à l’aide Focus de la méthode Keyboard sur la classe.Keyboard focus can also be obtained programmatically by using the Focus method on the Keyboard class. Focustente d’attribuer le focus clavier à l’élément spécifié.Focus attempts to give the specified element keyboard focus. L’élément retourné par Focus est l’élément qui a actuellement le focus clavier.The element returned by Focus is the element that currently has keyboard focus.

Pour qu’un élément obtienne le focus clavier, la Focusable propriété et les IsVisible propriétés doivent avoir la valeur true.In order for an element to obtain keyboard focus the Focusable property and the IsVisible properties must be set to true. Certaines classes, telles que Panel, ont Focusable la valeur false par défaut; par conséquent, vous devrez peut-être définir cette true propriété sur si vous souhaitez que cet élément puisse obtenir le focus.Some classes, such as Panel, have Focusable set to false by default; therefore, you may have to set this property to true if you want that element to be able to obtain focus.

L’exemple suivant utilise Focus pour définir le focus clavier sur Buttonun.The following example uses Focus to set keyboard focus on a Button. L’emplacement recommandé pour définir le focus initial dans une application se trouve Loaded dans le gestionnaire d’événements.The recommended place to set initial focus in an application is in the Loaded event handler.

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

Pour plus d’informations sur le focus clavier, consultez Vue d’ensemble du focus.For more information about keyboard focus, see Focus Overview.

Focus logiqueLogical Focus

Le FocusManager.FocusedElement focus logique fait référence à dans une portée de focus.Logical focus refers to the FocusManager.FocusedElement in a 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.

Une portée de focus est un élément conteneur qui effectue le FocusedElement suivi du dans sa portée.A focus scope is a container element that keeps track of the FocusedElement within its scope. Quand le focus quitte une portée de focus, l’élément ayant le focus perd le focus clavier, mais conserve le focus logique.When focus leaves a focus scope, the focused element will lose keyboard focus but will retain logical focus. Quand le focus revient dans la portée de focus, l’élément ayant le focus obtient le focus clavier.When 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 demeure l’élément ayant le focus quand le focus revient.This allows for keyboard focus to be changed between multiple focus scopes but insures that the focused element within the focus scope remains the focused element when focus returns.

Un élément peut être converti en portée de focus dans langage XAML (eXtensible Application Markup Language)Extensible Application Markup Language (XAML) en affectant FocusManager à truela IsFocusScope propriété jointe la valeur ou dans le code en définissant la SetIsFocusScope propriété jointe à l’aide de la méthode.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, or in code by setting the attached property by using the SetIsFocusScope method.

L’exemple suivant rend un StackPanel en portée de focus en définissant IsFocusScope la 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)

Les classes WPFWPF dans lesquelles sont des portées de focus Windowpar défaut ToolBarsont, ContextMenu Menu, et.Classes in WPFWPF which are focus scopes by default are Window, Menu, ToolBar, and ContextMenu.

Un élément qui a le focus clavier aura également le focus logique pour la portée de focus à laquelle il appartient; par conséquent, le fait de définir le focus Focus sur un élément Keyboard avec la méthode sur la classe ou les classes d’élément de base tente de fournir le focus clavier de l’élément et le focus logique.An element that has keyboard focus will also have logical focus for the focus scope it belongs to; therefore, setting focus on an element with the Focus method on the Keyboard class or the base element classes will attempt to give the element keyboard focus and logical focus.

Pour déterminer l’élément ayant le focus dans une portée de GetFocusedElementFocus, utilisez.To determine the focused element in a focus scope, use GetFocusedElement. Pour modifier l’élément ayant le focus pour une portée de SetFocusedElementFocus, utilisez.To change the focused element for a focus scope, use SetFocusedElement.

Pour plus d’informations sur le focus logique, consultez Vue d’ensemble du focus.For more information about logical focus, see Focus Overview.

Position de la sourisMouse Position

L' WPFWPF API d’entrée fournit des informations utiles concernant les espaces de coordonnées.The WPFWPF input API provides helpful information with regard to coordinate spaces. Par exemple, la coordonnée (0,0) est la coordonnée de l’angle supérieur gauche, mais de quel élément dans l’arborescence ?For example, coordinate (0,0) is the upper-left coordinate, but the upper-left of which element in the tree? L’élément qui est la cible d’entrée ?The element that is the input target? L’élément auquel vous avez attaché votre gestionnaire d’événements ?The element you attached your event handler to? Ou un autre élément ?Or something else? Pour éviter toute confusion, WPFWPF l’API d’entrée requiert que vous spécifiiez le cadre de référence lorsque vous travaillez avec des coordonnées obtenues à l’aide de la souris.To avoid confusion, the WPFWPF input API requires that you specify your frame of reference when you work with coordinates obtained through the mouse. La GetPosition méthode retourne la coordonnée du pointeur de la souris par rapport à l’élément spécifié.The GetPosition method returns the coordinate of the mouse pointer relative to the specified element.

Capture de la sourisMouse Capture

Les souris ont une caractéristique modale spécifique appelée capture de la souris.Mouse devices specifically hold a modal characteristic known as mouse capture. La capture de la souris sert à tenir à jour un état d’entrée transitionnel quand une opération de glisser-déplacer commence, afin que les autres opérations impliquant la position nominale à l’écran du pointeur de la souris ne se produisent pas nécessairement.Mouse capture is used to maintain a transitional input state when a drag-and-drop operation is started, so that other operations involving the nominal on-screen position of the mouse pointer do not necessarily occur. Pendant l’opération glisser, l’utilisateur ne peut pas cliquer sans annuler le glisser-déplacer, ce qui rend la plupart des indices de survol de souris inappropriés pendant que la capture de la souris est détenue par l’origine de l’opération glisser.During the drag, the user cannot click without aborting the drag-and-drop, which makes most mouseover cues inappropriate while the mouse capture is held by the drag origin. Le système d’entrée expose des API qui peuvent déterminer l’état de capture de la souris, ainsi que des API qui peuvent forcer la capture de la souris sur un élément spécifique ou effacer l’état de capture de la souris.The input system exposes APIs that can determine mouse capture state, as well as APIs that can force mouse capture to a specific element, or clear mouse capture state. Pour plus d’informations sur les opérations de glisser-déplacer, consultez Vue d’ensemble du glisser-déplacer.For more information on drag-and-drop operations, see Drag and Drop Overview.

CommandesCommands

Les commandes permettent de gérer les entrées à un niveau plus sémantique que l’entrée de périphérique.Commands enable input handling at a more semantic level than device input. Les commandes sont des directives simples, telles que Cut, Copy, Paste ou Open.Commands are simple directives, such as Cut, Copy, Paste, or Open. Elles sont utiles pour centraliser la logique de commande.Commands are useful for centralizing your command logic. Il est possible d’accéder à la même Menucommande à partir ToolBard’un, d’un ou d’un raccourci clavier.The same command might be accessed from a Menu, on a ToolBar, or through a keyboard shortcut. Les commandes fournissent également un mécanisme permettant de désactiver des contrôles quand la commande devient indisponible.Commands also provide a mechanism for disabling controls when the command becomes unavailable.

RoutedCommandest l' WPFWPF implémentation de ICommand.RoutedCommand is the WPFWPF implementation of ICommand. Lorsqu’un RoutedCommand est exécuté, un PreviewExecuted et un Executed événement sont déclenchés sur la cible de commande, qui effectue un tunneling et effectue une propagation dans l’arborescence d’éléments comme une autre entrée.When a RoutedCommand is executed, a PreviewExecuted and an Executed event are raised on the command target, which tunnel and bubble through the element tree like other input. Si une cible de commande n’est pas définie, l’élément qui a le focus clavier est la cible de commande.If a command target is not set, the element with keyboard focus will be the command target. La logique qui exécute la commande est attachée à CommandBindingun.The logic that performs the command is attached to a CommandBinding. Lorsqu’un Executed événement atteint un CommandBinding pour cette CommandBinding commande spécifique, la ExecutedRoutedEventHandler sur est appelée.When an Executed event reaches a CommandBinding for that specific command, the ExecutedRoutedEventHandler on the CommandBinding is called. Ce gestionnaire exécute l’action de la commande.This handler performs the action of the command.

Pour plus d’informations sur l’exécution des commandes, consultez Vue d’ensemble des commandes.For more information on commanding, see Commanding Overview.

WPFWPFfournit une bibliothèque de commandes courantes qui se compose ApplicationCommandsde MediaCommands, ComponentCommands, NavigationCommands, et EditingCommands, ou vous pouvez définir les vôtres.provides a library of common commands which consists of ApplicationCommands, MediaCommands, ComponentCommands, NavigationCommands, and EditingCommands, or you can define your own.

L’exemple suivant montre MenuItem comment configurer un de sorte que, lorsque l’utilisateur clique dessus, il appelle la Paste commande sur TextBoxle, en supposant que a le TextBox focus clavier.The following example shows how to set up a MenuItem so that when it is clicked it will invoke the Paste command on the TextBox, assuming the TextBox has keyboard focus.

<StackPanel>
  <Menu>
    <MenuItem Command="ApplicationCommands.Paste" />
  </Menu>
  <TextBox />
</StackPanel>
  // Creating the UI objects
  StackPanel mainStackPanel = new StackPanel();
  TextBox pasteTextBox = new TextBox();
  Menu stackPanelMenu = new Menu();
  MenuItem pasteMenuItem = new MenuItem();
 
  // Adding objects to the panel and the menu
  stackPanelMenu.Items.Add(pasteMenuItem);
  mainStackPanel.Children.Add(stackPanelMenu);
  mainStackPanel.Children.Add(pasteTextBox);

  // Setting the command to the Paste command
  pasteMenuItem.Command = ApplicationCommands.Paste;

  // Setting the command target to the TextBox
  pasteMenuItem.CommandTarget = pasteTextBox;
' Creating the UI objects
Dim mainStackPanel As New StackPanel()
Dim pasteTextBox As New TextBox()
Dim stackPanelMenu As New Menu()
Dim pasteMenuItem As New MenuItem()

' Adding objects to the panel and the menu
stackPanelMenu.Items.Add(pasteMenuItem)
mainStackPanel.Children.Add(stackPanelMenu)
mainStackPanel.Children.Add(pasteTextBox)

' Setting the command to the Paste command
pasteMenuItem.Command = ApplicationCommands.Paste

Pour plus d’informations sur les commandes dans WPFWPF, consultez Vue d’ensemble des commandes.For more information about commands in WPFWPF, see Commanding Overview.

Le système d’entrée et les éléments de baseThe Input System and Base Elements

Les événements d’entrée tels que les événements attachés Mousedéfinis Keyboardpar les Stylus classes, et sont déclenchés par le système d’entrée et injectés dans une position particulière dans le modèle objet en fonction du test d’atteinte de l’arborescence visuelle au moment de l’exécution.Input events such as the attached events defined by the Mouse, Keyboard, and Stylus classes are raised by the input system and injected into a particular position in the object model based on hit testing the visual tree at run time.

Chacun des événements qui Mouse, Keyboardet Stylus définis comme un événement attaché est également réexposé par les classes UIElement d’élément de base et ContentElement comme nouvel événement routé.Each of the events that Mouse, Keyboard, and Stylus define as an attached event is also re-exposed by the base element classes UIElement and ContentElement as a new routed event. Les événements routés d’éléments de base sont générés par des classes gérant l’événement attaché d’origine et réutilisant les données d’événements.The base element routed events are generated by classes handling the original attached event and reusing the event data.

Quand l’événement d’entrée est associé à un élément source particulier par l’intermédiaire de son implémentation d’événement d’entrée d’élément de base, il peut être routé le long du reste d’un itinéraire d’événement qui est basé sur une combinaison d’objets des arborescences visuelle et logique, et être géré par le code de l’application.When the input event becomes associated with a particular source element through its base element input event implementation, it can be routed through the remainder of an event route that is based on a combination of logical and visual tree objects, and be handled by application code. En règle générale, il est plus commode de gérer ces événements d’entrée liés à l’appareil à l' UIElement aide ContentElementdes événements routés sur et, car vous pouvez utiliser une XAMLXAML syntaxe de gestionnaire d’événements plus intuitive à la fois dans et dans le code.Generally, it is more convenient to handle these device-related input events using the routed events on UIElement and ContentElement, because you can use more intuitive event handler syntax both in XAMLXAML and in code. Vous pouvez choisir à la place de gérer l’événement attaché qui a démarré le processus, mais vous serez alors confronté à plusieurs problèmes : l’événement attaché pourra être marqué comme géré par la gestion de classe d’élément de base, et vous devrez utiliser des méthodes d’accesseur plutôt qu’une réelle syntaxe d’événement pour attacher des gestionnaires pour les événements attachés.You could choose to handle the attached event that initiated the process instead, but you would face several issues: the attached event may be marked handled by the base element class handling, and you need to use accessor methods rather than true event syntax in order to attach handlers for attached events.

Étapes suivantesWhat's Next

Vous connaissez maintenant plusieurs techniques pour gérer les entrées dans WPFWPF.You now have several techniques to handle input in WPFWPF. Vous devriez également mieux comprendre les différents types d’événements d’entrée et les mécanismes d’événements routés utilisés par WPFWPF.You should also have an improved understanding of the various types of input events and the routed event mechanisms used by WPFWPF.

Si vous souhaitez en savoir plus, il existe des ressources supplémentaires qui expliquent les éléments de framework WPFWPF et le routage d’événement plus en détail.Additional resources are available that explain WPFWPF framework elements and event routing in more detail. Pour plus d’informations, consultez les vues d’ensemble suivantes : Vue d’ensemble des commandes, Vue d’ensemble du focus, Vue d’ensemble des éléments de base, Arborescences dans WPF et Vue d’ensemble des événements routés.See the following overviews for more information, Commanding Overview, Focus Overview, Base Elements Overview, Trees in WPF, and Routed Events Overview.

Voir aussiSee also