Langage: HTML | XAML

Réponse aux interactions du clavier (XAML)

Vous pouvez répondre aux actions d’un clavier physique ou tactile dans vos applications à l’aide de gestionnaires d’événements de classe et de clavier.

Important  

Certains contrôles Windows Runtime gèrent les événements d’entrée en interne. Dans ces cas-là, il peut sembler qu’un événement d’entrée n’a pas lieu car votre écouteur d’événements n’appelle pas le gestionnaire associé. En général, ces touches sont gérées par le gestionnaire de classe pour fournir une prise en charge intégrée de l’accessibilité de base du clavier. Par exemple, la classe Button substitue les événements OnKeyDown pour la touche Espace et la touche Entrée (de même que OnPointerPressed) et les achemine vers l’événement Click du contrôle. Quand un appui sur une touche est géré par la classe de contrôle, les événements KeyDown et KeyUp ne sont pas déclenchés.

Cela fournit un équivalent de clavier intégré pour l’appel du bouton, comme en cas d’appui avec un doigt ou de clic avec une souris. Les touches autres que Espace ou Entrée déclenchent quand même les événements KeyDown et KeyUp. Pour plus d’informations sur le fonctionnement de cette gestion des événements basée sur la classe, voir Vue d’ensemble des événements et des événements routés (en particulier Gestionnaires d’événements d’entrée dans les contrôles).

Astuce  Les informations fournies dans cette rubrique sont spécifiques au développement d’applications en C++, C# ou Visual Basic.

Pour les applications en JavaScript, voir Réponse aux interactions du clavier (HTML).

Conditions préalables:  Examinez ces rubriques pour vous familiariser avec les technologies discutées ici.

Créer votre première application du Windows Store en C# ou Visual Basic

Créer votre première application du Windows Store en C++

Feuille de route pour les applications du Windows Store en C# ou Visual Basic

Feuille de route pour les applications du Windows Store en C++

Découvrir les événements avec Vue d’ensemble des événements et des événements routés.

Fonctionnalités d’application de A à Z:  Étudier cette fonctionnalité de façon plus approfondie dans le cadre de notre série Fonctionnalités d’application de A à Z

Interaction utilisateur de A à Z (XAML)

Personnalisation de l’interaction utilisateur de A à Z (XAML)

Recommandations en matière d’expérience utilisateur:  

Les bibliothèques de contrôles de plateforme (HTML et XAML) fournissent l’intégralité de l’expérience d’interaction utilisateur, y compris les interactions standard, les effets physiques animés et le retour visuel. Utilisez ces contrôles intégrés si vous n’avez pas besoin d’une prise en charge d’interaction personnalisée.

Si les contrôles de plateforme ne suffisent pas, les présentes recommandations peuvent vous aider à fournir une expérience d’interaction utilisateur à la fois immersive et cohérente entre les divers modes d’entrée. Ces recommandations sont axées principalement sur l’entrée tactile, mais elles s’appliquent également à l’entrée de pavé tactile, de souris, de clavier et de stylet.

Exemples:  Découvrez cette fonctionnalité en action dans nos exemples d’applications.

Exemple d’entrée

Entrée : exemple de fonctionnalités de périphériques

Entrée : exemple de clavier tactile

Exemple de réponse à l’apparition du Clavier visuel

Vue d’ensemble

Les entrées via le clavier représentent une part importante de l’expérience d’interaction utilisateur globale pour les applications. Le clavier est indispensable pour certaines personnes souffrant d’un handicap et les utilisateurs qui le considèrent simplement comme un moyen plus efficace d’interaction avec une application. Par exemple, les utilisateurs doivent pouvoir naviguer dans votre application à l’aide des touches de direction et de tabulation, activer les éléments d’interface utilisateur à l’aide des touches Espace et Entrée, et accéder aux commandes à l’aide de raccourcis clavier.

Une interface utilisateur de clavier bien conçue représente un aspect important de l’accessibilité logicielle. Elle permet aux utilisateurs malvoyants ou souffrant d’un handicap moteur de naviguer dans une application et d’interagir avec ses fonctionnalités. Les utilisateurs qui ne sont pas en mesure d’utiliser une souris peuvent avoir recours à diverses technologies d’assistance, telles que les outils de clavier amélioré, les claviers visuels, les écrans élargis, les lecteurs d’écran et les utilitaires d’entrée vocale.

Le clavier matériel externe, qui est physiquement connecté à un appareil, est le type de clavier le plus courant. En plus d’un clavier matériel, Windows 8 fournit également deux claviers logiciels :

  • Remarque  Windows :

    Le Clavier visuel est un clavier logiciel visuel que vous pouvez utiliser à la place du clavier physique pour entrer des données à l’aide de la fonction tactile, de la souris, du stylo/stylet ou d’un autre périphérique de pointage (un écran tactile n’est pas nécessaire). Le Clavier visuel est fourni pour les systèmes qui ne possèdent pas de clavier physique ou pour les utilisateurs qui connaissent des problèmes de mobilité les empêchant d’utiliser les périphériques d’entrée physiques classiques. Le Clavier visuel émule la plupart, sinon la totalité, des fonctionnalités d’un clavier matériel.

    Clavier visuel

  • Remarque  Windows :

    Le clavier tactile est un clavier logiciel visuel permettant d’entrer du texte à l’aide de la fonction tactile. Le clavier tactile ne se substitue pas au Clavier visuel car il n’est utilisé que pour la saisie de texte (il n’émule pas le clavier matériel) et apparaît seulement quand un champ textuel ou un autre contrôle textuel modifiable reçoit le focus.
    Remarque  Le Clavier visuel a priorité sur le clavier tactile, lequel n’est pas visible si le Clavier visuel est présent.

    Voici quelques exemples de clavier tactile. La première image représente la disposition classique, la seconde représente la disposition ergonomique (qui n’est pas forcément disponible dans toutes les langues).

    Clavier tactile dans une disposition classique

    Clavier tactile dans une disposition ergonomique

Événements de clavier

Les événements de clavier suivants peuvent se produire pour les claviers physiques et tactiles.

ÉvénementDescription
KeyDown Se produit lorsqu’une touche est enfoncée.
KeyUp Se produit lorsqu’une touche est relâchée.

 

Événements de clavier et focus

Les contrôles de votre interface utilisateur génèrent des événements de clavier uniquement lorsqu’ils ont le focus d’entrée. Un élément individuel reçoit le focus lorsque l’utilisateur clique ou appuie directement sur cet élément dans l’interface ou qu’il utilise la touche Tab dans la zone de contenu.

Vous pouvez également appeler la méthode Focus d’un contrôle pour forcer le focus. Cette action est nécessaire lorsque vous implémentez les touches de raccourci car le focus du clavier n’est pas défini par défaut lors du chargement de votre interface utilisateur. Pour plus d’informations, voir Exemple de touches de raccourci, plus loin dans cette rubrique.

Pour qu’un contrôle puisse recevoir le focus d’entrée, il doit être activé, visible, et avoir les propriétés IsTabStop et HitTestVisible associées à la valeur true. Il s’agit de l’état par défaut de la plupart des contrôles. Lorsqu’un contrôle a le focus d’entrée, il peut être déclenché et répondre aux événements d’entrée de clavier, tel que décrit plus loin dans cette rubrique. Vous pouvez également répondre à un contrôle qui reçoit ou perd le focus en gérant les événements GotFocus et LostFocus.

Par défaut, l’ordre de tabulation des contrôles est celui dans lequel les contrôles apparaissent en XAML. Vous pouvez cependant changer cet ordre à l’aide de la propriété TabIndex. Pour plus d’informations, voir Implémentation de l’accessibilité du clavier.

Gestionnaires d’événements de clavier

Un gestionnaire d’événements d’entrée implémente un délégué qui fournit les informations suivantes :

  • L’expéditeur de l’événement. L’expéditeur signale l’objet auquel le gestionnaire d’événements est attaché.
  • Les données d’événement. Dans le cas des événements de clavier, ces données seront une instance de KeyRoutedEventArgs. Le délégué des gestionnaires est KeyEventHandler. Les propriétés les plus significatives de KeyRoutedEventArgs pour la plupart des scénarios de gestionnaires sont Key et éventuellement KeyStatus.
  • OriginalSource. Les événements de clavier étant des événements routés, les données d’événements fournissent OriginalSource. Si vous autorisez délibérément des événements à être proposés par le biais d’un arbre d’objets, OriginalSource est parfois l’objet de la question plutôt que l’expéditeur, bien que cela dépende de la conception de votre application. Pour plus d’informations sur l’utilisation de OriginalSource à la place de l’expéditeur, voir la section « Événements routés de clavier » de cette rubrique ou Vue d’ensemble des événements et des événements routés.

Attachement d’un gestionnaire d’événements de clavier

Vous pouvez attacher les fonctions des gestionnaires d’événements de clavier pour n’importe quel objet qui inclut l’événement en tant que membre. Cela inclut toute classe dérivée UIElement. L’exemple de code XAML suivant montre comment attacher des gestionnaires pour l’événement KeyUp d’un Grid.



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


Vous pouvez également attacher un gestionnaire d’événements dans du code. Pour plus d’informations, voir Vue d’ensemble des événements et des événements routés.

Définition d’un gestionnaire d’événements de clavier

L’exemple suivant montre la définition incomplète du gestionnaire d’événements KeyUp attaché dans l’exemple précédent.


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

Utilisation de KeyRoutedEventArgs

Tous les événements de clavier utilisent KeyRoutedEventArgs pour les données d’événements, et KeyRoutedEventArgs contient les propriétés suivantes :

Clé

L’événement KeyDown est déclenché si une touche est enfoncée. De même, l’événement KeyUp est déclenché si une touche est relâchée. Vous êtes généralement à l’écoute des événements en vue de traiter une valeur de touche spécifique. Afin de déterminer quelle touche est enfoncée ou relâchée, vérifiez la valeur Key dans les données d’événements. Key renvoie une valeur VirtualKey. L’énumération VirtualKey inclut toutes les touches prises en charge.

Touches de modification

Remarque  Windows :

Les touches de modification sont des touches, telles que Ctrl ou Maj, sur lesquelles les utilisateurs appuient généralement en même temps que d’autres touches. Votre application peut utiliser ces combinaisons de touches en tant que raccourcis clavier pour appeler des commandes d’application.

Vous pouvez détecter des combinaisons de touches de raccourci à l’aide de code dans vos gestionnaires d’événements KeyDown et KeyUp. Vous pouvez ensuite effectuer le suivi de l’état d’appui des touches de modification qui vous intéressent. Lorsqu’un événement de clavier se produit pour une touche qui n’est pas une touche de modification, vous pouvez vérifier en même temps si une touche de modification est à l’état appuyé.

Remarque  La touche Alt est représentée par la valeur VirtualKey.Menu.

Exemple de touches de raccourci

Remarque  Windows :

L’exemple suivant explique comment implémenter des touches de raccourci. Dans cet exemple, les utilisateurs peuvent contrôler la lecture du contenu multimédia à l’aide des boutons Lecture, Pause et Arrêt ou des raccourcis clavier Ctrl+P, Ctrl+A et Ctrl+S. Le bouton XAML affiche les touches de raccourci à l’aide des info-bulles et des propriétés AutomationProperties des étiquettes de boutons. Cette documentation d’auto-apprentissage est importante afin d’augmenter la facilité d’utilisation et l’accessibilité de votre application. Pour plus d’informations, voir la rubrique Implémentation de l’accessibilité du clavier.

Notez également que la page définit le focus d’entrée sur elle-même lors de son chargement. Sans cette étape, aucun contrôle n’a le focus d’entrée initial et l’application ne déclenche pas les événements d’entrée tant qu’un utilisateur n’a pas défini le focus d’entrée manuellement (par exemple en utilisant la touche Tab ou en cliquant sur un contrôle).


<Grid KeyDown="Grid_KeyDown">

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

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

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

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

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

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

  </StackPanel>

</Grid>



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

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


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


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


Remarque  La définition d’AutomationProperties.AcceleratorKey ou d’AutomationProperties.AccessKey en XAML fournit des informations de chaîne qui documentent la touche de raccourci d’appel de cette action particulière. Les informations sont capturées par des clients Microsoft UI Automation, tels que le Narrateur, et généralement fournis directement à l’utilisateur. La définition d’AutomationProperties.AcceleratorKey ou d’AutomationProperties.AccessKey ne constitue pas une action proprement dite. Vous devrez quand même associer des gestionnaires pour les événements KeyDown ou KeyUp afin de mettre réellement en œuvre le comportement de la touche de raccourci dans l’application. De même, l’ornement de soulignement du texte n’est pas fourni automatiquement pour une touche d’accès. Si vous voulez afficher du texte souligné dans l’interface utilisateur, vous devez souligner le texte de manière explicite pour la touche en question dans votre mnémonique en insérant une mise en forme Underline.

Événements routés de clavier

Certains événements sont des événements routés, comme KeyDown et KeyUp. Les événements routés utilisent la stratégie de routage de propagation. La stratégie de routage de propagation signifie qu’un événement provenant d’un objet enfant est ensuite routé jusqu’aux objets parents successifs dans l’arbre d’objets, ce qui offre ainsi une autre opportunité de gérer le même événement et d’interagir avec les mêmes données d’événements.

Considérez l’exemple de code XAML suivant, dans lequel des événements KeyUp sont définis pour un objet Canvas et deux objets Button. Dans ce cas, si vous relâchez une touche tandis que le focus est détenu par l’un des objets Button, l’événement KeyUp est déclenché. L’événement est ensuite propagé au Canvas parent.


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


L’exemple suivant montre comment implémenter le gestionnaire d’événements KeyUp pour le contenu XAML correspondant dans l’exemple précédent.


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


Notez l’utilisation de la propriété OriginalSource dans le gestionnaire précédent. Dans ce cas, OriginalSource signale l’objet qui a déclenché l’événement. L’objet ne pouvait pas être l’objet StackPanel, car l’objet StackPanel n’est pas un contrôle et il ne peut pas avoir le focus. Seul un des deux boutons au sein de l’objet StackPanel a pu déclencher l’événement, mais lequel ? Vous utilisez OriginalSource pour identifier l’objet source de l’événement réel si vous gérez l’événement sur un objet parent.

Propriété Handled dans des données d’événements

En fonction de votre stratégie de gestion des événements, il se peut que vous vouliez qu’un seul gestionnaire d’événements réagisse à un événement de propagation. Ainsi, tout gestionnaire KeyUp spécifique attaché à l’un des contrôles Button a en premier lieu la possibilité de gérer cet événement. Dans ce cas, il se peut que vous ne vouliez pas que le panneau parent gère également l’événement. Pour ce scénario, utilisez la propriété Handled dans les données d’événements.

Le rôle de la propriété Handled dans une classe de données d’événements routés est de signaler qu’un autre gestionnaire que vous aviez enregistré précédemment sur l’itinéraire des événements a déjà agi. Cela influence le comportement du système d’événements routés. Lorsque vous définissez la valeur de la propriété Handled à true dans un gestionnaire d’événements, cet événement arrête le routage et n’est pas envoyé aux éléments parents successifs.

AddHandler et événements de clavier déjà gérés

Vous pouvez utiliser une technique spéciale pour attacher des gestionnaires pouvant agir sur des événements déjà marqués comme étant gérés. Cette technique utilise la méthode AddHandler pour inscrire un gestionnaire, plutôt que d’utiliser des attributs XAML ou une syntaxe spécifique au langage pour l’ajout de gestionnaires, telle que += en C#. L’une des limitations générales de cette technique est le fait que l’API AddHandler utilise un paramètre de type RoutedEvent qui identifie l’événement routé en question. Tous les événements routés ne fournissent pas un identificateur RoutedEvent et cette considération affecte par conséquent quels événements routés peuvent encore été gérés dans le cas Handled. Les événements KeyDown et KeyUp possèdent des identificateurs d’événements routés (KeyDownEvent et KeyUpEvent) sur UIElement. Toutefois, les autres événements tels que TextBox.TextChanged ne possèdent pas d’identificateurs d’événements routés. Par conséquent, ils ne peuvent pas être utilisés pour la technique AddHandler.

Commande

Un petit nombre d’éléments d’interface utilisateur fournit la prise en charge intégrée pour les commandes. Les commandes utilisent les événements routés associés à une entrée dans leur implémentation sous-jacente et permettent de traiter l’entrée d’interface utilisateur associée (une certaine action du pointeur, une touche d’accès rapide spécifique), en invoquant un seul gestionnaire de commandes.

Si les commandes sont disponibles pour un élément d’interface utilisateur, envisagez d’utiliser ses API de commandes plutôt que les événements d’entrée discrets. Pour plus d’informations, voir ButtonBase.Command.

Vous pouvez également implémenter ICommand afin d’encapsuler les fonctionnalités de commande que vous invoquez à partir de gestionnaires d’événements ordinaires, ce qui vous permet d’utiliser les commandes même lorsqu’aucune propriété Command n’est disponible.

Entrée de texte et contrôles

Certains contrôles réagissent aux événements de clavier avec leur propre gestion. Par exemple, TextBox est un contrôle conçu pour capturer puis représenter visuellement du texte entré à l’aide du clavier. Il utilise KeyUp et KeyDown dans sa propre logique en vue de capturer les frappes de touches, puis il déclenche également son propre événement TextChanged si le texte a changé.

D’une manière générale, vous pouvez toujours ajouter des gestionnaires pour KeyUp et KeyDown à un TextBox, ou tout contrôle associé destiné à traiter l’entrée de texte. Toutefois, comme prévu de par sa conception, il se peut qu’un contrôle ne réponde pas à l’ensemble des valeurs de touches qui lui sont envoyées par le biais des événements de touches. Le comportement est spécifique à chaque contrôle.

En guise d’exemple, ButtonBase (la classe de base pour Button) traite KeyUp de sorte qu’elle puisse surveiller la barre d’espace ou la touche Entrée. ButtonBase considère que KeyUp équivaut à un clic de bouton gauche de souris pour les besoins du déclenchement d’événement Click. Ce traitement de l’événement s’effectue lorsque ButtonBase remplace la méthode virtuelle OnKeyUp. Dans son implémentation, elle affecte la valeur true à Handled. Le résultat est que tout parent d’un bouton à l’écoute d’un événement de touche, dans le cas d’un Espace, ne recevra pas l’événement déjà géré pour ses propres gestionnaires.

Un autre exemple est TextBox. Certaines touches, telles que les touches de direction, ne sont pas considérées comme étant du texte par TextBox mais sont au contraire considérées comme étant spécifiques au comportement d’interface utilisateur du contrôle. L’objet TextBox marque ces cas d’événements comme gérés.

Les contrôles personnalisés peuvent implémenter leur propre comportement similaire de remplacement pour les événements de touches en remplaçant OnKeyDown / OnKeyUp. Si votre contrôle personnalisé traite des touches d’accès rapide spécifiques ou présente un comportement de contrôle ou de focus qui est similaire au scénario décrit pour TextBox, vous devez placer cette logique dans vos propres remplacements OnKeyDown / OnKeyUp.

Le clavier tactile

Les contrôles de saisie de texte fournissent le support automatique du clavier tactile. Lorsque l’utilisateur définit le focus d’entrée sur un contrôle de texte à l’aide de l’entrée tactile, le clavier tactile apparaît automatiquement. Lorsque le focus d’entrée n’est pas placé sur un contrôle de texte, le clavier tactile est masqué.

Lorsque le clavier tactile apparaît, votre interface utilisateur est automatiquement repositionnée afin que l’élément ciblé reste visible. Des zones importantes de l’interface utilisateur peuvent alors sortir de l’écran. Vous pouvez désactiver ce comportement par défaut et effectuer vos propres ajustements de l’interface utilisateur lorsque le clavier tactile apparaît. Pour plus d’informations, voir Exemple de réponse à l’apparition du Clavier visuel.

Si vous créez un contrôle personnalisé qui nécessite une saisie de texte mais ne découle pas d’un contrôle de saisie de texte standard, vous pouvez ajouter la prise en charge du clavier tactile en implémentant les modèles de contrôle Automation d’interface utilisateur appropriés. Pour plus d’informations, voir Exemple de clavier tactile.

Les touches enfoncées sur le clavier tactile déclenchent les événements KeyDown et KeyUp, exactement comme si vous aviez appuyé sur les touches d’un clavier physique. Cependant, le clavier tactile ne déclenchera pas d’événements de saisie pour les touches Ctrl+A, Ctrl+Z, Ctrl+X, Ctrl+C et Ctrl+V, qui sont réservées à la manipulation de texte dans le contrôle de saisie.

Recommandations en matière d’expérience utilisateur pour la prise en charge des interactions avec le clavier

Voici des recommandations pour la prise en charge des interactions avec le clavier :

Considérations d’ordre général

  • Remarque  Windows :

    Les utilisateurs doivent pouvoir accomplir toutes les tâches prises en charge par votre application en utilisant exclusivement le clavier physique ou visuel.
    Remarque  Le clavier tactile sert uniquement à l’entrée de texte ; il n’est pas utilisé pour les commandes d’application commandes système.
  • Au démarrage de votre application, définissez le focus clavier initial sur l’élément avec lequel, selon vous, les utilisateurs interagiront intuitivement en premier. En général, l’emplacement le plus approprié est l’affichage de contenu principal de l’application, ce qui permet à l’utilisateur de parcourir immédiatement le contenu à l’aide des touches de direction. Pour plus d’informations sur la définition du focus sur des contrôles spécifiques, voir Focus.
  • Remarque  Windows :

    Assurez-vous que les touches Tab et de direction permettent de parcourir le contenu dans un ordre logique.
  • Affectez à la propriété TabIndex une valeur supérieure ou égale à 0 pour tous les éléments d’interface utilisateur interactifs qui ne sont pas dans l’ordre de tabulation par défaut. La définition de la propriété TabIndex est importante, car les utilisateurs de lecteurs d’écran naviguent parmi les éléments d’interface utilisateur interactifs à l’aide de la touche Tab.
  • Remarque  Windows :

    Utilisez les touches de direction comme raccourcis clavier pour la navigation interne correcte parmi les éléments enfants d’éléments composites. Si les nœuds de l’arborescence ont des éléments enfants distincts pour la gestion de la fonctionnalité développer-réduire et l’activation des nœuds, utilisez les touches de direction Gauche et Droite pour fournir au clavier la fonctionnalité développer-réduire.
  • Assurez-vous que chaque élément d’interface utilisateur sur lequel il est possible de cliquer peut également être appelé à l’aide du clavier.
  • Remarque  Windows :

    Implémentez des raccourcis clavier pour les fonctionnalités clés de l’application. (Un raccourci clavier est une combinaison de touches qui améliore la productivité en fournissant à l’utilisateur un moyen efficace d’accéder aux fonctionnalités de l’application.)

    Une touche d’accès est un raccourci vers un élément de l’interface utilisateur de votre application. Elle est composée de la touche Alt et d’une lettre.

    Une touche accélérateur est un raccourci vers une commande d’application. Votre application peut avoir une interface utilisateur qui correspond exactement à la commande. Les touches accélérateur sont formées à partir de la touche Ctrl et d’une lettre.

    Vous devez permettre aux utilisateurs qui se font aider de lecteurs d’écran et d’autres technologies d’assistance de découvrir facilement les touches de raccourci de votre application. Déclarez les touches de raccourci dans le balisage HTML à l’aide de la propriété AccessKey et indiquez-les à l’aide d’info-bulles, de noms accessibles, de descriptions accessibles ou d’autres formes de communication visuelle. Veillez à documenter correctement les touches de raccourci dans le contenu de l’aide de votre application.

    Pour obtenir de l’aide supplémentaire sur l’implémentation de touches de raccourci, voir la section Touches de raccourci dans les Recommandations en matière d’expérience utilisateur Windows.

    Ne redéfinissez pas les raccourcis clavier par défaut auxquels les utilisateurs sont habitués dans toute application du Windows Store. Voir Raccourcis clavier pour une liste complète.

Matériel

Interrogez les fonctionnalités du clavier (KeyboardCapabilities) pour déterminer si un clavier est connecté et pour identifier les aspects de l’interface utilisateur de votre application auxquels le clavier peut accéder directement. Pour plus d’informations sur l’interrogation des fonctionnalités du périphérique, voir Démarrage rapide : identification des périphériques de pointage.

Associez les boutons de clavier aux éléments d’interface utilisateur appropriés (boutons Précédent et Suivant) dans votre application.

Retour visuel

  • Utilisez les rectangles de sélection uniquement pour les interactions avec le clavier. Si l’utilisateur commence une interaction tactile, estompez progressivement l’interface utilisateur du clavier. Cela maintient l’interface utilisateur propre et aérée.
  • N’affichez pas de retour visuel si un élément ne prend pas en charge l’interaction (tel que le texte statique).
  • Affichez un retour visuel simultanément pour tous les éléments qui représentent la même cible d’entrée.
  • Fournissez des boutons à l’écran (par exemple + et -) en guise d’indications pour émuler des manipulations tactiles comme le mouvement panoramique, la rotation, le zoom, etc.

Pour obtenir des recommandations plus générales sur le retour visuel, voir Recommandations en matière de retour visuel.

Rubriques associées

Étude conceptuelle
Réponse à l’interaction utilisateur
Démarrage rapide : ajout de contrôles HTML et gestion des événements
Implémentation de l’accessibilité du clavier
Accessibilité dans les applications du Windows Store en C++, C# ou Visual Basic
Affichage et édition de texte
Input Hosting Manager et le clavier tactile

 

 

Afficher:
© 2015 Microsoft