Übersicht über die Tastatureingabe

Anwendungen sollten Benutzereingaben sowohl über die Tastatur als auch über die Maus akzeptieren. Eine Anwendung empfängt Tastatureingaben in Form von Nachrichten, die an ihre Fenster gesendet werden.

Tastatureingabemodell

Das System bietet geräteunabhängige Tastaturunterstützung für Anwendungen, indem es einen Tastaturgerätetreiber installiert, der für die aktuelle Tastatur geeignet ist. Das System bietet sprachunabhängige Tastaturunterstützung mithilfe des sprachspezifischen Tastaturlayouts, das der Benutzer oder die Anwendung derzeit ausgewählt hat. Der Tastaturgerätetreiber empfängt Scancodes von der Tastatur, die an das Tastaturlayout gesendet werden, wo sie in Nachrichten übersetzt und an die entsprechenden Fenster in Ihrer Anwendung gesendet werden.

Jeder Taste auf einer Tastatur wird ein eindeutiger Wert zugewiesen, der als Scancode bezeichnet wird, ein geräteabhängiger Bezeichner für die Taste auf der Tastatur. Eine Tastatur generiert zwei Scancodes, wenn der Benutzer auf eine Taste drückt – einen, wenn der Benutzer die Taste drückt, und einen weiteren, wenn der Benutzer die Taste loslässt.

Der Tastaturgerätetreiber interpretiert einen Scancode und übersetzt ihn in einen Virtuellen Schlüsselcode, einen geräteunabhängigen vom System definierten Wert, der den Zweck einer Taste identifiziert. Nach der Übersetzung eines Scancodes wird über das Tastaturlayout eine Nachricht erstellt, die den Scancode, den Code der virtuellen Taste und andere Informationen zur Tastatureingabe enthält, und die Nachricht wird in der Systemnachrichtenwarteschlange platziert. Das System entfernt die Nachricht aus der Systemnachrichtenwarteschlange und stellt sie in die Nachrichtenwarteschlange des entsprechenden Threads. Schließlich entfernt die Nachrichtenschleife des Threads die Nachricht und übergibt sie zur Verarbeitung an die entsprechende Fensterprozedur. In der folgenden Abbildung ist das Tastatureingabemodell dargestellt.

Tastaturfokus und Aktivierung

Das System sendet Tastaturnachrichten an die Nachrichtenwarteschlange des Vordergrundthreads, der das Fenster mit dem Tastaturfokus erstellt hat. Der Tastaturfokus ist eine temporäre Eigenschaft eines Fensters. Das System teilt die Tastatur auf alle Fenstern in der Anzeige auf, indem der Tastaturfokus in Richtung des Benutzers von einem Fenster in ein anderes verschoben wird. Das Fenster mit dem Tastaturfokus empfängt (aus der Nachrichtenwarteschlange des Threads, von dem es erstellt wurde) alle Tastaturnachrichten, bis der Fokus in ein anderes Fenster wechselt.

Ein Thread kann die GetFocus-Funktion aufrufen, um zu bestimmen, welches seiner Fenster ggf. derzeit den Tastaturfokus hat. Ein Thread kann durch Aufrufen der SetFocus-Funktion den Tastaturfokus auf eines seiner Fenster legen. Wenn der Tastaturfokus von einem Fenster in ein anderes geändert wird, sendet das System eine WM_KILLFOCUS-Nachricht an das Fenster, das den Fokus verloren hat, und sendet dann eine WM_SETFOCUS-Nachricht an das Fenster, das den Fokus erhalten hat.

Das Konzept des Tastaturfokus hängt mit dem des aktiven Fensters zusammen. Das aktive Fenster ist das Fenster auf der obersten Ebene, mit dem der Benutzer derzeit arbeitet. Das Fenster mit dem Tastaturfokus ist entweder das aktive Fenster oder ein untergeordnetes Fenster des aktiven Fensters. Um den Benutzer bei der Identifizierung des aktiven Fensters zu unterstützen, platziert das System es oben in der Z-Reihenfolge und hebt ggf. die Titelleiste und den Rahmen hervor.

Der Benutzer kann ein Fenster auf oberster Ebene aktivieren, indem er darauf klickt und es mit der Tastenkombination ALT+TAB oder ALT+ESC aus der Aufgabenliste auswählt. Ein Thread kann ein Fenster auf oberster Ebene mithilfe der SetActiveWindow-Funktion aktivieren. Er kann mithilfe der GetActiveWindow-Funktion ermitteln, ob ein von ihm erstelltes Fenster auf oberster Ebene aktiv ist.

Wenn ein Fenster deaktiviert und ein anderes aktiviert ist, sendet das System die Nachricht WM_ACTIVATE. Das niederwertige Wort des Parameters wParam ist null, wenn das Fenster deaktiviert wird, und ungleich null, wenn es aktiviert wird. Wenn die Standardfensterprozedur die Nachricht WM_ACTIVATE empfängt, wird der Tastaturfokus auf das aktive Fenster gelegt.

Verwenden Sie BlockInput, um zu verhindern, dass Tastatur- und Mauseingabeereignisse Anwendungen erreichen. Beachten Sie, dass die BlockInput-Funktion die Tabelle mit dem asynchronen Tastatureingabestatus nicht beeinträchtigt. Dies bedeutet, dass das Aufrufen der SendInput-Funktion, während die Eingabe blockiert wird, die Tabelle mit dem asynchronen Tastatureingabestatus ändert.

Nachrichten zur Tastatureingabe

Wenn Sie eine Taste drücken, wird eine WM_KEYDOWN- oder eine WM_SYSKEYDOWN-Nachricht in der Threadnachrichtenwarteschlange platziert, die an das Fenster mit dem Tastaturfokus angefügt ist. Durch das Freigeben einer Taste wird eine WM_KEYUP - oder eine WM_SYSKEYUP-Nachricht in der Warteschlange platziert.

Key-up- und Key-down-Nachrichten treten in der Regel in Paaren auf. Wenn der Benutzer jedoch eine Taste so lange gedrückt hält, dass die automatische Wiederholungsfunktion der Tastatur gestartet wird, generiert das System nacheinander eine Reihe von WM_KEYDOWN- oder WM_SYSKEYDOWN-Nachrichten. Anschließend wird eine einzelne WM_KEYUP- oder WM_SYSKEYUP-Nachricht generiert, wenn der Benutzer die Taste freigibt.

Dieser Abschnitt enthält die folgenden Themen:

• System- und systemfremde Tastatureingaben
• Beschriebene Codes für virtuelle Tasten
• Nachrichten -Flags für Tastatureingaben

System- und systemfremde Tastatureingaben

Das System unterscheidet zwischen Systemtastatureingaben und systemfremden Tastatureingaben. Systemtastatureingaben erzeugen Nachrichten zu Systemtastatureingaben,WM_SYSKEYDOWN und WM_SYSKEYUP. Systemfremde Tastatureingaben erzeugen Nachrichten zu systemfremden Tastatureingaben, WM_KEYDOWN und WM_KEYUP.

Wenn Ihre Fensterprozedur eine Systemtastennachricht verarbeiten muss, stellen Sie sicher, dass die Prozedur sie nach der Verarbeitung der Nachricht an die DefWindowProc-Funktion übergibt. Andernfalls werden alle Systemvorgänge mit der ALT-Taste deaktiviert, wenn das Fenster den Tastaturfokus hat. Das heißt, der Benutzer kann nicht auf die Menüs oder das Systemmenü des Fensters zugreifen oder die Tastenkombination ALT+ESC oder ALT+TAB verwenden, um ein anderes Fenster zu aktivieren.

Nachrichten zu Systemtastatureingaben werden in erster Linie vom System und nicht von einer Anwendung verwendet. Das System verwendet sie, um die integrierte Tastaturschnittstelle für Menüs bereitzustellen und es dem Benutzer zu ermöglichen, zu steuern, welches Fenster aktiv ist. Nachrichten zu Systemtastatureingaben werden generiert, wenn der Benutzer eine Taste in Kombination mit der ALT-TASTE eingibt oder wenn der Benutzer etwas eingibt und kein Fenster den Tastaturfokus hat (z. B. wenn die aktive Anwendung minimiert wird). In diesem Fall werden die Nachrichten an die Nachrichtenwarteschlange gesendet, die an das aktive Fenster angefügt ist.

Nachrichten zu systemfremden Tastatureingaben sind für die Verwendung in Anwendungsfenstern vorgesehen. Die DefWindowProc-Funktion macht nichts mit ihnen. Eine Fensterprozedur kann alle Meldungen zu systemfremden Tastatureingaben verwerfen, die nicht benötigt werden.

Beschriebene Codes für virtuelle Tasten

Der Parameter wParam in einer Nachricht zu einer Tastatureingabe enthält den virtuellen Tastencode der Taste, die gedrückt oder freigegeben wurde. Eine Fensterprozedur verarbeitet oder ignoriert je nach Wert des virtuellen Tastencodes eine Nachricht zu einer Tastatureingabe.

Eine typische Fensterprozedur verarbeitet nur eine kleine Teilmenge der Meldungen zu einer Tastatureingabe, die sie empfängt, und ignoriert den Rest. Beispielsweise kann eine Nachrichten nur WM_KEYDOWN-Nachrichten zu Tastatureingaben verarbeiten, und nur solche, die virtuelle Schlüsselcodes für die Cursorbewegungstasten, Umschalttasten (auch als Steuertasten bezeichnet) und Funktionstasten enthalten. Eine typische Fensterprozedur verarbeitet keine Nachrichten zu Tastatureingaben von Tasten mit Zeichen. Stattdessen wird die TranslateMessage-Funktion verwendet, um die Nachricht in Zeichennachrichten zu konvertieren. Weitere Informationen zu TranslateMessage- und Zeichennachrichten finden Sie unter Zeichennachrichten.

Nachrichten -Flags für Tastatureingaben

Der Parameter lParam einer Nachricht zu Tastatureingaben enthält zusätzliche Informationen zu der Tastatureingabe, mit der die Nachricht generiert wurde. Diese Informationen umfassen die Wiederholungsanzahl, den Scancode, das Flag für erweiterte Tasten, den Kontextcode, das Flag zum vorherigen Tastenstatus und das Flag zum Übergangsstatus. Die folgende Abbildung zeigt die Speicherorte dieser Flags und Werte im Parameter lParam.

Eine Anwendung kann die folgenden Werte verwenden, um die Tastatureingabeflags aus dem hochwertigen Wort des lParam abzurufen.

Codebeispiel:

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;

Zahl der Wiederholungen

Sie können die Wiederholungsanzahl überprüfen, um zu bestimmen, ob eine Tastatureingabe mehrere Tastatureingaben darstellt. Das System erhöht die Anzahl, wenn die Tastatur WM_KEYDOWN oder WM_SYSKEYDOWN Nachrichten schneller generiert, als eine Anwendung sie verarbeiten kann. Dies tritt häufig auf, wenn der Benutzer eine Taste lange genug gedrückt hält, um die automatische Wiederholungsfunktion der Tastatur zu starten. Anstatt die Systemnachrichtenwarteschlange mit den resultierenden Key-Down-Nachrichten zu füllen, kombiniert das System die Nachrichten in einer einzelnen Key-Down-Nachricht und erhöht die Wiederholungsanzahl. Das Freigeben einer Taste kann das Feature für automatische Wiederholungen nicht starten, sodass die Wiederholungsanzahl für WM_KEYUP und WM_SYSKEYUP-Nachrichten immer auf „1“ festgelegt ist.

Scancodes

Der Scancode ist der Wert, den das System generiert, wenn Benutzer*innen eine Taste drücken. Es handelt sich um einen Wert, der die Taste unabhängig vom aktiven Tastaturlayout identifiziert – im Gegensatz zu dem Zeichen, das durch die Taste dargestellt wird. Eine Anwendung ignoriert Scancodes in der Regel. Stattdessen werden virtuelle Tastencodes verwendet, um Tastaturanschlagmeldungen zu interpretieren.

Moderne Tastaturen verwenden die HID-Spezifikation (Human Interface Devices), um mit einem Computer zu kommunizieren. Der Tastaturtreiber konvertiert die von der Tastatur gemeldeten HID-Verwendungswerte in Tastencodes und leitet diese an Anwendungen weiter.

In der folgenden Tabelle sind die Scancodes aufgeführt, die derzeit von Windows erkannt werden. Die Werte HID-Verwendungsseite/HID-Verwendungs-ID/HID-Verwendungsname finden Sie im Dokument HID-Verwendungstabellen. Die Werte für die Tastenposition finden Sie im obigen Tastaturbild.

Der Code Scan 1 Make wird in WM_KEYDOWN/WM_KEYUP/WM_SYSKEYDOWN/WM_SYSKEYUP- und WM_INPUT-Nachrichten übermittelt.

Hinweise:

1. Der Tastencode SysRq wird beim Tastendruck ALT+DRUCK ausgegeben.
2. Der Tastencode Break wird beim Tastendruck STRG+PAUSE ausgegeben.
3. Wie in älteren Tastaturnachrichten zu sehen
4. Die Taste ist auf brasilianischen Tastaturen vorhanden.
5. Die Taste ist auf japanischen Tastaturen vorhanden.
6. Der Tastencode wird nur beim Loslassen der Taste ausgegeben.

Flat für erweiterte Taste

Das Flag für erweiterte Taste gibt an, ob die Tastatureingabenachricht von einer der zusätzlichen Tasten auf der erweiterten Tastatur mit 101/102-Tasten stammt. Die erweiterten Tasten bestehen aus den ALT- und STRG-Tasten auf der rechten Seite der Tastatur, den Tasten EINFG, ENTF, POS1, ENDE, BILD AUF, BILD AB und den Pfeiltasten in den Clustern links neben der Zehnertastatur, der NUM-Taste, der Taste PAUSE/UNTERBR (STRG+PAUSE); der BILDSCHIRM DRUCKEN-Taste und der Slash-(/-) und der EINGABE-Taste auf der numerischen Zehnertastatur. Die rechte UMSCHALT-Taste gilt nicht als erweiterte TasteSchlüssel, sondern verfügt stattdessen über einen separaten Scancode.

Sofern angegeben, besteht der Scancode aus einer Sequenz von zwei Bytes, wobei das erste Byte den Wert 0xE0 hat.

Kontextcode

Der Kontextcode gibt an, ob die ALT-Taste ausgefallen ist, als die Tastatureingabenachricht generiert wurde. Der Code ist 1, wenn die ALT-Taste gedrückt war, und 0, wenn sie nicht gedrückt war.

Flag für vorherigen Tastenstatus

Das Flag für den vorherigen Tastenstatus gibt an, ob die Taste, mit der die Tastatureingabenachricht generiert wurde, zuvor gedrückt oder nicht gedrückt war. Es ist 1, wenn die Taste zuvor gedrückt war, und 0, wenn die Taste Schlüssel zuvor nicht gedrückt war. Sie können dieses Flag verwenden, um Tastatureingabenachrichten zu identifizieren, die von der Funktion für automatische Wiederholungen der Tastatur generiert werden. Dieses Flag ist für WM_KEYDOWN und WM_SYSKEYDOWN-Tastatureingabenachrichten, die vom Feature für automatische Wiederholungen generiert werden, auf „1“ festgelegt. Sie ist für WM_KEYUP- und WM_SYSKEYUP-Nachrichten immer auf „1“ festgelegt.

Flag für Übergangsstatus

Das Flag für „Übergangsstatus“ gibt an, ob die Tastatureingabenachricht durch das Drücken einer Taste oder das Loslassen einer Taste generiert wurde. Dieses Flag ist für WM_KEYDOWN und WM_SYSKEYDOWN-Nachrichten immer auf „0“ festgelegt. Für WM_KEYUP- und WM_SYSKEYUP-Nachrichten ist es immer auf „1“ festgelegt.

Zeichennachrichten

Tastatureingabenachrichten bieten viele Informationen zu Tastatureingaben, aber sie stellen keine Zeichencodes für Zeichentastatureingaben bereit. Zum Abrufen von Zeichencodes muss eine Anwendung die TranslateMessage-Funktion in ihre Threadnachrichtenschleife einschließen. TranslateMessage übergibt eine WM_KEYDOWN-- oder WM_SYSKEYDOWN-Nachricht an das Tastaturlayout. Das Layout untersucht den virtuellen Tastencode der Nachricht und stellt, wenn er einer Zeichentaste entspricht, die Äquivalente des Zeichencodes bereit (unter Berücksichtigung des Zustands der UMSCHALT- und FESTSTELL-Tasten). Anschließend wird eine Zeichennachricht generiert, die den Zeichencode enthält, und die Nachricht an den Anfang der Nachrichtenwarteschlange platziert. Durch die nächste Iteration der Nachrichtenschleife wird die Zeichennachricht aus der Warteschlange entfernt, und die Nachricht wird an die entsprechende Fensterprozedur gesendet.

Dieser Abschnitt enthält die folgenden Themen:

• Nachrichten zu systemfremden Zeichen
• Nachrichten zu Totzeichen

Nachrichten zu systemfremden Zeichen

Eine Fensterprozedur kann die folgenden Zeichennachrichten empfangen: WM_CHAR, WM_DEADCHAR, WM_SYSCHAR, WM_SYSDEADCHAR und WM_UNICHAR. Die TranslateMessage-Funktion generiert eine WM_CHAR oder eine WM_DEADCHAR-Nachricht, wenn sie eine WM_KEYDOWN-Nachricht verarbeitet. Ebenso generiert sie eine WM_SYSCHAR- oder eine WM_SYSDEADCHAR-Nachricht, wenn eine WM_SYSKEYDOWN-Nachricht verarbeitet wird.

Eine Anwendung, die Tastatureingaben verarbeitet, ignoriert in der Regel alle WM_CHAR- und WM_UNICHAR-Nachrichten und übergibt alle anderen Nachrichten an die DefWindowProc-Funktion. Beachten Sie, dass WM_CHAR deb UTF-16 (16-Bit Unicode Transformation Format) oder den ANSI-Zeichensatz verwendet, während WM_UNICHAR immer UTF-32 (32-Bit-Unicode-Transformationsformat) verwendet. Das System verwendet die WM_SYSCHAR und WM_SYSDEADCHAR-Nachrichten, um Menümnemonics zu implementieren.

Der Parameter wParam aller Zeichennachrichten enthält den Zeichencode der gedrückten Zeichentaste. Der Wert des Zeichencodes hängt von der Fensterklasse des Fensters ab, das die Nachricht empfängt. Wenn die Unicode-Version der RegisterClass-Funktion verwendet wurde, um die Fensterklasse zu registrieren, stellt das System Unicode-Zeichen für alle Fenster dieser Klasse bereit. Andernfalls stellt das System ANSI-Zeichencodes bereit. Weitere Informationen finden Sie unter Registrieren von Fensterklassen und Verwenden von UTF-8-Codepages in Windows-Apps.

Der Inhalt des Parameters lParam einer Zeichennachricht ist identisch mit dem Inhalt des Parameters lParam der Key-Down-Nachricht, die zur Erzeugung der Zeichennachricht übersetzt wurde. Weitere Informationen finden Sie unter Flags zu Tastatureingabenachrichten.

Nachrichten zu Totzeichen

Einige nicht englischsprachige Tastaturen enthalten Zeichentasten, von denen nicht erwartet wird, dass sie selbst Zeichen erzeugen. Stattdessen werden sie verwendet, um dem Zeichen, das durch die nachfolgende Tasteneingabe erzeugt wird, ein diakritisches Zeichen hinzuzufügen. Diese Schlüssel werden als Tottasten bezeichnet. Die Zirkumflextaste auf einer deutschen Tastatur ist ein Beispiel für eine Tottaste. Um das Zeichen einzugeben, das aus einem „o“ mit einem Zirkumflex besteht, würde ein deutscher Benutzer die Zirkumflex-Taste gefolgt von der „o“-Taste eingeben. Das Fenster mit dem Tastaturfokus erhält die folgende Nachrichtensequenz:

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

TranslateMessage generiert die WM_DEADCHAR-Nachricht, wenn die WM_KEYDOWN-Nachricht von einer Tottaste verarbeitet wird. Obwohl der Parameter wParam der WM_DEADCHAR-Nachricht den Zeichencode des diakritischen Zeichens für die Tottaste enthält, ignoriert eine Anwendung die Nachricht in der Regel. Stattdessen verarbeitet sie die WM_CHAR-Nachricht, die mit der nachfolgenden Tastatureingabe generiert wird. Der Parameter wParam der WM_CHAR-Nachricht enthält den Zeichencode des Buchstabens mit dem diakritischen Zeichen. Wenn mit der nachfolgenden Tastatureingabe ein Zeichen generiert wird, das nicht mit einem diakritischen Zeichen kombiniert werden kann, generiert das System zwei WM_CHAR-Nachrichten. Der Parameter wParam der ersten Nachricht enthält den Zeichencode des diakritischen Zeichens; der Parameter wParam der zweiten enthält den Zeichencode der nachfolgenden Zeichentaste.

Die TranslateMessage-Funktion generiert die WM_SYSDEADCHAR-Nachricht, wenn sie die WM_SYSKEYDOWN-Nachricht von einer Systemtottaste verarbeitet (eine Tottaste, die in Kombination mit der ALT-Taste gedrückt wird). Eine Anwendung ignoriert in der Regel die WM_SYSDEADCHAR-Nachricht.

Tastenstatus

Während der Verarbeitung einer Tastaturnachricht muss eine Anwendung möglicherweise den Status einer anderen Taste neben der Taste ermitteln, durch die die aktuelle Nachricht generiert wurde. Beispielsweise muss eine Textverarbeitungsanwendung, in der der Benutzer UMSCHALT+ENDE drücken kann, um einen Textblock auszuwählen, den Status der UMSCHALT-Taste überprüfen, wenn sie eine Tastatureingabenachricht von der ENDE-Taste empfängt. Die Anwendung kann mithilfe der GetKeyState-Funktion den Status einer virtuellen Taste zum Zeitpunkt der Generierung der aktuellen Nachricht bestimmen. Sie kann mit der GetAsyncKeyState-Funktion den aktuellen Status einer virtuellen Taste abrufen.

Das Tastaturlayout verwaltet eine Liste von Namen. Der Name einer Taste, die ein einzelnes Zeichen erzeugt, ist identisch mit dem von der Taste erzeugten Zeichen. Der Name einer Taste, die kein Zeichen generiert, wie z. B. die TAB und die EINGABE-Taste wird als Zeichenfolge gespeichert. Eine Anwendung kann den Namen einer beliebigen Taste vom Gerätetreiber abrufen, indem sie die Funktion GetKeyNameText aufruft.

Tastatureingabe- und Zeichenübersetzungen

Das System umfasst mehrere spezielle Funktionen, die Scancodes, Zeichencodes und Codes von virtuellen Tasten übersetzen, die von verschiedenen Tastatureingabenachrichten bereitgestellt werden. Zu diesen Funktionen gehören MapVirtualKey, ToAscii, ToUnicode und VkKeyScan.

Darüber hinaus unterstützt Microsoft Rich Edit 3.0 den HexToUnicode-IME, mit der ein Benutzer zwischen Hexadezimal- und Unicode-Zeichen mithilfe von Tastenkombinationen wechseln kann. Dies bedeutet, dass die Anwendung, wenn Microsoft Rich Edit 3.0 in eine Anwendung integriert wird, die Features der HexToUnicode-IME erbt.

Hot-Key-Support

Ein Hot-Key ist eine Tastenkombination, die eine WM_HOTKEY-Nachricht generiert, eine Nachricht, die das System oben in der Nachrichtenwarteschlange eines Threads platziert, wobei alle vorhandenen Nachrichten in der Warteschlange umgangen werden. Anwendungen verwenden Hot-Keys, um Tastatureingaben mit hoher Priorität vom Benutzer zu erhalten. Wenn Sie z. B. einen Hot-Key definieren, der aus der Tastenkombination STRG+C besteht, kann eine Anwendung es dem Benutzer ermöglichen, einen längeren Vorgang abzubrechen.

Um einen Hot-Key zu definieren, ruft eine Anwendung die RegisterHotKey-Funktion auf und gibt die Tastenkombination an, die die WM_HOTKEY-Nachricht generiert, das Handle für das Fenster zum Empfangen der Nachricht und den Bezeichner des Hot-Keys. Wenn der Benutzer die Tastenkombination drückt, wird eine WM_HOTKEY-Nachricht in der Nachrichtenwarteschlange des Threads platziert, der das Fenster erstellt hat. Der Parameter wParam der Nachricht enthält den Bezeichner des Hot-Keys. Die Anwendung kann mehrere Hot-Keys für einen Thread definieren, aber jeder Hot-Key im Thread muss über einen eindeutigen Bezeichner verfügen. Bevor die Anwendung beendet wird, sollte sie die UnregisterHotKey-Funktion verwenden, um den Hot-Key zu zerstören.

Anwendungen können eine Hot-Key-Steuerung verwenden, um dem Benutzer die Auswahl einer Tastenkombination zu erleichtern. Hot-Key-Steuerelemente werden in der Regel verwendet, um einen Hot-Key zu definieren, mit dem ein Fenster aktiviert wird. Sie verwenden nicht die Funktionen RegisterHotKey und UnregisterHotKey. Stattdessen sendet eine Anwendung, die ein Hot-Key-Steuerelement verwendet, in der Regel die WM_SETHOTKEY-Nachricht, um den Hot-Key festzulegen. Wenn der Benutzer die Tastenkombination drückt, sendet das System eine WM_SYSCOMMAND-Nachricht, in der SC_HOTKEY angegeben wird. Weitere Informationen zu Hot Key-Steuerelementen finden Sie unter „Verwenden von Hot-Key-Steuerelementen“ in Hot-Key-Steuerelemente.

Tastaturtasten zum Browsen und für andere Funktionen

Windows bietet Support für Tastaturen mit zusätzlichen Tasten für Browserfunktionen, Medienfunktionen, Anwendungsstarts und zur Energieverwaltung. Der WM_APPCOMMAND-Befehl unterstützt die zusätzlichen Tastaturtasten. Darüber hinaus wurde die ShellProc-Funktion geändert, um die zusätzlichen Tastaturtasten zu unterstützen.

Es ist unwahrscheinlich, dass ein untergeordnetes Fenster in einer Komponentenanwendung Befehle für diese zusätzlichen Tastaturtasten direkt implementieren kann. Wenn also eine dieser Tasten gedrückt wird, sendet DefWindowProc eine WM_APPCOMMAND-Nachricht an ein Fenster. DefWindowProc sendet die Nachricht WM_APPCOMMAND auch an das übergeordnete Fenster. Dies ähnelt der Art und Weise, wie Kontextmenüs mit der rechten Maustaste aufgerufen werden, d. h. DefWindowProc sendet eine WM_CONTEXTMENU-Nachricht bei einem Klick mit der rechten Maustaste und sendet sie an das übergeordnete Element. Wenn DefWindowProc eine WM_APPCOMMAND-Nachricht für ein Fenster der obersten Ebene empfängt, wird außerdem ein Shell-Hook mit dem Code HSHELL_APPCOMMAND aufgerufen.

Windows unterstützt auch den Microsoft IntelliMouse Explorer, bei dem es sich um eine Maus mit fünf Tasten handelt. Die beiden zusätzlichen Tasten unterstützen die Vorwärts- und Rückwärtsnavigation im Browser. Weitere Informationen finden Sie unter XBUTTONs.

Simulieren der Eingabe

Mit der SendInput-Funktion können Sie eine ununterbrochene Reihe von Benutzereingabeereignissen simulieren. Die Funktion besteht aus drei Parametern. Der erste Parameter cInputs gibt die Anzahl der Eingabeereignisse an, die simuliert werden. Der zweite Parameter, rgInputs, ist ein Array von INPUT-Strukturen, die jeweils Eingabeereignisse und zusätzliche Informationen eines Typs zu diesem Ereignis beschreiben. Der letzte Parameter, cbSize, übernimmt die Größe der INPUT-Struktur in Bytes.

Die SendInput-funktion fügt eine Reihe simulierter Eingabeereignisse in den Eingabedatenstrom eines Geräts ein. Der Effekt ähnelt dem wiederholten Aufrufen der keybd_event- oder der mouse_event-Funktion, bis auf dass das System sicherstellt, dass sich keine anderen Eingabeereignisse mit den simulierten Ereignissen mischen. Nach Abschluss des Aufrufs gibt der Rückgabewert die Anzahl der erfolgreich wiedergegebenen Eingabeereignisse an. Wenn dieser Wert Null ist, wurde die Eingabe blockiert.

Mit der SendInput-Funktion wird der aktuelle Zustand der Tastatur nicht zurückgesetzt. Daher können die Tasten die Ereignisse beeinträchtigen, die von dieser Funktion generiert werden, wenn der Benutzer beim Aufrufen dieser Funktion Tasten gedrückt hat. Wenn Sie über mögliche Störungen besorgt sind, überprüfen Sie den Zustand der Tastatur mit der GetAsyncKeyStateFunktion, und korrigieren Sie ihn bei Bedarf.

Sprachen, Gebietsschemas und Tastaturlayouts

Eine Sprache ist eine natürliche Sprache, z. B. Englisch, Französisch und Japanisch. Eine Untersprache ist eine Variante einer natürlichen Sprache, die in einer bestimmten geografischen Region gesprochen wird, z. B. die im Vereinigten Königreich und in den USA gesprochenen englischen Untervarianten. Anwendungen verwenden Werte, die Sprachbezeichner genannt werden, um Sprachen und Untersprachen eindeutig zu identifizieren.

Anwendungen verwenden in der Regel Gebietsschemas, um die Sprache festzulegen, in der Eingaben und Ausgaben verarbeitet werden. Das Festlegen des Gebietsschemas für die Tastatur wirkt sich beispielsweise auf die von der Tastatur generierten Zeichenwerte aus. Das Festlegen des Gebietsschemas für die Anzeige oder den Drucker wirkt sich auf die angezeigten oder gedruckten Symbole aus. In Anwendungen wird das Gebietsschema für eine Tastatur festgelegt, indem Tastaturlayouts geladen und verwendet werden. Sie legen das Gebietsschema für eine Anzeige oder einen Drucker fest, indem sie eine Schriftart auswählen, die das angegebene Gebietsschema unterstützt.

Ein Tastaturlayout gibt nicht nur die physische Position der Tasten auf der Tastatur an, sondern bestimmt auch die Zeichenwerte, die durch Drücken dieser Tasten generiert werden. Jedes Layout identifiziert die aktuelle Eingabesprache und bestimmt, welche Zeichenwerte von welchen Tasten und Tastenkombinationen generiert werden.

Jedes Tastaturlayout verfügt über einen entsprechenden Handle, der das Layout und die Sprache identifiziert. Das niederwertige Wort des Handles ist ein Sprachbezeichner. Das hochwertige Wort ist ein Gerätehandle, das das physische Layout angibt; wenn es Null ist, gibt dies ein physisches Standardlayout an. Der Benutzer kann eine beliebige Eingabesprache einem physischen Layout zuordnen. Beispielsweise kann ein englischsprachiger Benutzer, der sehr gelegentlich auf Französisch arbeitet, die Eingabesprache der Tastatur auf Französisch festlegen, ohne das physische Layout der Tastatur zu ändern. Dies bedeutet, dass der Benutzer Text in Französisch mit dem vertrauten englischen Layout eingeben kann.

Von Anwendungen wird im Allgemeinen nicht erwartet, dass sie Eingabesprachen direkt bearbeiten. Stattdessen richtet der Benutzer Sprach- und Layoutkombinationen ein und wechselt dann zwischen ihnen. Wenn der Benutzer in Text klickt, der mit einer anderen Sprache markiert ist, ruft die Anwendung die ActivateKeyboardLayout-Funktion auf, um das Standardlayout des Benutzers für diese Sprache zu aktivieren. Wenn der Benutzer Text in einer Sprache bearbeitet, die nicht in der aktiven Liste enthalten ist, kann die Anwendung die LoadKeyboardLayout-Funktion mit der Sprache aufrufen, um ein Layout basierend auf dieser Sprache zu erhalten.

Mit der ActivateKeyboardLayout-Funktion wird die Eingabesprache für die aktuelle Aufgabe festgelegt. Der hkl- Parameter kann entweder das Handle für das Tastaturlayout oder ein mit Null erweiterter Sprachbezeichner sein. Tastaturlayouthandles können über die Funktion LoadKeyboardLayout oder GetKeyboardLayoutList abgerufen werden. Mit den Werten HKL_NEXT und HKL_PREV kann ebenfalls die nächste oder vorherige Tastatur ausgewählt werden.

Mit der GetKeyboardLayoutName-Funktion wird der Name des aktiven Tastaturlayouts für den aufrufenden Thread abgerufen. Wenn eine Anwendung das aktive Layout mithilfe der LoadKeyboardLayout-Funktion erstellt, ruft GetKeyboardLayoutName dieselbe Zeichenfolge ab, die zum Erstellen des Layouts verwendet wurde. Andernfalls ist die Zeichenfolge der primäre Sprachbezeichner, der dem Gebietsschema des aktiven Layouts entspricht. Das bedeutet, dass die Funktion möglicherweise nicht unbedingt zwischen verschiedenen Layouts mit derselben primären Sprache unterscheidet, sodass keine spezifischen Informationen zur Eingabesprache zurückgegeben werden können. Mit der GetKeyboardLayout-Funktion kann jedoch die Eingabesprache bestimmt werden.

Mit der LoadKeyboardLayout-Funktion wird ein Tastaturlayout geladen und das Layout für den Benutzer zur Verfügung gestellt. Anwendungen können das Layout mithilfe des Wertes KLF_ACTIVATE sofort für den aktuellen Thread aktivieren. Eine Anwendung kann die Layouts mit dem Wert KLF_REORDER neu anordnen, ohne dass auch der KLF_ACTIVATE-Wert angegeben wird. Anwendungen sollten beim Laden von Tastaturlayouts immer den Wert KLF_SUBSTITUTE_OK verwenden, um sicherzustellen, dass die Einstellung des Benutzers ggf. ausgewählt ist.

Für mehrsprachigen Support stellt die LoadKeyboardLayout-Funktion die Flags KLF_REPLACELANG und KLF_NOTELLSHELL bereit. Das Flag KLF_REPLACELANG weist die Funktion an, ein vorhandenes Tastaturlayout zu ersetzen, ohne die Sprache zu ändern. Der Versuch, ein vorhandenes Layout mit demselben Sprachbezeichner zu ersetzen, ohne jedoch KLF_REPLACELANG anzugeben, ist ein Fehler. Das Flag KLF_NOTELLSHELL verhindert, dass die Funktion die Shell benachrichtigt, wenn ein Tastaturlayout hinzugefügt oder ersetzt wird. Dies ist nützlich bei Anwendungen, die mehrere Layouts in einer aufeinanderfolgenden Reihe von Aufrufen hinzufügen. Dieses Flag sollte bei allen Aufrufen außer dem letzten verwendet werden.

Die UnloadKeyboardLayout-Funktion ist eingeschränkt, da sie die Systemstandardeingabesprache nicht entladen kann. Dadurch wird sichergestellt, dass der Benutzer immer über ein Layout für die Eingabe von Text mit demselben Zeichensatz verfügt, der von der Shell und dem Dateisystem verwendet wird.