InputHook() [v1.1.31+]

Erstellt ein Objekt, das zum Erfassen oder Abfangen von Tastatureingaben genutzt werden kann.

InputHook := InputHook(Optionen, EndTasten, VergleichListe)

Parameter

Optionen

Eine Zeichenkette mit null oder mehreren der folgenden Buchstaben (in beliebiger Reihenfolge, optional mit Leerzeichen getrennt):

B: Setzt BackspaceIsUndo auf False, um zu bewirken, dass Backspace ignoriert wird.

C: Setzt CaseSensitive auf True, um VergleichListe Groß-Kleinschreibung-sensitiv zu machen.

I: Setzt MinSendLevel auf 1 oder den angegebenen Wert, um Eingaben zu ignorieren, deren Sendestufe kleiner als dieser Wert ist. I2 beispielsweise würde Eingaben mit einer Stufe von 0 (Standardwert) oder 1 ignorieren, aber Eingaben der Stufe 2 erfassen.

L: Längenbegrenzung (z. B. L5). Die maximal erlaubte Länge der Eingabe. Wenn der Text diese Länge erreicht, wird die Eingabeerfassung beendet und EndReason auf das Wort Max gesetzt (es sei denn, der Text stimmt mit einem der Elemente in der VergleichListe überein, dann wird EndReason auf das Wort Match gesetzt). Wenn diese Option nicht verwendet wird, ist die Länge auf 1023 Zeichen begrenzt.

Die Angabe von L0 deaktiviert die Texterfassung und Längenlimitierung, hat aber keinen Einfluss darauf, welche Tasten tatsächlich Text erzeugen (siehe VisibleText). Dies kann in Zusammenhang mit OnChar, OnKeyDown, KeyOpt oder EndTasten nützlich sein.

M: Modifizierte Tastendrücke wie Strg+A bis Strg+Z werden erkannt und in echte ASCII-Zeichen umgewandelt, falls möglich. Das folgende Beispiel zeigt, wie Strg+C erkannt werden kann:

StrgC := Chr(3) ; Speichert das Zeichen für STRG+C in die Variable StrgC.
ih := InputHook("L1 M")
ih.Start()
ih.Wait()
if (ih.Input = StrgC)
    MsgBox, Sie haben STRG+C gedrückt.

Hinweis: Strg+A bis Strg+Z sind die Zeichen von Chr(1) bis Chr(26). Außerdem ist es möglich, dass die M-Option einige Tastaturkurzbefehle wie Strg+← dazu bringen kann, sich während einer Eingabeerfassung falsch zu verhalten.

T: Setzt Timeout (z. B. T3 oder T2.5).

V: Setzt VisibleText und VisibleNonText auf True. Normalerweise wird die Eingabe des Benutzers blockiert (unsichtbar für das Betriebssystem gemacht). Nutzen Sie diese Option, damit die Tastendrücke des Benutzers direkt an das aktive Fenster gesendet werden.

*: Platzhalter. Setzt FindAnywhere auf True, damit überall Übereinstimmungen innerhalb dessen, was der Benutzer eingibt, gefunden werden können.

E: Behandelt Einzelzeichen-Endungstasten als Zeichencode anstatt als Tastencode. Diese Änderung ermöglicht konsistentere Ergebnisse, wenn das Tastaturlayout des aktiven Fensters sich vom Tastaturlayout des Skripts unterscheidet. Es verhindert auch Tastenkombinationen, die die angegebenen Endungszeichen bei der Eingabe eigentlich nicht erzeugen können; wenn @ beispielsweise eine Endungstaste wäre, würde sie auf einem US-Layout via Umschalt+2 ausgelöst werden, aber nicht via Strg+Umschalt+2 (wenn die E-Option verwendet wird). Wenn zusätzlich noch die C-Option angegeben ist, ist das Endungszeichen Groß-/Kleinschreibung-sensitiv.

EndTasten

Eine optionale Liste mit ein oder mehr Tasten, die, wenn gedrückt, die Eingabeerfassung beenden können (die Endtaste selbst wird nicht in den Eingabepuffer geschrieben). Wenn eine Eingabeerfassung auf diese Weise beendet wird, wird EndReason auf das Wort EndKey und die EndKey-Eigenschaft auf den Namen der Taste gesetzt.

Die EndTasten-Liste verwendet ein Format, das Ähnlichkeit zum verwendeten Format des Send-Befehls hat. Zum Beispiel würde {Enter}.{Esc} bewirken, dass Enter, . oder Esc die Eingabeerfassung beenden können. Um die geschweiften Klammern als Endtasten zu definieren, geben Sie {{} und/oder {}} an.

Um Strg, Alt oder Umschalt als Endtasten zu definieren, geben Sie die linke und/oder rechte Version der Taste an, nicht die neutrale Version. Zum Beispiel müsste {LControl}{RControl} anstelle von {Control} angegeben werden.

Obwohl modifizierte Tasten wie Alt+C (!c) nicht unterstützt werden, setzen nicht-alphanumerische Zeichen wie ?!:@&{} standardmäßig voraus, dass UMSCHALT gedrückt oder nicht gedrückt sein muss, je nachdem, wie das Zeichen normalerweise eingegeben wird. Wenn die E-Option vorhanden ist, werden die Namen von Einzelzeichentasten stattdessen als Zeichen interpretiert - in solchen Fällen müssen die Modifikatortasten im richtigen Zustand sein, um dieses Zeichen zu erzeugen. Wenn sowohl die E- als auch M-Option vorhanden sind, werden Tastenkombinationen von Strg+A bis Strg+Z unterstützt, indem man die entsprechenden ASCII-Steuerzeichen in EndTasten einfügt.

Ein eindeutiger Tastencode wie {vkFF} oder {sc001} kann auch angegeben werden. Diese Angabe ist in Ausnahmefällen nützlich, wo eine Taste keinen Namen hat und keine sichtbaren Zeichen beim Drücken erzeugt. Der virtuelle Tastencode einer solchen Taste kann durch Befolgen der Schritte am unteren Ende der Tastenliste ermittelt werden.

VergleichListe

Eine kommagetrennte Liste mit Stichwörtern, die die Eingabeerfassung beenden können (in diesem Fall wird EndReason auf das Wort Match gesetzt). Alles, was der Benutzer eingibt, muss exakt mit einem Element aus der Liste übereinstimmen, um eine Übereinstimmung zu bewirken (sofern die *-Option nicht vorhanden ist). Alle Leer- und Tabulatorzeichen an den angrenzenden Kommas sind von Bedeutung - das heißt, dass sie ein Teil der Übereinstimmungszeichenkette sind. Wenn VergleichListe beispielsweise ABC , XYZ wäre, kann eine Übereinstimmung nur erfolgen, wenn der Benutzer ein Leerzeichen nach ABC oder vor XYZ eingibt.

Zwei aufeinanderfolgende Kommas ergeben ein direkt geschriebenes Komma. Zum Beispiel würde die folgende Zeile ein direkt geschriebenes Komma nach dem Wort Zkette1 erzeugen: Zkette1,,,Zkette2. Im Vergleich dazu würde die folgende Liste nur ein einzelnes Element mit einem direkt geschriebenen Komma dazwischen enthalten: einzelnes,,Element.

Da die Elemente in VergleichListe nicht als einzelne Parameter behandelt werden, kann die Liste komplett in einer Variable enthalten sein. Diese Methode ist sowieso notwendig, wenn die Liste eine Länge von 16383 Zeichen überschreitet (die maximale Länge einer Skriptzeile). Zum Beispiel könnte VergleichListe aus %Liste1%,%Liste2%,%Liste3% bestehen, von der jede Unterliste eine lange Liste mit Elementen enthält.

Input-Stapel

Es können beliebig viele InputHook-Objekte erstellt werden und zur selben Zeit aktiv sein, allerdings hat die Reihenfolge, in der sie gestartet werden, Einfluss darauf, wie die Eingaben erfasst werden.

Wenn eine Eingabeerfassung gestartet wird (via Start-Methode oder Input-Befehl), wird sie ganz oben auf den Stapel geschoben, und aus diesem Stapel entfernt, wenn die Eingabeerfassung beendet wird. Die Reihenfolge, in der die Tastaturereignisse an eine Eingabeerfassung übergeben werden, geht vom neuesten zum ältesten. Wenn eine Eingabeerfassung ein bestimmtes Tastaturereignis unterdrückt, wird er nicht weiter im Stapel nach unten verschoben.

Gesendete Tastendrücke werden ignoriert, wenn die Sendestufe des Tastendrucks unterhalb des MinSendLevel von InputHook liegt. In solchen Fällen kann der Tastendruck immer noch von einer Eingabeerfassung verarbeitet werden, der niedriger auf dem Stapel liegt.

Es können mehrere InputHooks in Kombination mit MinSendLevel genutzt werden, um sowohl gesendete als auch reale Tastendrücke separat zu erfassen.

Der Aufruf des Input-Befehls beendet jede vorherige via Input-Befehl gestartete Eingabeerfassung, lässt aber alle InputHooks aktiv. Wenn die Eingabeerfassung nicht sichtbar ist, werden alle InputHooks, die davon unterbrochen werden, grundsätzlich keine Eingaben erfassen, bis der Input-Befehl fertig ist.

InputHook-Objekt

Die InputHook-Funktion gibt ein InputHook-Objekt zurück, das die folgenden Methoden und Eigenschaften hat.

• Methoden:
  • KeyOpt: Setzt Optionen für eine Taste oder Tastenliste.
  • Start: Beginnt die Eingabeerfassung.
  • Stop: Beendet die Eingabeerfassung und setzt EndReason auf das Wort Stopped.
  • Wait: Wartet, bis die Eingabeerfassung beendet wird (InProgress ist False).
• Allgemeine Eigenschaften:
  • EndKey: Gibt den Namen der Endtaste zurück, die zum Beenden der Eingabeerfassung gedrückt wurde.
  • EndMods: Gibt eine Zeichenkette mit Modifikatoren zurück, die logisch unten waren, während die Eingabeerfassung beendet wurde.
  • EndReason: Gibt eine EndReason-Zeichenkette zurück, die angibt, wie die Eingabeerfassung beendet wurde.
  • InProgress: Gibt True zurück, wenn die Eingabeerfassung im Gange ist, ansonsten False.
  • Input: Gibt den erfassten Text seit dem letzten Start der Eingabeerfassung zurück.
  • Match: Gibt das Element der VergleichListe zurück, mit der die Eingabeerfassung beendet wurde.
  • OnEnd: Ermittelt oder setzt das Funktionsobjekt, das aufgerufen wird, wenn die Eingabeerfassung beendet wird.
  • OnChar: Ermittelt oder setzt das Funktionsobjekt, das aufgerufen wird, nachdem ein Zeichen zum Eingabepuffer hinzugefügt wurde.
  • OnKeyDown: Ermittelt oder setzt das Funktionsobjekt, das aufgerufen wird, wenn eine benachrichtigungsfähige Taste gedrückt wird.
  • OnKeyUp: Ermittelt oder setzt das Funktionsobjekt, das aufgerufen wird, wenn eine benachrichtigungsfähige Taste losgelassen wird.
• Optionseigenschaften:
  • BackspaceIsUndo: Legt fest, ob Backspace das zuletzt gedrückte Zeichen am Ende des Eingabepuffers entfernen soll.
  • CaseSensitive: Legt fest, ob VergleichListe Groß-/Kleinschreibung-sensitiv sein soll.
  • FindAnywhere: Legt fest, ob alle Übereinstimmungen ein Teil des Eingabetexts sein sollen.
  • MinSendLevel: Ermittelt oder setzt die minimale Sendestufe der zu erfassenden Eingabe.
  • NotifyNonText: Legt fest, ob die Callbacks OnKeyDown und OnKeyUp jedes Mal aufgerufen werden sollen, wenn eine Nicht-Text-Taste gedrückt wird.
  • Timeout: Ermittelt oder setzt den Timeout-Wert in Sekunden.
  • VisibleNonText: Legt fest, ob Tasten oder Tastenkombinationen, die keinen Text erzeugen, sichtbar sein (blockiert werden) sollen.
  • VisibleText: Legt fest, ob Tasten oder Tastenkombinationen, die Text erzeugen, sichtbar sein (blockiert werden) sollen.

Methoden

InputHook.KeyOpt(Tasten, Tastenoptionen)

InputHook.Start()

InputHook.Stop()

InputHook.Wait(MaxZeit)

Allgemeine Eigenschaften

TasteName := InputHook.EndKey

Mods := InputHook.EndMods

<^>^<!>!<+>+<#>#

Mods := RegExReplace(Mods, "[<>](.)(?:>\1)?", "$1")

Grund := InputHook.EndReason

BoolescherWert := InputHook.InProgress

Zkette := InputHook.Input

Zkette := InputHook.Match

MeinFunk := InputHook.OnEnd

InputHook.OnEnd := MeinFunk

MeineFunk := InputHook.OnChar

InputHook.OnChar := MeineFunk

MeineFunk := InputHook.OnKeyDown

InputHook.OnKeyDown := MeineFunk

MeineFunk := InputHook.OnKeyUp

InputHook.OnKeyUp := MeineFunk

Optionseigenschaften

BoolescherWert := InputHook.BackspaceIsUndo

InputHook.BackspaceIsUndo := BoolescherWert

BoolescherWert := InputHook.CaseSensitive

InputHook.CaseSensitive := BoolescherWert

BoolescherWert := InputHook.FindAnywhere

InputHook.FindAnywhere := BoolescherWert

Stufe := InputHook.MinSendLevel

InputHook.MinSendLevel := Stufe

BoolescherWert := InputHook.NotifyNonText

InputHook.NotifyNonText := BoolescherWert

Sekunden := InputHook.Timeout

InputHook.Timeout := Sekunden

BoolescherWert := InputHook.VisibleNonText

InputHook.VisibleNonText := BoolescherWert

BoolescherWert := InputHook.VisibleText

InputHook.VisibleText := BoolescherWert

EndReason

Die EndReason-Eigenschaft gibt eine der folgenden Zeichenketten zurück:

Bemerkungen

Die Start-Methode kann nur aufgerufen werden, wenn die Eingabeerfassung nicht im Gange ist.

InputHook ist so konzipiert, dass verschiedene Teile des Skripts die Eingabe mit geringem Konfliktpotenzial überwachen können. Es kann kontinuierlich laufen, um z. B. auf willkürliche Wörter oder andere Muster zu reagieren. Es kann auch zeitweise genutzt werden, um z. B. Benutzereingaben zu erfassen oder vorübergehend bestimmte (oder unbestimmte) Tasten zu überschreiben, ohne Hotkeys zu beeinträchtigen.

Tastatur-Hotkeys bleiben wirksam, während eine Eingabeerfassung im Gange ist, aber sie können sich nicht aktivieren, wenn eine der erforderlichen Modifikatortasten unterdrückt ist oder wenn der Hotkey die reg-Methode verwendet und seine Suffix-Taste unterdrückt ist. Der Hotkey ^+a:: beispielsweise könnte von InputHook überschrieben werden, während der Hotkey $^+a:: Vorrang hätte, es sei denn, InputHook unterdrückt Strg oder Umschalt.

Tasten werden entweder unterdrückt (blockiert) oder nicht, abhängig von den folgenden Faktoren (in dieser Reihenfolge):

• Wenn die V-Option bei diesen VK oder SC wirksam ist, wird sie nicht unterdrückt.
• Wenn die S-Option bei diesen VK oder SC wirksam ist, wird sie unterdrückt.
• Wenn die Taste eine reguläre Modifikatortaste oder CapsLock, NumLock oder ScrollLock ist, wird sie nicht unterdrückt.
• VisibleText oder VisibleNonText wird herangezogen, je nachdem, ob die Taste Text erzeugt oder nicht. Wenn die Eigenschaft False ist, wird die Taste unterdrückt. Informationen darüber, welche Tasten als Texterzeuger eingestuft werden, finden Sie unter VisibleText.

Der Tastatur-Hook wird benötigt, während eine Eingabeerfassung im Gange ist, wird aber automatisch deinstalliert, wenn er nach Beendigung der Eingabeerfassung nicht mehr benötigt wird. Der Tastatur-Hook (sofern installiert) bewirkt, dass das Skript vorübergehend persistent wird; das heißt, dass das Skript nur noch mit ExitApp beendet werden kann.

AutoHotkey unterstützt keine Input Method Editors (IME). Der Tastatur-Hook fängt Tastaturereignisse ab und wandelt sie mithilfe von ToUnicodeEx oder ToAsciiEx in Text um (außer im Falle von VK_PACKET-Ereignissen, die ein einzelnes Zeichen beinhalten).

Wenn Sie mehrere Sprachen oder Tastaturlayouts verwenden, greift die Eingabeerfassung auf das Tastaturlayout des aktiven Fensters statt auf die des Skripts zurück (egal ob die Eingabeerfassung sichtbar ist oder nicht).

Trotz ihrer geringeren Flexibilität sind Hotstrings in der Regel einfacher zu bedienen.

InputHook vs. Input

InputHook und der Input-Befehl sind zwei verschiedene Schnittstellen, die im Grunde die gleiche Funktionalität bieten. Die folgenden zwei Beispiele sind funktionsgemäß nahezu identisch:

Input, AusgabeVar, %Optionen%, %EndTasten%, %VergleichListe%

ih := InputHook(Optionen, EndTasten, VergleichListe)
ih.Start()
ErrorLevel := ih.Wait()
if (ErrorLevel = "EndKey")
    ErrorLevel .= ":" ih.EndKey
AusgabeVar := ih.Input

Der Input-Befehl beendet jede vorher von ihm gestartete Eingabeerfassung, während InputHook mehrere Eingabeerfassungen gleichzeitig erlaubt.

Optionen wird gleichermaßen interpretiert, allerdings gibt es Unterschiede bei den Standardeinstellungen:

• Der Input-Befehl limitiert die Länge der Eingabe auf 16383, während InputHook diese auf 1023 limitiert. Dies kann mit der L-Option überschrieben werden (ohne absolutes Maximum).
• Der Input-Befehl blockiert standardmäßig sowohl Text- als auch Nicht-Text-Tastendrücke, und blockiert keine der beiden, wenn die V-Option vorhanden ist. InputHook dagegen blockiert standardmäßig nur Text-Tastendrücke (VisibleNonText ist standardmäßig True), dadurch können die meisten Hotkeys verwendet werden, während eine Eingabeerfassung im Gange ist.

Der Input-Befehl blockiert den Thread, während eine Eingabeerfassung im Gange ist, wohingegen InputHook dem Thread erlaubt, fortzufahren oder sogar beendet zu werden (wodurch jeder von ihm unterbrochene Thread fortgesetzt werden kann). Anstatt zu warten, kann das Skript eine OnEnd-Funktion registrieren, die aufgerufen wird, wenn die Eingabeerfassung beendet wird.

Der Input-Befehl gibt die Eingabe des Benutzers erst zurück, nachdem die Eingabeerfassung beendet wurde, während mit der Input-Eigenschaft von InputHook die aktuelle Eingabe des Benutzers jederzeit abgerufen werden kann. Anstatt ständig die Input-Eigenschaft zu prüfen, kann das Skript eine OnChar-Funktion registrieren, die jedes Mal aufgerufen wird, wenn ein Zeichen hinzugefügt wird.

InputHook ermöglicht deutlich mehr Kontrolle über einzelne Tasten via KeyOpt-Methode. Dazu gehört das Hinzufügen oder Entfernen von Endtasten, das Unterdrücken oder Nicht-Unterdrücken bestimmter Tasten oder das Ignorieren von Texterzeugnissen bestimmter Tasten.

Im Gegensatz zum Input-Befehl kann InputHook genutzt werden, um Tasten zu erkennen, die keinen Text erzeugen, ohne die Eingabeerfassung zu beenden. Hierzu wird eine OnKeyDown-Funktion registriert und KeyOpt oder NotifyNonText verwendet, um die zu betreffenden Tasten anzugeben.

Wenn eines der Elemente in VergleichListe die Eingabeerfassung beendet hat, kann die Match-Eigenschaft herangezogen werden, um genau zu bestimmen, welche Übereinstimmung eingetreten ist (vor allem dann, wenn die *-Option vorhanden ist).

Obwohl das Skript GetKeyState() nach einem Input-Befehl heranziehen kann, spiegelt es manchmal nicht genau wider, welche Tasten gedrückt wurden, nachdem die Eingabeerfassung beendet wurde. Die EndMods-Eigenschaft von InputHook spiegelt den logischen Zustand der Modifikatortasten zum Zeitpunkt der Beendigung der Eingabeerfassung wider.

Es gibt einige Unterschiede in Bezug auf die Abwärtskompatibilität:

• Der Input-Befehl speichert Endtasten A-Z in Großbuchstaben, obwohl andere Buchstaben auf einigen Tastaturlayouts kleingeschrieben sind. Übergibt man den Wert an Send, würde es ungewollt einen UMSCHALT-modifizierten Tastendruck erzeugen. Die EndKeys-Eigenschaft von InputHook gibt dagegen immer den normalisierten Namen zurück; also das Zeichen, das die Taste erzeugen würde, wenn kein Umschalt oder andere Modifikatoren gedrückt gehalten werden.

• Wenn ein Tastenname in EndTasten einem VK entspricht, der von zwei physischen Tasten verwendet wird (z. B. NumpadUp und Up), wird der Input-Befehl die primäre Taste via VK und die sekundäre Taste via SC behandeln, während InputHook beide via SC behandelt. Mit der Schreibweise {vkNN} kann die Taste via VK behandelt werden.

  Wenn die Endtaste via VK behandelt wird, können beide physikalischen Tasten die Eingabeerfassung beenden. {NumpadUp} beispielsweise würde bewirken, dass der Input-Befehl mit Up beendet werden kann, allerdings würde ErrorLevel EndKey:NumpadUp enthalten, da nur der VK berücksichtigt wird.

  Wenn eine Endtaste via SC behandelt wird, erzeugt der Input-Befehl immer Namen für den bekannten sekundären SC eines bestimmten VKs, und für alle anderen Tasten immer scNNN (selbst wenn sie einen Namen hat). InputHook dagegen erzeugt einen Namen, wenn die Taste einen hat.

Siehe auch

Input, KeyWait, Hotstrings, InputBox, #InstallKeybdHook, Threads, if Var in/contains VergleichListe

Beispiele

MsgBox % KeyWaitAny()

; Das Gleiche nochmal, aber ohne dass die Taste blockiert wird.
MsgBox % KeyWaitAny("V")

KeyWaitAny(Optionen:="")
{
    ih := InputHook(Optionen)
    if !InStr(Optionen, "V")
        ih.VisibleNonText := false
    ih.KeyOpt("{All}", "E")  ; End
    ih.Start()
    ErrorLevel := ih.Wait()  ; EndReason in ErrorLevel speichern
    return ih.EndKey  ; Tastenname zurückgeben
}

MsgBox % KeyWaitCombo()

KeyWaitCombo(Optionen:="")
{
    ih := InputHook(Optionen)
    if !InStr(Optionen, "V")
        ih.VisibleNonText := false
    ih.KeyOpt("{All}", "E")  ; End
    ; Modifikatoren ausschließen
    ih.KeyOpt("{LCtrl}{RCtrl}{LAlt}{RAlt}{LShift}{RShift}{LWin}{RWin}", "-E")
    ih.Start()
    ErrorLevel := ih.Wait()  ; EndReason in ErrorLevel speichern
    return ih.EndMods . ih.EndKey  ; Eine Zeichenkette wie <^<+Esc zurückgeben
}

global WörterListe := "Montag`nDienstag`nMittwoch`nDonnerstag`nFreitag`nSamstag`nSonntag"

global Suffix := "", SacHook

SacHook := InputHook("V", "{Esc}")
SacHook.OnChar := Func("SacChar")
SacHook.OnKeyDown := Func("SacKeyDown")
SacHook.OnEnd := Func("SacEnd")
SacHook.KeyOpt("{Backspace}", "N")
SacHook.Start()

SacChar(ih, char)  ; Wird aufgerufen, wenn ein Zeichen zu SacHook.Input hinzugefügt wird.
{
    Suffix := ""
    if RegExMatch(ih.Input, "`nm)\w+$", Präfix)
        RegExMatch(WörterListe, "`nmi)^" Präfix "\K.*", Suffix)
    
    ToolTip % Suffix, % A_CaretX + 15, % A_CaretY    
    
    ; Tab nur abfangen, während ein Tooltip angezeigt wird.
    ih.KeyOpt("{Tab}", Suffix = "" ? "-NS" : "+NS")
}

SacKeyDown(ih, vk, sc)
{
    if (vk = 8) ; Backspace
        SacChar(ih, "")
    else if (vk = 9) ; Tab
        Send % "{Text}" Suffix
}

SacEnd()
{
    ExitApp
}