Vue d’ensemble des entrées du clavier

  • Article

Les applications doivent accepter les entrées utilisateur du clavier et de la souris. Une application reçoit une entrée au clavier sous la forme de messages publiés dans ses fenêtres.

Modèle d’entrée clavier

Le système fournit la prise en charge du clavier indépendant du périphérique pour les applications en installant un pilote de périphérique clavier approprié pour le clavier actuel. Le système fournit une prise en charge du clavier indépendante de la langue à l’aide de la disposition de clavier spécifique à la langue actuellement sélectionnée par l’utilisateur ou l’application. Le pilote du périphérique clavier reçoit des codes d’analyse du clavier, qui sont envoyés à la disposition du clavier, où ils sont traduits en messages et publiés dans les fenêtres appropriées dans votre application.

Affecté à chaque touche d’un clavier est une valeur unique appelée code d’analyse, identificateur dépendant de l’appareil pour la touche du clavier. Un clavier génère deux codes d’analyse lorsque l’utilisateur tape une touche : l’un lorsque l’utilisateur appuie sur la touche et l’autre lorsque l’utilisateur relâche la touche.

Le pilote de périphérique clavier interprète un code d’analyse et le traduit (mappe) en code de clé virtuelle, une valeur indépendante du périphérique définie par le système qui identifie l’objectif d’une clé. Après avoir traduit un code d’analyse, la disposition du clavier crée un message qui inclut le code d’analyse, le code de touche virtuelle et d’autres informations sur la séquence de touches, puis place le message dans la file d’attente des messages système. Le système supprime le message de la file d’attente des messages système et le publie dans la file d’attente des messages du thread approprié. Finalement, la boucle de message du thread supprime le message et le transmet à la procédure de fenêtre appropriée pour le traitement. La figure suivante illustre le modèle d’entrée clavier.

modèle de traitement d’entrée clavier

Focus et activation du clavier

Le système publie des messages clavier dans la file d’attente des messages du thread de premier plan qui a créé la fenêtre avec le focus clavier. Le focus clavier est une propriété temporaire d’une fenêtre. Le système partage le clavier entre toutes les fenêtres de l’écran en déplaçant le focus du clavier, dans la direction de l’utilisateur, d’une fenêtre à une autre. La fenêtre qui a le focus clavier reçoit (de la file d’attente de messages du thread qui l’a créée) tous les messages clavier jusqu’à ce que le focus passe à une autre fenêtre.

Un thread peut appeler la fonction GetFocus pour déterminer laquelle de ses fenêtres (le cas échéant) a actuellement le focus clavier. Un thread peut donner le focus clavier à l’une de ses fenêtres en appelant la fonction SetFocus . Lorsque le focus clavier passe d’une fenêtre à une autre, le système envoie un message WM_KILLFOCUS à la fenêtre qui a perdu le focus, puis envoie un message WM_SETFOCUS à la fenêtre qui a obtenu le focus.

Le concept de focus clavier est lié à celui de la fenêtre active. La fenêtre active est la fenêtre de niveau supérieur avec laquelle l’utilisateur travaille actuellement. La fenêtre avec le focus clavier est la fenêtre active ou une fenêtre enfant de la fenêtre active. Pour aider l’utilisateur à identifier la fenêtre active, le système la place en haut de l’ordre Z et met en surbrillance sa barre de titre (le cas échéant) et sa bordure.

L’utilisateur peut activer une fenêtre de niveau supérieur en cliquant dessus, en la sélectionnant à l’aide de la combinaison de touches ALT+TAB ou ALT+ÉCHAP, ou en la sélectionnant dans la liste des tâches. Un thread peut activer une fenêtre de niveau supérieur à l’aide de la fonction SetActiveWindow . Il peut déterminer si une fenêtre de niveau supérieur qu’elle a créée est active à l’aide de la fonction GetActiveWindow .

Lorsqu’une fenêtre est désactivée et qu’une autre est activée, le système envoie le message WM_ACTIVATE . Le mot d’ordre inférieur du paramètre wParam est égal à zéro si la fenêtre est désactivée et non nulle si elle est activée. Lorsque la procédure de fenêtre par défaut reçoit le message WM_ACTIVATE , elle définit le focus clavier sur la fenêtre active.

Pour empêcher les événements d’entrée du clavier et de la souris d’atteindre les applications, utilisez BlockInput. Notez que la fonction BlockInput n’interfère pas avec la table d’état d’entrée asynchrone du clavier. Cela signifie que l’appel de la fonction SendInput alors que l’entrée est bloquée modifie la table d’état d’entrée asynchrone du clavier.

Messages de séquence de touches

Appuyez sur une touche pour placer un message WM_KEYDOWN ou WM_SYSKEYDOWN dans la file d’attente des messages de thread attachée à la fenêtre qui a le focus clavier. La libération d’une clé entraîne le WM_KEYUP ou WM_SYSKEYUP message dans la file d’attente.

Les messages de saisie rapide et de touche vers le bas se produisent généralement par paires, mais si l’utilisateur conserve une touche suffisamment longtemps pour démarrer la fonctionnalité de répétition automatique du clavier, le système génère un certain nombre de messages WM_KEYDOWN ou WM_SYSKEYDOWN dans une ligne. Il génère ensuite un seul message WM_KEYUP ou WM_SYSKEYUP lorsque l’utilisateur libère la clé.

Cette section couvre les sujets suivants :

Séquences de touches système et non système

Le système fait une distinction entre les séquences de touches système et les séquences de touches non système. Les séquences de touches système produisent des messages de séquence de touches système, des WM_SYSKEYDOWN et des WM_SYSKEYUP. Les séquences de touches non système produisent des messages de séquence de touches non système, des WM_KEYDOWN et des WM_KEYUP.

Si votre procédure de fenêtre doit traiter un message de séquence de touches système, assurez-vous qu’après avoir traité le message, la procédure le transmet à la fonction DefWindowProc . Sinon, toutes les opérations système impliquant la touche ALT sont désactivées chaque fois que la fenêtre a le focus clavier. Autrement dit, l’utilisateur ne pourra pas accéder aux menus de la fenêtre ou au menu Système, ni utiliser la combinaison de touches ALT+ÉCHAP ou ALT+TAB pour activer une autre fenêtre.

Les messages de séquence de touches système sont principalement destinés au système plutôt qu’à une application. Le système les utilise pour fournir son interface clavier intégrée aux menus et permettre à l’utilisateur de contrôler la fenêtre active. Les messages de séquence de touches système sont générés lorsque l’utilisateur tape une touche en combinaison avec la touche ALT, ou quand l’utilisateur tape et qu’aucune fenêtre n’a le focus clavier (par exemple, lorsque l’application active est réduite). Dans ce cas, les messages sont publiés dans la file d’attente des messages attachée à la fenêtre active.

Les messages de frappe non système sont destinés aux fenêtres d’application ; la fonction DefWindowProc n’y fait rien. Une procédure de fenêtre peut ignorer tous les messages de séquence de touches non système dont elle n’a pas besoin.

Virtual-Key codes décrits

Le paramètre wParam d’un message de séquence de touches contient le code de la touche virtuelle de la touche qui a été enfoncée ou relâchée. Une procédure de fenêtre traite ou ignore un message de séquence de touches, en fonction de la valeur du code de clé virtuelle.

Une procédure de fenêtre classique ne traite qu’un petit sous-ensemble des messages de séquence de touches qu’elle reçoit et ignore le reste. Par exemple, une procédure de fenêtre peut traiter uniquement WM_KEYDOWN messages de frappe et uniquement ceux qui contiennent des codes de touche virtuelle pour les touches de mouvement du curseur, les touches de décalage (également appelées touches de contrôle) et les touches de fonction. Une procédure de fenêtre classique ne traite pas les messages de séquence de touches provenant de touches de caractères. Au lieu de cela, il utilise la fonction TranslateMessage pour convertir le message en messages caractères. Pour plus d’informations sur TranslateMessage et les messages de caractères, consultez Messages de caractères.

Indicateurs de message de séquence de touches

Le paramètre lParam d’un message de séquence de touches contient des informations supplémentaires sur la séquence de touches qui a généré le message. Ces informations incluent le nombre de répétitions, le code d’analyse, l’indicateur de clé étendue, le code de contexte, l’indicateur d’état de clé précédent et l’indicateur d’état de transition. L’illustration suivante montre les emplacements de ces indicateurs et valeurs dans le paramètre lParam .

emplacements des indicateurs et des valeurs dans le paramètre lparam d’un message de séquence de touches

Une application peut utiliser les valeurs suivantes pour obtenir les indicateurs de séquence de touches du mot d’ordre élevé de lParam.

Valeur Description
KF_EXTENDED
0x0100		 Manipule l’indicateur de clé étendue.
KF_DLGMODE
0x0800		 Manipule l’indicateur de mode de dialogue, qui indique si une boîte de dialogue est active.
KF_MENUMODE
0x1000		 Manipule l’indicateur de mode de menu, qui indique si un menu est actif.
KF_ALTDOWN
0x2000		 Manipule l’indicateur de code de contexte.
KF_REPEAT
0x4000		 Manipule l’indicateur d’état de clé précédent.
KF_UP
0x8000		 Manipule l’indicateur d’état de transition.

Exemple de code :

case WM_KEYDOWN:
case WM_KEYUP:
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
{
    WORD vkCode = LOWORD(wParam);                                 // virtual-key code
    
    WORD keyFlags = HIWORD(lParam);

    WORD scanCode = LOBYTE(keyFlags);                             // scan code
    BOOL isExtendedKey = (keyFlags & KF_EXTENDED) == KF_EXTENDED; // extended-key flag, 1 if scancode has 0xE0 prefix
    
    if (isExtendedKey)
        scanCode = MAKEWORD(scanCode, 0xE0);

    BOOL wasKeyDown = (keyFlags & KF_REPEAT) == KF_REPEAT;        // previous key-state flag, 1 on autorepeat
    WORD repeatCount = LOWORD(lParam);                            // repeat count, > 0 if several keydown messages was combined into one message

    BOOL isKeyReleased = (keyFlags & KF_UP) == KF_UP;             // transition-state flag, 1 on keyup

    // if we want to distinguish these keys:
    switch (vkCode)
    {
    case VK_SHIFT:   // converts to VK_LSHIFT or VK_RSHIFT
    case VK_CONTROL: // converts to VK_LCONTROL or VK_RCONTROL
    case VK_MENU:    // converts to VK_LMENU or VK_RMENU
        vkCode = LOWORD(MapVirtualKeyW(scanCode, MAPVK_VSC_TO_VK_EX));
        break;
    }

    // ...
}
break;

Nombre de répétitions

Vous pouvez case activée le nombre de répétitions pour déterminer si un message de frappe représente plusieurs frappes. Le système incrémente le nombre lorsque le clavier génère des messages WM_KEYDOWN ou WM_SYSKEYDOWN plus rapidement qu’une application ne peut les traiter. Cela se produit souvent lorsque l’utilisateur maintient une touche suffisamment longtemps pour démarrer la fonctionnalité de répétition automatique du clavier. Au lieu de remplir la file d’attente des messages système avec les messages de clé vers le bas résultants, le système combine les messages en un seul message de clé vers le bas et incrémente le nombre de répétitions. La libération d’une clé ne peut pas démarrer la fonctionnalité de répétition automatique, de sorte que le nombre de répétitions pour les messages WM_KEYUP et WM_SYSKEYUP est toujours défini sur 1.

Codes d’analyse

Diagramme d’un clavier de type 4 avec les emplacements des touches pour chaque touche.

Le code d’analyse est la valeur que le système génère lorsque l’utilisateur appuie sur une touche. Il s’agit d’une valeur qui identifie la touche enfoncée quelle que soit la disposition du clavier active, par opposition au caractère représenté par la touche. Une application ignore généralement les codes d’analyse. Au lieu de cela, il utilise les codes de clé virtuelle pour interpréter les messages de frappe.

Les claviers modernes utilisent la spécification HID (Human Interface Devices) pour communiquer avec un ordinateur. Le pilote de clavier convertit les valeurs d’utilisation HID signalées envoyées à partir du clavier pour analyser les données et les transmet aux applications.

Notes

Bien que les codes de touche virtuelle soient généralement plus utiles pour les applications de bureau, les codes d’analyse peuvent être requis dans des cas spécifiques lorsque vous avez besoin de savoir quelle touche est enfoncée, quelle que soit la disposition actuelle du clavier. Par exemple, les liaisons de touches WASD (W est haut, A est gauche, S est en bas et D à droite) pour les jeux, ce qui garantit une formation de touches cohérente entre les dispositions de clavier QWERTY ou Français AZERTY .

Le tableau suivant répertorie l’ensemble des codes d’analyse actuellement reconnus par Windows. Page /d’utilisation HID ID /d’utilisation HIDLes valeurs hid Usage Name référencent le document Hid Usage Tables. Les valeurs De l’emplacement de la clé font référence à l’image de clavier précédente.

Le code Make scan 1 est fourni dans WM_KEYDOWN/WM_KEYUP/WM_SYSKEYDOWN/messages WM_SYSKEYUP et WM_INPUT .

Page d’utilisation HID ID d’utilisation HID Nom d’utilisation HID Emplacement de la clé Scan 1 Make
07 01 ErrorRollOver FF
07 04 Clavier A 31 1E
07 05 Clavier B 50 30
07 06 Clavier C 48 2E
07 07 Clavier D 33 20
07 08 Clavier E 19 12
07 09 Clavier F 34 21
07 0A Clavier G 35 22
07 0B Clavier H 36 23
07 0C Clavier I 24 17
07 0D Clavier J 37 24
07 0E Clavier K 38 25
07 0F Clavier L 39 26
07 10 Clavier M 52 32
07 11 Clavier N 51 31
07 12 Clavier O 25 18
07 13 Clavier P 26 19
07 14 Clavier Q 17 10
07 15 Clavier R 20 13
07 16 Clavier S 32 1F
07 17 Clavier T 21 14
07 18 Clavier U 23 16
07 19 Clavier V 49 2F
07 1A Clavier W 18 11
07 1B Clavier X 47 2D
07 1C Clavier Y 22 15
07 1D Clavier Z 46 2C
07 1E Clavier 1 et Bang 2 02
07 1F Clavier 2 et At 3 03
07 20 Clavier 3 et hachage 4 04
07 21 Clavier 4 et Dollar 5 05
07 22 Clavier 5 et pourcentage 6 06
07 23 Clavier 6 et caret 7 07
07 24 Clavier 7 et Ampersand 8 08
07 25 Clavier 8 et Étoile 9 09
07 26 Clavier 9 et crochet gauche 10 0A
07 27 Clavier 0 et crochet droit 11 0B
07 28 Entrée de retour du clavier 43 1C
07 29 Échappement du clavier 110 01
07 2A Suppression du clavier 15 0E
07 2B Onglet clavier 16 0F
07 2C Espace du clavier 61 39
07 2D Tiret et trait de soulignement du clavier 12 0C
07 2E Clavier égal et plus 13 0D
07 2F Accolade gauche du clavier 27 1A
07 30 Accolade droite du clavier 28 1B
07 31 Barre oblique et barre oblique du clavier 29 2B
07 32 Clavier non-États-Unis 42 2B
07 33 Point-virgule et deux-points du clavier 40 27
07 34 Apos gauche du clavier et double 41 28
07 35 Accent grave du clavier et Tilde 1 29
07 36 Virgule clavier 53 33
07 37 Période du clavier 54 34
07 38 QuestionMark du clavier 55 35
07 39 Verrouillage des majuscules du clavier 30 3A
07 3A Clavier F1 112 3B
07 3B Clavier F2 113 3C
07 3C Clavier F3 114 3D
07 3D Clavier F4 115 3E
07 3E Clavier F5 116 3F
07 3F Clavier F6 117 40
07 40 Clavier F7 118 41
07 41 Clavier F8 119 42
07 42 Clavier F9 120 43
07 43 Clavier F10 121 44
07 44 Clavier F11 122 57
07 45 Clavier F12 123 58
07 46 Clavier PrintScreen 124 E0 37
54 *Note 1
07 47 Verrouillage de défilement du clavier 125 46
07 48 Pause du clavier 126 E1 1D 45
E0 46 *Note 2
45 *Note 3
07 49 Clavier Insertion 75 E0 52
07 4A Clavier d’accueil 80 E0 47
07 4B PageUp du clavier 85 % E0 49
07 4C Suppression du clavier vers l’avant 76 E0 53
07 4D Fin du clavier 81 E0 4F
07 4E Clavier PageDown 86 E0 51
07 4F Clavier RightArrow 89 E0 4D
07 50 Clavier LeftArrow 79 E0 4B
07 51 Clavier BasArrow 84 E0 50
07 52 Clavier UpArrow 83 E0 48
07 53 Verrouillage et effacement du numéro du clavier 90 45
E0 45 *Note 3
07 54 Barre oblique du clavier 95 E0 35
07 55 Keypad Star 100 37
07 56 Tiret du clavier 105 4A
07 57 Clavier Plus 106 4E
07 58 Entrée du clavier 108 E0 1C
07 59 Clavier 1 et Fin 93 4F
07 5A Clavier 2 et flèche bas 98 50
07 5B Clavier 3 et PageDn 103 51
07 5C Clavier 4 et flèche gauche 92 4B
07 5D Clavier 5 97 4C
07 5E Clavier 6 et flèche droite 102 4D
07 5F Clavier 7 et Accueil 91 47
07 60 Clavier 8 et flèche vers le haut 96 48
07 61 Clavier 9 et PageUp 101 49
07 62 Clavier 0 et Insertion 99 52
07 63 Période du clavier 104 53
07 64 Barre oblique du clavier autre que les États-Unis 45 56
07 65 Application clavier 129 E0 5D
07 66 Alimentation du clavier E0 5E
07 67 Touches égales 59
07 68 Clavier F13 64
07 69 Clavier F14 65
07 6A Clavier F15 66
07 6B Clavier F16 67
07 6C Clavier F17 68
07 6D Clavier F18 69
07 6E Clavier F19 6A
07 6F Clavier F20 6B
07 70 Clavier F21 6C
07 71 Clavier F22 6D
07 72 Clavier F23 6E
07 73 Clavier F24 76
07 85 % Virgule du clavier 107*Note 4 7E
07 87 Keyboard International1 56*Note 4, 5 73
07 88 Keyboard International2 133*Note 5 70
07 89 Keyboard International3 14*Note 5 7D
07 8A Clavier International4 132*Note 5 79
07 8B Keyboard International5 131*Note 5 7B
07 8C Keyboard International6 5C
07 90 Clavier LANG1 72 *Note 6
07 91 Clavier LANG2 71 *Note 6
07 92 Clavier LANG3 78
07 93 Clavier LANG4 77
07 94 Clavier LANG5 76
07 E0 Clavier LeftControl 58 1D
07 E1 Clavier LeftShift 44 2A
07 E2 Clavier LeftAlt 60 38
07 E3 Interface graphique graphique utilisateur gauche du clavier 127 E0 5B
07 E4 Clavier RightControl 64 E0 1D
07 E5 Clavier RightShift 57 36
07 E6 Clavier RightAlt 62 E0 38
07 E7 Interface graphique graphique utilisateur de droite du clavier 128 E0 5C
01 81 Mise hors tension du système E0 5E
01 82 Veille système E0 5F
01 83 Mise en éveil du système E0 63
0C 00B5 Analyser le suivi suivant E0 19
0C 00B6 Analyser la piste précédente E0 10
0C 00B7 Arrêter E0 24
0C 00CD Lecture/Pause E0 22
0C 00E2 Désactiver le son E0 20
0C 00E9 Incrémentation de volume E0 30
0C 00EA Décrémentation du volume E0 2E
0C 0183 Configuration du contrôle consommateur AL E0 6D
0C 018A Lecteur Email AL E0 6C
0C 0192 Calculatrice AL E0 21
0C 0194 AL Local Machine Browser E0 6B
0C 0221 Recherche ac E0 65
0C 0223 Accueil AC E0 32
0C 0224 AC Back E0 6A
0C 0225 AC Forward E0 69
0C 0226 Arrêt du contrôle d’accès E0 68
0C 0227 Actualisation du secteur E0 67
0C 022A Lien précédent ac E0 66

Remarques :

  1. Le code d’analyse de la touche SysRq est affiché sur alt+frappe d’écran d’impression
  2. Le code d’analyse de la touche d’arrêt est émis lors de la séquence de touches Ctrl+Pause
  3. Comme indiqué dans les messages clavier hérités
  4. La touche est présente sur les claviers brésiliens
  5. La touche est présente sur les claviers japonais
  6. Le code d’analyse est emmited dans l’événement de mise en production de clé uniquement

indicateur Extended-Key

L’indicateur de touche étendue indique si le message de frappe provient de l’une des touches supplémentaires du clavier 101/102 touches améliorées. Les touches étendues se composent des touches Alt et Ctrl situées sur le côté droit du clavier ; les touches INS, DEL, HOME, END, PAGE UP, PAGE DOWN et arrow dans les clusters à gauche du pavé numérique ; la clé NUM LOCK ; la touche BREAK (CTRL+PAUSE) ; la touche PRINT SCRN ; et les touches diviser (/) et ENTRÉE dans le pavé numérique. La touche MAJ de droite n’est pas considérée comme une clé étendue, elle a un code d’analyse distinct à la place.

S’il est spécifié, le code d’analyse se compose d’une séquence de deux octets, où le premier octet a une valeur de 0xE0.

Code de contexte

Le code de contexte indique si la touche ALT était hors service lorsque le message de frappe a été généré. Le code est 1 si la touche ALT était en panne et 0 si elle était up.

Indicateur de Key-State précédent

L’indicateur d’état de la clé précédent indique si la touche qui a généré le message de séquence de touches était précédemment en hausse ou en baisse. Il est 1 si la clé était précédemment en panne et 0 si la clé était précédemment montée. Vous pouvez utiliser cet indicateur pour identifier les messages de frappe générés par la fonctionnalité de répétition automatique du clavier. Cet indicateur est défini sur 1 pour WM_KEYDOWN et WM_SYSKEYDOWN messages de frappe générés par la fonctionnalité de répétition automatique. Elle est toujours définie sur 1 pour les messages WM_KEYUP et WM_SYSKEYUP .

indicateur Transition-State

L’indicateur d’état de transition indique si l’appui sur une touche ou la libération d’une touche a généré le message de séquence de touches. Cet indicateur est toujours défini sur 0 pour les messages WM_KEYDOWN et WM_SYSKEYDOWN ; elle est toujours définie sur 1 pour les messages WM_KEYUP et WM_SYSKEYUP .

Messages de caractères

Les messages de frappe fournissent beaucoup d’informations sur les séquences de touches, mais ils ne fournissent pas de codes de caractères pour les séquences de touches de caractères. Pour récupérer des codes de caractères, une application doit inclure la fonction TranslateMessage dans sa boucle de message de thread. TranslateMessage transmet un message WM_KEYDOWN ou WM_SYSKEYDOWN à la disposition du clavier. La disposition examine le code de clé virtuelle du message et, s’il correspond à une clé de caractère, fournit le code de caractère équivalent (en tenant compte de l’état des touches MAJ et CAPS LOCK). Il génère ensuite un message de caractères qui inclut le code du caractère et place le message en haut de la file d’attente des messages. L’itération suivante de la boucle de message supprime le message caractère de la file d’attente et distribue le message à la procédure de fenêtre appropriée.

Cette section couvre les sujets suivants :

Messages caractères non système

Une procédure de fenêtre peut recevoir les messages caractères suivants : WM_CHAR, WM_DEADCHAR, WM_SYSCHAR, WM_SYSDEADCHAR et WM_UNICHAR. La fonction TranslateMessage génère un message WM_CHAR ou WM_DEADCHAR lorsqu’elle traite un message WM_KEYDOWN . De même, il génère un message WM_SYSCHAR ou WM_SYSDEADCHAR lorsqu’il traite un message WM_SYSKEYDOWN .

Une application qui traite l’entrée au clavier ignore généralement tous les messages, sauf les messages WM_CHAR et WM_UNICHAR , en transmettant tous les autres messages à la fonction DefWindowProc . Notez que WM_CHAR utilise UTF-16 (format de transformation Unicode 16 bits) ou un jeu de caractères ANSI, tandis que WM_UNICHAR utilise toujours UTF-32 (format de transformation Unicode 32 bits). Le système utilise les messages WM_SYSCHAR et WM_SYSDEADCHAR pour implémenter des mnémoniques de menu.

Le paramètre wParam de tous les messages de caractères contient le code de caractère de la touche de caractère qui a été enfoncée. La valeur du code de caractère dépend de la classe window de la fenêtre qui reçoit le message. Si la version Unicode de la fonction RegisterClass a été utilisée pour inscrire la classe window, le système fournit des caractères Unicode à toutes les fenêtres de cette classe. Sinon, le système fournit des codes de caractères ANSI. Pour plus d’informations, consultez Inscription de classes de fenêtre et Utiliser des pages de code UTF-8 dans les applications Windows.

Le contenu du paramètre lParam d’un message caractère est identique au contenu du paramètre lParam du message key-down qui a été traduit pour produire le message caractère. Pour plus d’informations, consultez Indicateurs de message de frappe.

messages Dead-Character

Certains claviers non anglais contiennent des touches de caractères qui ne sont pas censées produire des caractères par elles-mêmes. Au lieu de cela, ils sont utilisés pour ajouter un diacritique au caractère produit par la frappe suivante. Ces clés sont appelées clés mortes. La touche circonflexe d’un clavier allemand est un exemple de touche morte. Pour entrer le caractère constitué d’un « o » avec une circonflexe, un utilisateur allemand taperait la touche circonflexe suivie de la touche « o ». La fenêtre avec le focus clavier reçoit la séquence de messages suivante :

  1. WM_KEYDOWN
  2. WM_DEADCHAR
  3. WM_KEYUP
  4. WM_KEYDOWN
  5. WM_CHAR
  6. WM_KEYUP

TranslateMessage génère le message WM_DEADCHAR lorsqu’il traite le message WM_KEYDOWN à partir d’une clé morte. Bien que le paramètre wParam du message WM_DEADCHAR contienne le code de caractère du diacritique de la clé morte, une application ignore généralement le message. Au lieu de cela, il traite le message WM_CHAR généré par la frappe suivante. Le paramètre wParam du message WM_CHAR contient le code de caractère de la lettre avec le diacritique. Si la frappe suivante génère un caractère qui ne peut pas être combiné avec un diacritique, le système génère deux messages WM_CHAR . Le paramètre wParam du premier contient le code de caractère du diacritique ; le paramètre wParam du second contient le code de caractère de la clé de caractère suivante.

La fonction TranslateMessage génère le message WM_SYSDEADCHAR lorsqu’elle traite le message WM_SYSKEYDOWN à partir d’une clé morte système (une touche morte enfoncée en combinaison avec la touche ALT). Une application ignore généralement le message WM_SYSDEADCHAR .

État de la clé

Lors du traitement d’un message clavier, une application peut avoir besoin de déterminer la status d’une autre touche que celle qui a généré le message actuel. Par exemple, une application de traitement de texte qui permet à l’utilisateur d’appuyer sur MAJ+FIN pour sélectionner un bloc de texte doit case activée l’status de la touche MAJ chaque fois qu’il reçoit un message de frappe de la touche END. L’application peut utiliser la fonction GetKeyState pour déterminer la status d’une clé virtuelle au moment de la génération du message actuel ; elle peut utiliser la fonction GetAsyncKeyState pour récupérer la status actuelle d’une clé virtuelle.

La disposition du clavier conserve une liste de noms. Le nom d’une clé qui produit un caractère unique est le même que le caractère produit par la clé. Le nom d’une clé non caractéristique, telle que TAB et ENTRÉE, est stocké sous la forme d’une chaîne de caractères. Une application peut récupérer le nom d’une clé à partir du pilote de périphérique en appelant la fonction GetKeyNameText .

Traductions de touches et de caractères

Le système comprend plusieurs fonctions à usage spécial qui traduisent les codes d’analyse, les codes de caractères et les codes de clé virtuelle fournis par divers messages de frappe. Ces fonctions incluent MapVirtualKey, ToAscii, ToUnicode et VkKeyScan.

En outre, Microsoft Rich Edit 3.0 prend en charge l’IME HexToUnicode, qui permet à un utilisateur de convertir entre des caractères hexadécimaux et des caractères Unicode à l’aide de touches de raccourci. Cela signifie que lorsque Microsoft Rich Edit 3.0 est incorporé dans une application, l’application hérite des fonctionnalités de l’IME HexToUnicode.

Support Hot-Key

Une touche chaude est une combinaison de touches qui génère un message WM_HOTKEY , un message que le système place en haut de la file d’attente de messages d’un thread, contournant tous les messages existants dans la file d’attente. Les applications utilisent des touches de raccourci pour obtenir une entrée de clavier à priorité élevée de la part de l’utilisateur. Par exemple, en définissant une touche d’accès rapide composée de la combinaison de touches CTRL+C, une application peut permettre à l’utilisateur d’annuler une opération de longue durée.

Pour définir une clé d’accès rapide, une application appelle la fonction RegisterHotKey , en spécifiant la combinaison de clés qui génère le message WM_HOTKEY , le handle de la fenêtre pour recevoir le message et l’identificateur de la touche de raccourci. Lorsque l’utilisateur appuie sur la touche chaude, un message WM_HOTKEY est placé dans la file d’attente de messages du thread qui a créé la fenêtre. Le paramètre wParam du message contient l’identificateur de la clé de raccourci. L’application peut définir plusieurs touches d’accès rapide pour un thread, mais chaque clé chaude du thread doit avoir un identificateur unique. Avant la fin de l’application, elle doit utiliser la fonction UnregisterHotKey pour détruire la clé chaude.

Les applications peuvent utiliser un contrôle de touche chaude pour faciliter le choix d’une clé d’accès rapide par l’utilisateur. Les contrôles de touche chaude sont généralement utilisés pour définir une clé d’accès rapide qui active une fenêtre ; ils n’utilisent pas les fonctions RegisterHotKey et UnregisterHotKey . Au lieu de cela, une application qui utilise un contrôle de touche chaude envoie généralement le message WM_SETHOTKEY pour définir la clé d’accès rapide. Chaque fois que l’utilisateur appuie sur la touche chaude, le système envoie un message WM_SYSCOMMAND spécifiant SC_HOTKEY. Pour plus d’informations sur les contrôles de clé d’accès rapide, consultez « Utilisation des contrôles à clé chaude » dans Contrôles à clé chaude.

Touches de clavier pour la navigation et d’autres fonctions

Windows prend en charge les claviers avec des touches spéciales pour les fonctions de navigateur, les fonctions multimédias, le lancement d’applications et la gestion de l’alimentation. Le WM_APPCOMMAND prend en charge les touches de clavier supplémentaires. En outre, la fonction ShellProc est modifiée pour prendre en charge les touches de clavier supplémentaires.

Il est peu probable qu’une fenêtre enfant d’une application de composant puisse implémenter directement des commandes pour ces touches de clavier supplémentaires. Par conséquent, lorsque l’une de ces touches est enfoncée, DefWindowProc envoie un message WM_APPCOMMAND à une fenêtre. DefWindowProc fait également buller le message WM_APPCOMMAND dans sa fenêtre parente. Cela est similaire à la façon dont les menus contextuels sont appelés avec le bouton droit de la souris, c’est-à-dire que DefWindowProc envoie un message WM_CONTEXTMENU sur un clic droit et le fait buller à son parent. En outre, si DefWindowProc reçoit un message WM_APPCOMMAND pour une fenêtre de niveau supérieur, il appelle un crochet d’interpréteur de commandes avec du code HSHELL_APPCOMMAND.

Windows prend également en charge le Explorer Microsoft IntelliMouse, qui est une souris avec cinq boutons. Les deux boutons supplémentaires prennent en charge la navigation par navigateur avant et arrière. Pour plus d’informations, consultez XBUTTONs.

Simulation d’entrée

Pour simuler une série ininterrompue d’événements d’entrée utilisateur, utilisez la fonction SendInput . La fonction accepte trois paramètres. Le premier paramètre, cInputs, indique le nombre d’événements d’entrée qui seront simulés. Le deuxième paramètre, rgInputs, est un tableau de structures INPUT , chacune décrivant un type d’événement d’entrée et des informations supplémentaires sur cet événement. Le dernier paramètre, cbSize, accepte la taille de la structure INPUT , en octets.

La fonction SendInput fonctionne en injectant une série d’événements d’entrée simulés dans le flux d’entrée d’un appareil. L’effet est similaire à l’appel répété de la fonction keybd_event ou mouse_event , sauf que le système garantit qu’aucun autre événement d’entrée ne s’entremêle avec les événements simulés. Une fois l’appel terminé, la valeur de retour indique le nombre d’événements d’entrée correctement lus. Si cette valeur est égale à zéro, l’entrée a été bloquée.

La fonction SendInput ne réinitialise pas l’état actuel du clavier. Par conséquent, si l’utilisateur a des touches enfoncées lorsque vous appelez cette fonction, elles peuvent interférer avec les événements générés par cette fonction. Si vous êtes préoccupé par les interférences possibles, case activée l’état du clavier avec la fonction GetAsyncKeyState et corrigez si nécessaire.

Langues, paramètres régionaux et dispositions du clavier

Une langue est une langue naturelle, comme l’anglais, le Français et le japonais. Une sous-langue est une variante d’une langue naturelle parlée dans une région géographique spécifique, comme les sous-langues anglaises parlées au Royaume-Uni et les États-Unis. Les applications utilisent des valeurs, appelées identificateurs de langue, pour identifier de manière unique les langues et les sous-langues.

Les applications utilisent généralement des paramètres régionaux pour définir la langue dans laquelle l’entrée et la sortie sont traitées. La définition des paramètres régionaux pour le clavier, par exemple, affecte les valeurs de caractères générées par le clavier. La définition des paramètres régionaux pour l’affichage ou l’imprimante affecte les glyphes affichés ou imprimés. Les applications définissent les paramètres régionaux d’un clavier en chargeant et en utilisant des dispositions de clavier. Ils définissent les paramètres régionaux d’un affichage ou d’une imprimante en sélectionnant une police qui prend en charge les paramètres régionaux spécifiés.

Une disposition de clavier spécifie non seulement la position physique des touches sur le clavier, mais détermine également les valeurs de caractères générées en appuyant sur ces touches. Chaque disposition identifie la langue d’entrée actuelle et détermine quelles valeurs de caractère sont générées par quelles touches et combinaisons de touches.

Chaque disposition de clavier a un handle correspondant qui identifie la disposition et la langue. Le mot bas du handle est un identificateur de langue. Le mot élevé est un handle d’appareil, spécifiant la disposition physique, ou est égal à zéro, indiquant une disposition physique par défaut. L’utilisateur peut associer n’importe quelle langue d’entrée à une disposition physique. Par exemple, un utilisateur anglophone qui travaille très occasionnellement dans Français peut définir la langue d’entrée du clavier sur Français sans modifier la disposition physique du clavier. Cela signifie que l’utilisateur peut entrer du texte dans Français à l’aide de la disposition anglaise familière.

Les applications ne sont généralement pas censées manipuler directement les langages d’entrée. Au lieu de cela, l’utilisateur configure des combinaisons de langue et de disposition, puis bascule entre celles-ci. Lorsque l’utilisateur clique sur du texte marqué avec une autre langue, l’application appelle la fonction ActivateKeyboardLayout pour activer la disposition par défaut de l’utilisateur pour cette langue. Si l’utilisateur modifie du texte dans une langue qui ne figure pas dans la liste active, l’application peut appeler la fonction LoadKeyboardLayout avec la langue pour obtenir une disposition basée sur cette langue.

La fonction ActivateKeyboardLayout définit la langue d’entrée de la tâche actuelle. Le paramètre hkl peut être le handle de la disposition du clavier ou un identificateur de langue zéro étendu. Les poignées de disposition du clavier peuvent être obtenues à partir de la fonction LoadKeyboardLayout ou GetKeyboardLayoutList . Les valeurs HKL_NEXT et HKL_PREV peuvent également être utilisées pour sélectionner le clavier suivant ou précédent.

La fonction GetKeyboardLayoutName récupère le nom de la disposition de clavier active pour le thread appelant. Si une application crée la disposition active à l’aide de la fonction LoadKeyboardLayout , GetKeyboardLayoutName récupère la même chaîne que celle utilisée pour créer la disposition. Sinon, la chaîne est l’identificateur de langue principal correspondant aux paramètres régionaux de la disposition active. Cela signifie que la fonction peut ne pas nécessairement différencier différentes dispositions avec la même langue primaire. Elle ne peut donc pas retourner d’informations spécifiques sur la langue d’entrée. Toutefois, la fonction GetKeyboardLayout peut être utilisée pour déterminer la langue d’entrée.

La fonction LoadKeyboardLayout charge une disposition de clavier et la met à la disposition de l’utilisateur. Les applications peuvent rendre la disposition immédiatement active pour le thread actuel à l’aide de la valeur KLF_ACTIVATE . Une application peut utiliser la valeur KLF_REORDER pour réorganiser les dispositions sans spécifier la valeur KLF_ACTIVATE . Les applications doivent toujours utiliser la valeur KLF_SUBSTITUTE_OK lors du chargement des dispositions du clavier pour s’assurer que la préférence de l’utilisateur, le cas échéant, est sélectionnée.

Pour la prise en charge multilingue, la fonction LoadKeyboardLayout fournit les indicateurs KLF_REPLACELANG et KLF_NOTELLSHELL . L’indicateur KLF_REPLACELANG indique à la fonction de remplacer une disposition de clavier existante sans modifier la langue. La tentative de remplacement d’une disposition existante à l’aide du même identificateur de langue, mais sans spécifier KLF_REPLACELANG est une erreur. L’indicateur KLF_NOTELLSHELL empêche la fonction de notifier l’interpréteur de commandes lorsqu’une disposition de clavier est ajoutée ou remplacée. Cela est utile pour les applications qui ajoutent plusieurs dispositions dans une série consécutive d’appels. Cet indicateur doit être utilisé dans tous les appels sauf le dernier.

La fonction UnloadKeyboardLayout est limitée en ce qu’elle ne peut pas décharger la langue d’entrée par défaut du système. Cela garantit que l’utilisateur dispose toujours d’une disposition disponible pour entrer du texte en utilisant le même jeu de caractères que celui utilisé par l’interpréteur de commandes et le système de fichiers.