neo-layout/windows/autohotkey/neo20.ahk

3526 lines
90 KiB
AutoHotkey
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
*******************************************
WICHTIGE WARNUNG:
Dies ist inzwischen eine automatisch generierte
Datei! Sie wird regelmäßig überschrieben und
sollte deshalb nicht mehr direkt bearbeitet werden!
Alle weiterführende Informationen finden sich im Abschnitt
== Hinweise für Entwickler ==
in der Datei README.txt!
*******************************************
*/
/*
*******************************************
Das war die letzte WARNUNG, ich hoffe nur dass
Sie wirklich wissen was Sie hier tun wollen ...
*******************************************
*/
/************************************
* NEO 2.0 (beta) AutoHotkey-Treiber *
*************************************
Autoren:
Stefan Mayer <stm (at) neo-layout. o r g>
Nora Geißler <nora_geissler (at) yahoo. d e>
Matthias Berg <neo (at) matthias-berg. e u>
Martin Roppelt <m.p.roppelt (at) web. d e>
Dennis Heidsiek <HeidsiekB (at) aol. c o m>
Matthias Wächter <matthias (at) waechter.wiz. a t>
...
*********
* TODO: *
*********
- Compose vollständig implementieren (Welche Methode ist hierzu am besten geeignet?)
- ausgiebig testen... (besonders Vollständigkeit bei Deadkeys)
- Bessere Lösung für das Leeren von PriorDeadKey finden, damit die Sondertasten nicht mehr abgefangen werden müssen.
- Testen, ob die Capslocklösung (siehe *1:: ebene 1) auch für Numpad gebraucht wird
- Die Ebenen vom Tastenblock an die neue Referenz anpassen (wenn da ein Konsens gefunden wurde)
**********
* IDEEN: *
**********
- Die Varianten (lernModus, einHandNeo, Lang-s-Tastatur, Qwertz/pausieren) sollten einheitlich (de-)aktiviert werden, etwa über M4+F9-F12
******************
* CHANGEHISTORY: *
******************
Revision 746 (von Martin Roppelt)
- Zurücksetzen der Tastatur über M4+Esc
- #(2L) sendet nicht mehr '
- Variablen Ebene7 und Ebene8 zum Abfragen eingeführt
- s(12)(2L)-Bug von Matthias Wächter behoben
Revision 744 (von Stefan Mayer)
- Ebene4-Ziffernblock: auf neo_d nun Komma (wie Referenz), "NumPadKomma" gibt es nicht
Revision 743 (von Matthias Wächter, commit durch Stefan Mayer)
- Ebene4-Ziffernblock: NumPadAdd und NumPadSub korrigiert
Revision 740 (von Matthias Wächter, commit durch HCW)
- "Mega-Patch" (Skript verkürzt, Ebenenabfrage verändert, ...), siehe CHANGES.txt
- Blinde tote Tasten auf M4+F9 (Toggle)
- Blinde Compose auf M4+F10 (Toggle)
Revision 728 (von Dennis Heidsiek):
- Ist die Datei %APPDATA%\NEO2\NEO2.ini vorhanden, werden dort eventuell vorhandene Werte für die Globalen Schalter beim Start übernommen
- »LangSTastaturStandardmäßigEingeschaltet.ahk« wird nicht mehr unterstützt, weil sonst immer neu kompiliert werden muss
Revision 707 (von Dennis Heidsiek):
- Die Resourcen-Dateien (PNGs, ICOs) werden nun nach "Von Windows vorgegebenes TEMP Verzeichnis"\NEO2\ extrahiert und nicht mehr in das Verzeichnis, in dem sich die EXE befindet
- Die doppelten französischen Anführungszeichen werden nun ebenfalls über SendUnicodeChar gesendet
Revision 694 (von Martin Roppelt):
- LangSTastatur auf M4+F11
- Entwickler können durch das Erstellen einer Datei »LangSTastaturStandardmäßigEingeschaltet.ahk« mit dem Inhalt »LangSTastatur := 1« diese standardmäßig aktivieren
- Mehrere DeadKeys aktualisiert (T*, Ebene 4 und T*, Ebene 5)
Revision 687 (von Dennis Heidsiek):
- Die SendUnicodeChar-Methode um den GDK-Workarround von Matthias Wächter ergänzt
- (An/Aus) Icons an Favicon der neuen Homepage angepasst
Revision 645 (von Martin Roppelt):
- Ellipse zusätzlich auf M3+x
- Lang-s-Tastatur probeweise auf M4+Esc
Revision 640 (von Dennis Heidsiek):
- Der untote Zirkumflex (^) auf Ebene 3 funktioniert jetzt auch in Java-Programmen
Revision 639 (von Martin Roppelt):
- Lang-s-Tastatur kann nicht mehr durch einen Hotkey aktiviert werden
Revision 629 (von Martin Roppelt):
- Spitze Klammern (bra und ket) auf M5+8/9
Revision 624 (von Martin Roppelt):
- Lang-s-Tastatur (ein- und auszuschalten durch Mod4+ß)
Revision 616 (von Dennis Heidsiek):
- Der nicht funktionierende Mod5-Lock-Fix wurde wieder entfernt, da er sogar neue Fehler produzierte
Revision 615 (von Dennis Heidsiek):
- Erfolgloser Versuch, den Mod4-Lock wiederherzustellen (durch eine Tilde vor den Scancodes der Bildschirmtastatur)
- Rechtschreibfehler korrigiert
- Zwei AHK-Links eingefügt
Revision 609 (von Dennis Heidsiek):
- Vorläufiger Abschluss der AHK-Modularisierung
- Bessere Testmöglichkeit »All.ahk« für AHK-Entwickler hinzugefügt, bei der sich die Zeilenangaben in Fehlermeldungen auf die tatsächlichen Module und nicht auf das große »vereinigte« Skript beziehen
Revision 608 (von Martin Roppelt):
- Rechtschreibfehler korrigiert und Dateinamen aktualisiert und sortiert
Revision 590 (von Dennis Heidsiek):
- Erste technische Vorarbeiten zur logischen Modularisierung des viel zu lange gewordenen AHK-Quellcodes
- Neue Batch-Datei Build-Update.bat zur einfachen Aktualisierung der EXE-Datei
Revision 583 (von Dennis Heidsiek):
- Kleinere Korrekturen (M3+NP5, M5+NP5 und M3+NP9 stimmen wieder mit der Referenz überein)
Revision 580 (von Matthias Berg):
- Bildschirmtastatur jetzt mit Mod4+F* statt Strg+F*, dies deaktiviert jedoch leider den Mod4-Lock
Revision 570 (von Matthias Berg):
- Hotkeys für einHandNeo und lernModus durch entsprechende ScanCodes ersetzt
Revision 568 (von Matthias Berg):
- Sonderzeichen, Umlaute, z und y durch ScanCodes ersetzt
* jetzt wird auch bei eingestelltem US Layout Neo verwendet (z.B. für Chinesische InputMethodEditors)
* rechter Mod3 geht noch nicht bei US-Layout (weder ScanCode noch "\")
Revision 567 (von Dennis Heidsiek):
- Aktivierter Mod4-Lock wird jetzt über die Rollen-LED des Keybord angezeigt (analog zu CapsLock), die Num-LED behält ihr bisheriges Verhalten
- Neue Option im Skript: UseMod4Light
Revision 561 (von Matthias Berg):
- M4+Tab verhält sich jetzt wie das andere Tab dank "goto neo_tab"
Revision 560 (von Dennis Heidsiek):
- Neue Option im Skript: bildschirmTastaturEinbinden bindet die PNG-Bilder der Bildschirmtastur mit in die exe-Datei ein, so dass sich der Benutzer nur eine Datei herunterladen muss
Revision 559 (von Matthias Berg):
- Shift+Alt+Tab Problem gelöst (muss noch mehr auf Nebeneffekte getestet werden)
Revision 558 (von Matthias Berg):
- Icon-Bug behoben
* Hotkeys dürfen nicht vor der folgenden Zeile stehen:
"menu, tray, icon, neo.ico,,1"
- lernModus-Konfigurations-Bug behoben: or statt and(not)
- Ein paar leere Else-Fälle eingebaut (Verständlichkeit, mögliche Compilerprobleme vermeiden)
Revision 556 (von Matthias Berg):
- lernModus (an/aus mit Strg+Komma)
* im Skript konfigurierbar
* Schaltet z.B. Qwertz Tasten aus, die es auf der 4. Ebene gibt (Return, Backspace,...)
* Kann auch Backspace und/oder Entfernen der 4. Ebene ausschalten (gut zum Lernen, richtig zu schreiben)
- Bug aufgetaucht: Icons werden nicht mehr angezeigt
Revision 544 (von Stefan Mayer):
- ,.:; auf dem Mod4-Ziffernblock an die aktuelle Referenz angepasst
- Versionen von rho, theta, kappa und phi an die aktuelle Referenz angepasst
Revision 542 (von Matthias Berg):
- bei EinHandNeo ist jetzt Space+y auch Mod4
- AltGr-Bug hoffentlich wieder behoben. Diesmal mit extra altGrPressed Variable
- nurEbenenFuenfUndSechs umbenannt in ahkTreiberKombi und auf Ebene 4 statt 5 und 6 geändert
Revision 540 (von Matthias Berg):
- stark überarbeitet um Wartbarkeit zu erhöhen und Redundanz zu verringern
- nurEbenenFuenfUndSechs sollte nun auch auf Neo Treiber statt Qwertz laufen
* aber es muss noch jemand testen
* Problem: was kann man abfangen, wenn eine tote Taste gedrückt wird
- einHandNeo:
* An-/Ausschalten mit Strg+Punkt
* Buchstaben der rechten Hand werden mit Space zur linken Hand
* Nebeneffekt: es gibt beim Festhalten von Space keine wiederholten Leerzeichen mehr
Revision 532 (von Matthias Berg):
- BildschirmTastatur
* aktiviert mit Strg+F1 bis 7, schaltet Keyboard ein oder aus
* Strg+F7 zeigt die zuletzt angezeigte Ebene an (und wieder aus)
* Strg+F8 schaltet AlwaysOnTop um
Revision 529 (von Stefan Mayer):
- Icon wird automatisch geladen, falls .ico-Dateien im selbem Ordner
- In der .exe sind die .ico mitgespeichert und werden geladen
Revision 528 (von Matthias Berg):
- Neo-Icon
- Neo-Prozess jetzt automatisch auf hoher Prioritaet
(siehe globale Schalter)
- Mod3-Lock (nur wenn rechtes Mod3 zuerst gedrückt wird, andere Lösung führte zum Caps-Bug)
- Mod4-Lock (nur wenn das linke Mod4 zuerst gedrückt wird, andere Lösung führte zum AltGr-Bug)
- Ein paar falsche Zeichen korrigiert
Revision 527 (von Matthias Berg):
- AltGr-Problem hoffentlich behoben
- Umschalt+Mod4-Bug behoben
Revision 526 (von Matthias Berg):
- Ebenen 1 bis 4 ausschalten per Umschalter siehe erste Codezeile nurEbenenFuenfUndSechs = 0
- Mod4-Lock durch Mod4+Mod4
- EbenenAktualisierung neu geschrieben
- Ebene 6 über Mod3+Mod4
- Ebenen (besonders Matheebene) an Referenz angepasst (allerdings kaum um Ebenen 1&2 gekümmert, besonders Compose könnte noch überholt werden)
Revision 525 (von Matthias Berg):
- Capslock bei Zahlen und Sonderzeichen berücksichtigt
Revision 524 (von Matthias Berg):
- umgekehrtes ^ für o, a, ü,i sowie für die grossen vokale ( 3. ton chinesisch)
• damit wird jetzt PinYin vollständig unterstützt caron, macron, akut, grave auf uiaeoü
- Sonderzeichen senden wieder blind -> Shortcuts funktionieren, Capslock ist leider Shiftlock
Revision 523 (von Matthias Berg):
- CapsLock geht jetzt auch bei allen Zeichen ('send Zeichen' statt 'send {blind} Zeichen')
- vertikale Ellipse eingebaut
- Umschalt+Umschalt für Capslock statt Mod3+Mod3
- bei Suspend wird jetzt wirklich togglesuspend aufgerufen (auch beim Aktivieren per shift+pause)
Revsion 490 (von Stefan Mayer):
- SUBSCRIPT von 0 bis 9 sowie (auf Ziffernblock) + und -
• auch bei Ziffernblock auf der 5. Ebene
- Kein Parsen über die Zwischenablage mehr
- Vista-kompatibel
- Compose-Taste
• Brüche (auf Zahlenreihe und Hardware-Ziffernblock)
• römische Zahlen
• Ligaturen und Copyright
*/
/****************
* Verzeichnisse *
*****************
*/
; Setzt den Pfad zu einem temporären Verzeichnis
EnvGet, WindowsEnvTempFolder, TEMP
ResourceFolder = %WindowsEnvTempFolder%\NEO2
FileCreateDir, %ResourceFolder%
; Setzt den Pfad zu den NEO-Anwendungsdateien
EnvGet, WindowsEnvAppDataFolder, APPDATA
ApplicationFolder = %WindowsEnvAppDataFolder%\NEO2
FileCreateDir, %ApplicationFolder%
/*******************
* Globale Schalter *
********************
*/
; Im folgenden gilt (soweit nicht anders angegeben) Ja = 1, Nein = 0:
; Syntaxhinweis: IniRead, Variable, InputFilename, Section, Key [, DefaultValue]
; Sollen die Bilder für die Bildschirmtastatur in die compilierte EXE-Datei miteingebunden werden? (Nachteil: grössere Dateigrösse, Vorteil: Referenz für Anfänger stets einfach verfügbar)
bildschirmTastaturEinbinden := 1
; Sollen Ebenen 1-4 ignoriert werden (kann z.B. vom dll Treiber übernommen werden)?
IniRead, ahkTreiberKombi, %ApplicationFolder%\NEO2.ini, Global, ahkTreiberKombi, 0
; Soll der Treiber im Einhandmodus betrieben werden?
IniRead, einHandNeo, %ApplicationFolder%\NEO2.ini, Global, einHandNeo, 0
; Soll der Lernmodus aktiviert werden?
IniRead, lernModus, %ApplicationFolder%\NEO2.ini, Global, lernModus, 0
; Soll aktivierter Mod4-Lock über die Rollen-LED des Keybord angezeigt werden (analog zu CapsLock)?
IniRead, UseMod4Light, %ApplicationFolder%\NEO2.ini, Global, UseMod4Light, 1
; Soll Lang-s auf s, s auf ß und ß auf Lang-s gelegt (bzw. vertauscht) werden?
IniRead, LangSTastatur, %ApplicationFolder%\NEO2.ini, Global, LangSTastatur, 0
; Sollen tote Tasten blind angezeigt werden?
IniRead, DeadCompose, %ApplicationFolder%\NEO2.ini, Global, DeadCompose, 0
;Sollen Compose-Tasten blind angezeigt werden?
IniRead, DeadSilence, %ApplicationFolder%\NEO2.ini, Global, DeadSilence, 0
/***********************
* Recourcen-Verwaltung *
************************
*/
if(FileExist("ResourceFolder") <> false) {
; Versuche, alle möglicherweise in die EXE eingebundenen Dateien zu extrahieren
FileInstall, neo.ico, %ResourceFolder%\neo.ico, 1
FileInstall, neo_disabled.ico, %ResourceFolder%\neo_disabled.ico, 1
iconBenutzen = 1
if (bildschirmTastaturEinbinden==1) {
FileInstall, ebene1.png, %ResourceFolder%\ebene1.png, 1
FileInstall, ebene2.png, %ResourceFolder%\ebene2.png, 1
FileInstall, ebene3.png, %ResourceFolder%\ebene3.png, 1
FileInstall, ebene4.png, %ResourceFolder%\ebene4.png, 1
FileInstall, ebene5.png, %ResourceFolder%\ebene5.png, 1
FileInstall, ebene6.png, %ResourceFolder%\ebene6.png, 1
zeigeBildschirmTastatur = 1
}
} else {
MsgBox, "Das Verzeichnis %ResourceFolder% konnte nicht angelegt werden!" ; Diese Zeile dient nur der eventuellen Fehlersuche und sollte eigentlich niemals auftauchen.
}
; Benutze die Dateien auch dann, wenn sie eventuell im aktuellen Verzeichnis vorhanden sind
if ( FileExist("ebene1.png") && FileExist("ebene2.png") && FileExist("ebene3.png") && FileExist("ebene4.png") && FileExist("ebene5.png") && FileExist("ebene6.png") )
zeigeBildschirmTastatur = 1
if ( FileExist("neo.ico") && FileExist("neo_disabled.ico") )
iconBenutzen = 1
/**************************
* lernModus Konfiguration *
* nur relevant wenn *
* lernModus = 1 *
* Strg+Komma schaltet um *
***************************
*/
; 0 = aus, 1 = an
; die Nachfolgenden sind nützlich um sich die Qwertz-Tasten abzugewöhnen, da alle auf der 4. Ebene vorhanden.
lernModus_std_Return = 0
lernModus_std_Backspace = 0
lernModus_std_PgUp = 0
lernModus_std_PgDn = 0
lernModus_std_Einf = 0
lernModus_std_Entf = 0
lernModus_std_Pos0 = 0
lernModus_std_Ende = 0
lernModus_std_Hoch = 0
lernModus_std_Runter = 0
lernModus_std_Links = 0
lernModus_std_Rechts = 0
lernModus_std_ZahlenReihe = 0
; im folgenden kann man auch noch ein paar Tasten der 4. Ebene deaktivieren
; nützlich um sich zu zwingen, richtig zu schreiben
lernModus_neo_Backspace = 0
lernModus_neo_Entf = 1
; aus Noras Skript kopiert:
Process,Priority,,High
#usehook on
#singleinstance force
#LTrim
; Quelltext kann eingerückt werden,
; msgbox ist trotzdem linksbündig
SetTitleMatchMode 2
SendMode Input
name = Neo 2.0
enable = Aktiviere %name%
disable = Deaktiviere %name%
; Überprüfung auf deutsches Tastaturlayout
; ----------------------------------------
regread, inputlocale, HKEY_CURRENT_USER, Keyboard Layout\Preload, 1
regread, inputlocalealias, HKEY_CURRENT_USER
, Keyboard Layout\Substitutes, %inputlocale%
if inputlocalealias <>
inputlocale = %inputlocalealias%
if inputlocale <> 00000407
{
suspend
regread, inputlocale, HKEY_LOCAL_MACHINE
, SYSTEM\CurrentControlSet\Control\Keyboard Layouts\%inputlocale%
, Layout Text
msgbox, 48, Warnung!,
(
Nicht kompatibles Tastaturlayout:
`t%inputlocale%
`nDas deutsche QWERTZ muss als Standardlayout eingestellt
sein, damit %name% wie erwartet funktioniert.
`nÄndern Sie die Tastatureinstellung unter
`tSystemsteuerung
`t-> Regions- und Sprachoptionen
`t-> Sprachen
`t-> Details... `n
)
exitapp
}
; Menü des Systray-Icons
; ----------------------
if (iconBenutzen)
menu, tray, icon, %ResourceFolder%\neo.ico,,1
menu, tray, nostandard
menu, tray, add, Öffnen, open
menu, helpmenu, add, About, about
menu, helpmenu, add, Autohotkey-Hilfe, help
menu, helpmenu, add
menu, helpmenu, add, http://&autohotkey.com/, autohotkey
menu, helpmenu, add, http://www.neo-layout.org/, neo
menu, tray, add, Hilfe, :helpmenu
menu, tray, add
menu, tray, add, %disable%, togglesuspend
menu, tray, default, %disable%
menu, tray, add
menu, tray, add, Edit, edit
menu, tray, add, Reload, reload
menu, tray, add
menu, tray, add, Nicht im Systray anzeigen, hide
menu, tray, add, %name% beenden, exitprogram
menu, tray, tip, %name%
/*
Variablen initialisieren
*/
DeadKey = ""
CompKey = ""
PriorDeadKey = ""
PriorCompKey = ""
Ebene12 = 0
EbeneAktualisieren()
/*
EinHandNeo
*/
spacepressed := 0
keypressed:= 0
; Reihe 1
gespiegelt_7 = neo_6
gespiegelt_8 = neo_5
gespiegelt_9 = neo_4
gespiegelt_0 = neo_3
gespiegelt_strich = neo_2
gespiegelt_tot2 = neo_1
; Reihe 2
gespiegelt_k = neo_w
gespiegelt_h = neo_c
gespiegelt_g = neo_l
gespiegelt_f = neo_v
gespiegelt_q = neo_x
gespiegelt_sz = neo_tab
gespiegelt_tot3 = neo_tot1
; Reihe 3
gespiegelt_s = neo_o
gespiegelt_n = neo_e
gespiegelt_r = neo_a
gespiegelt_t = neo_i
gespiegelt_d = neo_u
; Reihe 4
gespiegelt_b = neo_z
gespiegelt_m = neo_p
gespiegelt_komma = neo_ä
gespiegelt_punkt = neo_ö
gespiegelt_j = neo_ü
;Blinde/Sichtbare Tote Tasten
*F9::
if (isMod4pressed())
DeadSilence := not(DeadSilence)
else
send {blind}{F9}
return
;Blinde/Sichtbare Compose
*F10::
if (isMod4pressed())
DeadCompose := not(DeadCompose)
else
send {blind}{F10}
return
;Lang-s-Tastatur:
*F11::
if (isMod4pressed())
LangSTastatur := not(LangSTastatur) ; schaltet die Lang-s-Tastatur ein und aus
else
send {blind}{F11}
return
*Esc::
if (isMod4pressed())
reload
else
send {blind}{Esc}
return
/*
------------------------------------------------------
Modifier
------------------------------------------------------
*/
;LShift+RShift == CapsLock (simuliert)
; Es werden nur die beiden Tastenkombinationen abgefragt,
; daher kommen LShift und RShift ungehindert bis in die
; Applikation. Dies ist aber merkwürdig, da beide Shift-
; Tasten nun /modifier keys/ werden und, wie in der AHK-
; Hilfe beschrieben, eigentlich nicht mehr bis zur App
; durchkommen sollten.
VKA1SC136 & VKA0SC02A:: ; RShift, dann LShift
VKA0SC02A & VKA1SC136:: ; LShift, dann RShift
;
; mit diesen funktioniert das automatische Übernehmen der
; gedrückten Shift-Tasten nicht, also z.B. Shift-Ins, wenn Ins
; bei gedrückter Shift-Taste {blind} gesendet wird
; *VKA1SC136::
; *VKA0SC02A::
if (GetKeyState("VKA1SC136", "P") and GetKeyState("VKA0SC02A", "P"))
send {blind}{CapsLock}
return
; Mod3+Mod3 == Mod3-Lock
; Im Gegensatz zu LShift+RShift werden die beiden Tasten
; _nicht_ zur Applikation weitergeleitet, da '#' kein
; Modifier ist und CapsLock sonst den CapsLock-Status
; beeinflusst. Dafür werden sämtliche Events dieser
; Tasten abgefangen, und nur bei gleichzeitigem Drücken
; wird der Mod3-Lock aktiviert und angezeigt.
IsMod3Locked := 0
; VKBFSC02B & VK14SC03A::
; VK14SC03A & VKBFSC02B::
*VKBFSC02B:: ; #
*VK14SC03A:: ; CapsLock
if (GetKeyState("VKBFSC02B", "P") and GetKeyState("VK14SC03A", "P"))
{
if (IsMod3Locked)
{
IsMod3Locked = 0
MsgBox Mod3-Feststellung aufgebehoben
}
else
{
IsMod3Locked = 1
MsgBox Mod3 festgestellt: Um Mod3 wieder zu lösen drücke beide Mod3 Tasten gleichzeitig
}
}
return
; Mod4+Mod4 == Mod4-Lock
; Wie bei Mod3-Lock werden im Gegensatz zu LShift+RShift
; die beiden Tasten _nicht_ zur Applikation weitergeleitet,
; und nur bei gleichzeitigem Drücken wird der Mod4-Lock
; aktiviert und angezeigt.
IsMod4Locked := 0
; VKA5SC138 & VKE2SC056:: ; AltGr, dann <
; VKE2SC056 & VKA5SC138:: ; <, dann AltGr
*VKA5SC138::
*VKE2SC056::
if (GetKeyState("VKA5SC138", "P") and GetKeyState("VKE2SC056", "P"))
{
; Mod4-Lock durch Mod4(rechts)+Mod4(links)
if (IsMod4Locked)
{
MsgBox Mod4-Feststellung aufgebehoben
IsMod4Locked = 0
if (UseMod4Light==1)
{
KeyboardLED(1,"off")
}
}
else
{
MsgBox Mod4 festgestellt: Um Mod4 wieder zu lösen drücke beide Mod4 Tasten gleichzeitig
IsMod4Locked = 1
if (UseMod4Light==1)
{
KeyboardLED(1,"on")
}
}
}
return
/*
------------------------------------------------------
QWERTZ->Neo umwandlung
------------------------------------------------------
*/
; Reihe 1
*VKDCSC029::goto neo_tot1 ; Zirkumflex ^
*VK31SC002::goto neo_1
*VK32SC003::goto neo_2
*VK33SC004::goto neo_3
*VK34SC005::goto neo_4
*VK35SC006::goto neo_5
*VK36SC007::goto neo_6
*VK37SC008::
if( not(einHandNeo) or not(spacepressed) )
goto neo_7
else
{
keypressed := 1
goto %gespiegelt_7%
}
*VK38SC009::
if( not(einHandNeo) or not(spacepressed) )
goto neo_8
else
{
keypressed := 1
goto %gespiegelt_8%
}
*VK39SC00A::
if( not(einHandNeo) or not(spacepressed) )
goto neo_9
else
{
keypressed := 1
goto %gespiegelt_9%
}
*VK30SC00B::
if( not(einHandNeo) or not(spacepressed) )
goto neo_0
else
{
keypressed := 1
goto %gespiegelt_0%
}
*VKDBSC00C:: ; ß
if ( not(ahkTreiberKombi) )
{
if( not(einHandNeo) or not(spacepressed) )
goto neo_strich
else
{
keypressed := 1
goto %gespiegelt_strich%
}
}
else
{
goto neo_sz
}
*VKDDSC00D::goto neo_tot2 ; Akut
; Reihe 2
VK09SC00F::goto neo_tab
*VK51SC010:: ; q (x)
if ( not(ahkTreiberKombi) )
{
goto neo_x
}
else
{
goto neo_q
}
*VK57SC011:: ; w (v)
if ( not(ahkTreiberKombi) )
{
goto neo_v
}
else
{
goto neo_w
}
*VK45SC012:: ; e (l)
if ( not(ahkTreiberKombi) )
{
goto neo_l
}
else
{
goto neo_e
}
*VK52SC013:: ; r (c)
if ( not(ahkTreiberKombi) )
{
goto neo_c
}
else
{
goto neo_r
}
*VK54SC014:: ; t (w)
if ( not(ahkTreiberKombi) )
{
goto neo_w
}
else
{
goto neo_t
}
*VK5ASC015:: ; z (k)
if ( not(ahkTreiberKombi) )
{
if( not(einHandNeo) or not(spacepressed) )
goto neo_k
else
{
keypressed := 1
goto %gespiegelt_k%
}
}
else
{
goto neo_z
}
*VK55SC016:: ; u (h)
if ( not(ahkTreiberKombi) )
{
if( not(einHandNeo) or not(spacepressed) )
goto neo_h
else
{
keypressed := 1
goto %gespiegelt_h%
}
}
else
{
goto neo_u
}
*VK49SC017:: ; i (g)
if ( not(ahkTreiberKombi) )
{
if( not(einHandNeo) or not(spacepressed) )
goto neo_g
else
{
keypressed := 1
goto %gespiegelt_g%
}
}
else
{
goto neo_i
}
*VK4FSC018:: ; o (f)
if ( not(ahkTreiberKombi) )
{
if( not(einHandNeo) or not(spacepressed) )
goto neo_f
else
{
keypressed := 1
goto %gespiegelt_f%
}
}
else
{
goto neo_o
}
*VK50SC019:: ; p (q)
if ( not(ahkTreiberKombi) )
{
if( not(einHandNeo) or not(spacepressed) )
goto neo_q
else
{
keypressed := 1
goto %gespiegelt_q%
}
}
else
{
goto neo_p
}
*VKBASC01A:: ; ü (ß)
if ( not(ahkTreiberKombi) )
{
if( not(einHandNeo) or not(spacepressed) )
goto neo_sz
else
{
keypressed := 1
goto %gespiegelt_sz%
}
}
else
{
goto neo_ü
}
*VKBBSC01B:: ; + (tot3)
if ( not(ahkTreiberKombi) )
{
if( not(einHandNeo) or not(spacepressed) )
goto neo_tot3
else
{
keypressed := 1
goto %gespiegelt_tot3%
}
}
else
{ } ; this should never happen
; Reihe 3
*VK41SC01E:: ; a (u)
if ( not(ahkTreiberKombi) )
{
goto neo_u
}
else
{
goto neo_a
}
*VK53SC01F:: ; s (i)
if ( not(ahkTreiberKombi) )
{
goto neo_i
}
else
{
goto neo_s
}
*VK44SC020:: ; d (a)
if ( not(ahkTreiberKombi) )
{
goto neo_a
}
else
{
goto neo_d
}
*VK46SC021:: ; f (e)
if ( not(ahkTreiberKombi) )
{
goto neo_e
}
else
{
goto neo_f
}
*VK47SC022:: ; g (o)
if ( not(ahkTreiberKombi) )
{
goto neo_o
}
else
{
goto neo_g
}
*VK48SC023:: ; h (s)
if ( not(ahkTreiberKombi) )
{
if( not(einHandNeo) or not(spacepressed) )
goto neo_s
else
{
keypressed := 1
goto %gespiegelt_s%
}
}
else
{
goto neo_h
}
*VK4ASC024:: ; j (n)
if ( not(ahkTreiberKombi) )
{
if( not(einHandNeo) or not(spacepressed) )
goto neo_n
else
{
keypressed := 1
goto %gespiegelt_n%
}
}
else
{
goto neo_j
}
*VK4BSC025:: ; k (r)
if ( not(ahkTreiberKombi) )
{
if( not(einHandNeo) or not(spacepressed) )
goto neo_r
else
{
keypressed := 1
goto %gespiegelt_r%
}
}
else
{
goto neo_k
}
*VK4CSC026:: ; l (t)
if ( not(ahkTreiberKombi) )
{
if( not(einHandNeo) or not(spacepressed) )
goto neo_t
else
{
keypressed := 1
goto %gespiegelt_t%
}
}
else
{
goto neo_l
}
*VKC0SC027:: ; ö (d)
if ( not(ahkTreiberKombi) )
{
if( not(einHandNeo) or not(spacepressed) )
goto neo_d
else
{
keypressed := 1
goto %gespiegelt_d%
}
}
else
{
goto neo_ö
}
*VKDESC028:: ; ä (y)
if ( not(ahkTreiberKombi) )
{
goto neo_y
}
else
{
goto neo_ä
}
; Reihe 4
*VK59SC02C:: ; y (ü)
if ( not(ahkTreiberKombi) )
{
goto neo_ü
}
else
{
goto neo_y
}
*VK58SC02D:: ; x (ö)
if ( not(ahkTreiberKombi) )
{
goto neo_ö
}
else
{
goto neo_x
}
*VK43SC02E:: ; c (ä)
if ( not(ahkTreiberKombi) )
{
goto neo_ä
}
else
{
goto neo_c
}
*VK56SC02F:: ; v (p)
if ( not(ahkTreiberKombi) )
{
goto neo_p
}
else
{
goto neo_v
}
*VK42SC030:: ; b (z)
if ( not(ahkTreiberKombi) )
{
goto neo_z
}
else
{
goto neo_b
}
*VK4ESC031:: ; n (b)
if ( not(ahkTreiberKombi) )
{
if( not(einHandNeo) or not(spacepressed) )
goto neo_b
else
{
keypressed := 1
goto %gespiegelt_b%
}
}
else
{
goto neo_n
}
*VK4DSC032:: ; m (m)
if( not(einHandNeo) or not(spacepressed) )
goto neo_m
else
{
keypressed := 1
goto %gespiegelt_m%
}
*VKBCSC033:: ; , (,)
if( not(einHandNeo) or not(spacepressed) )
goto neo_komma
else
{
keypressed := 1
goto %gespiegelt_komma%
}
*VKBESC034:: ; . (.)
if( not(einHandNeo) or not(spacepressed) )
goto neo_punkt
else
{
keypressed := 1
goto %gespiegelt_punkt%
}
*VKBDSC035:: ; - (j)
if ( not(ahkTreiberKombi) )
{
if( not(einHandNeo) or not(spacepressed) )
goto neo_j
else
{
keypressed := 1
goto %gespiegelt_j%
}
}
else
{
goto neo_strich
}
; Numpad
*VK6FSC135::goto neo_NumpadDiv
*VK6ASC037::goto neo_NumpadMult
*VK6DSC04A::goto neo_NumpadSub
*VK6BSC04E::goto neo_NumpadAdd
*VK0DSC11C::goto neo_NumpadEnter
*VK67SC047:: ; NumPad7 (mit NumLock und ohne Shift)
*VK24SC047::goto neo_Numpad7 ; NumPadHome (ohne Numlock oder mit Shift)
*VK68SC048:: ; NumPad8 (mit NumLock und ohne Shift)
*VK26SC048::goto neo_Numpad8 ; NumPadUp (ohne Numlock oder mit Shift)
*VK69SC049:: ; NumPad9 (mit NumLock und ohne Shift)
*VK21SC049::goto neo_Numpad9 ; NumPadPgUp (ohne Numlock oder mit Shift)
*VK64SC04B:: ; NumPad4 (mit NumLock und ohne Shift)
*VK25SC04B::goto neo_Numpad4 ; NumPadLeft (ohne Numlock oder mit Shift)
*VK65SC04C:: ; NumPad5 (mit NumLock und ohne Shift)
*VK0CSC04C::goto neo_Numpad5 ; NumPadClear(ohne Numlock oder mit Shift)
*VK66SC04D:: ; NumPad6 (mit NumLock und ohne Shift)
*VK27SC04D::goto neo_Numpad6 ; NumPadRight(ohne Numlock oder mit Shift)
*VK61SC04F:: ; NumPad1 (mit NumLock und ohne Shift)
*VK23SC04F::goto neo_Numpad1 ; NumPadEnd (ohne Numlock oder mit Shift)
*VK62SC050:: ; NumPad2 (mit NumLock und ohne Shift)
*VK28SC050::goto neo_Numpad2 ; NumPadDown (ohne Numlock oder mit Shift)
*VK63SC051:: ; NumPad3 (mit NumLock und ohne Shift)
*VK22SC051::goto neo_Numpad3 ; NumPadPgDn (ohne Numlock oder mit Shift)
*VK60SC052:: ; NumPad0 (mit NumLock und ohne Shift)
*VK2DSC052::goto neo_Numpad0 ; NumPadIns (ohne Numlock oder mit Shift)
*VK6ESC053:: ; NumPadDot (mit NumLock und ohne Shift)
*VK2ESC053::goto neo_NumpadDot ; NumPadIns (ohne Numlock oder mit Shift)
/*
Die eigentliche NEO-Belegung und der Hauptteil des AHK-Treibers.
Ablauf bei toten Tasten:
1. Ebene Aktualisieren
2. Abhängig von der Variablen "Ebene" Zeichen ausgeben und die Variable "PriorDeadKey" setzen
Ablauf bei "untoten" Tasten:
1. Ebene Aktualisieren
2. Abhängig von den Variablen "Ebene" und "PriorDeadKey" Zeichen ausgeben
3. "PriorDeadKey" mit leerem String überschreiben
Reihe 1
*/
neo_tot1:
EbeneAktualisieren()
if (Ebene = 1)
{
deadUni(0x02C6) ; Zirkumflex, tot
DeadKey := "c1"
}
else if (Ebene = 2)
{
deadUni(0x02C7) ; Caron, tot
DeadKey := "c2"
}
else if (Ebene = 3)
{
deadUni(0x02D8) ; Brevis, tot
DeadKey := "c3"
}
else if (Ebene = 4)
{
deadUni(0x00B7) ; Mittenpunkt, tot
DeadKey := "c4"
}
else if (Ebene = 5)
{
deadAsc("-") ; Querstrich, tot
DeadKey := "c5"
}
else if (Ebene = 6)
{
deadAsc(".") ; Punkt drunter (Colon), tot
DeadKey := "c6"
}
CompKey := PriorCompKey
return
neo_1:
EbeneAktualisieren()
if (Ebene = 1)
{
if !(CheckDeadUni("c1",0x00B9)
or CheckDeadUni("c5",0x2081)
or CheckComp3Uni("r_1",0x217A) ; römisch xi
or CheckComp3Uni("R_1",0x216A)) ; römisch XI
if (GetKeyState("CapsLock","T"))
send {blind}{Shift down}1{Shift up}
else if (not(lernModus) or lernModus_std_ZahlenReihe)
send {blind}1
if (PriorDeadKey = "comp")
CompKey := "1"
else if (PriorCompKey == "r")
CompKey := "r_1"
else if (PriorCompKey == "R")
CompKey := "R_1"
}
else if (Ebene = 2)
send °
else if (Ebene = 3)
SendUnicodeChar(0x00B9) ; 2 Hochgestellte
else if (Ebene = 4)
SendUnicodeChar(0x2022) ; bullet
else if (Ebene = 5)
SendUnicodeChar(0x2640) ; Piktogramm weiblich
else if (Ebene = 6)
SendUnicodeChar(0x00AC) ; Nicht-Symbol
return
neo_2:
EbeneAktualisieren()
if (Ebene = 1)
{
if !(CheckDeadUni("c1",0x00B2)
or CheckDeadUni("c5",0x2082)
or CheckCompUni("r",0x2171) ; römisch ii
or CheckCompUni("R",0x2161) ; römisch II
or CheckComp3Uni("r_1",0x217B) ; römisch xii
or CheckComp3Uni("R_1",0x216B)) ; römisch XII
if (GetKeyState("CapsLock","T"))
send {blind}{Shift down}2{Shift up}
else if (not(lernModus) or lernModus_std_ZahlenReihe)
send {blind}2
if (PriorDeadKey = "comp")
CompKey := "2"
}
else if (Ebene = 2)
SendUnicodeChar(0x2116) ; numero
else if (Ebene = 3)
SendUnicodeChar(0x00B2) ; 2 Hochgestellte
else if (Ebene = 4)
SendUnicodeChar(0x2023) ; aufzaehlungspfeil
else if (Ebene = 5)
SendUnicodeChar(0x26A5) ; Piktogramm Zwitter
else if (Ebene = 6)
SendUnicodeChar(0x2228) ; Logisches Oder
return
neo_3:
EbeneAktualisieren()
if (Ebene = 1)
{
if !(CheckDeadUni("c1",0x00B3)
or CheckDeadUni("c5",0x2083)
or CheckCompUni("1",0x2153) ; 1/3
or CheckCompUni("2",0x2154) ; 2/3
or CheckCompUni("r",0x2172) ; römisch iii
or CheckCompUni("R",0x2162)) ; römisch III
if (GetKeyState("CapsLock","T"))
send {blind}{Shift down}3{Shift up}
else if (not(lernModus) or lernModus_std_ZahlenReihe)
send {blind}3
if (PriorDeadKey = "comp")
CompKey := "3"
}
else if (Ebene = 2)
send §
else if (Ebene = 3)
SendUnicodeChar(0x00B3) ; 3 Hochgestellte
else if (Ebene = 4)
{
CompKey := PriorCompKey
DeadKey := PriorDeadKey
} ; leer
else if (Ebene = 5)
SendUnicodeChar(0x2642) ; Piktogramm Mann
else if (Ebene = 6)
SendUnicodeChar(0x2227) ; Logisches Und
return
neo_4:
EbeneAktualisieren()
if (Ebene = 1)
{
if !(CheckDeadUni("c1",0x2074)
or CheckDeadUni("c5",0x2084)
or CheckCompUni("r",0x2173) ; römisch iv
or CheckCompUni("R",0x2163)) ; römisch IV
if (GetKeyState("CapsLock","T"))
send {blind}{Shift down}4{Shift up}
else if (not(lernModus) or lernModus_std_ZahlenReihe)
send {blind}4
if (PriorDeadKey = "comp")
CompKey := "4"
}
else if (Ebene = 2)
SendUnicodeChar(0x00BB) ; », Double guillemot right
else if (Ebene = 3)
Send {blind} ; Single guillemot right
else if (Ebene = 4)
Send {blind}{PgUp} ; Prev
else if (Ebene = 5)
SendUnicodeChar(0x2113) ; Script small L
else if (Ebene = 6)
SendUnicodeChar(0x22A5) ; Senkrecht
return
neo_5:
EbeneAktualisieren()
if (Ebene = 1)
{
if !(CheckDeadUni("c1",0x2075)
or CheckDeadUni("c5",0x2085)
or CheckCompUni("1",0x2155) ; 1/5
or CheckCompUni("2",0x2156) ; 2/5
or CheckCompUni("3",0x2157) ; 3/5
or CheckCompUni("4",0x2158) ; 4/5
or CheckCompUni("r",0x2174) ; römisch v
or CheckCompUni("R",0x2164)) ; römisch V
if (GetKeyState("CapsLock","T"))
send {blind}{Shift down}5{Shift up}
else if (not(lernModus) or lernModus_std_ZahlenReihe)
send {blind}5
if (PriorDeadKey = "comp")
CompKey := "5"
}
else if (Ebene = 2)
SendUnicodeChar(0x00AB) ; Double guillemot left
else if (Ebene = 3)
Send {blind} ; Single guillemot left
else if (Ebene = 4)
{
CompKey := PriorCompKey
DeadKey := PriorDeadKey
} ; leer
else if (Ebene = 5)
SendUnicodeChar(0x2020) ; Kreuz (Dagger)
else if (Ebene = 6)
SendUnicodeChar(0x2221) ; Winkel
return
neo_6:
EbeneAktualisieren()
if (Ebene = 1)
{
if !(CheckDeadUni("c1",0x2076)
or CheckDeadUni("c5",0x2086)
or CheckCompUni("1",0x2159) ; 1/6
or CheckCompUni("5",0x215A) ; 5/6
or CheckCompUni("r",0x2175) ; römisch vi
or CheckCompUni("R",0x2165)) ; römisch VI
if (GetKeyState("CapsLock","T"))
send {blind}{Shift down}6{Shift up}
else if (not(lernModus) or lernModus_std_ZahlenReihe)
send {blind}6
if (PriorDeadKey = "comp")
CompKey := "6"
}
else if (Ebene = 2)
send
else if (Ebene = 3)
send {blind}¢
else if (Ebene = 4)
send {blind}£
else if (Ebene = 5)
{
CompKey := PriorCompKey
DeadKey := PriorDeadKey
} ; leer
else if (Ebene = 6)
SendUnicodeChar(0x2225) ; parallel
return
neo_7:
EbeneAktualisieren()
if (Ebene = 1)
{
if !(CheckDeadUni("c1",0x2077)
or CheckDeadUni("c5",0x2087)
or CheckCompUni("r",0x2176) ; römisch vii
or CheckCompUni("R",0x2166)) ; römisch VII
if (GetKeyState("CapsLock","T"))
send {blind}{Shift down}7{Shift up}
else if (not(lernModus) or lernModus_std_ZahlenReihe)
send {blind}7
if (PriorDeadKey = "comp")
CompKey := "7"
}
else if (Ebene = 2)
send $
else if (Ebene = 3)
send {blind}¥
else if (Ebene = 4)
send {blind}¤
else if (Ebene = 5)
SendUnicodeChar(0x03BA) ; greek small letter kappa
else if (Ebene = 6)
SendUnicodeChar(0x2209) ; nicht Element von
return
neo_8:
EbeneAktualisieren()
if (Ebene = 1)
{
if !(CheckDeadUni("c1",0x2078)
or CheckDeadUni("c5",0x2088)
or CheckCompUni("1",0x215B) ; 1/8
or CheckCompUni("3",0x215C) ; 3/8
or CheckCompUni("5",0x215D) ; 5/8
or CheckCompUni("7",0x215E) ; 7/8
or CheckCompUni("r",0x2177) ; römisch viii
or CheckCompUni("R",0x2167)) ; römisch VIII
if (GetKeyState("CapsLock","T"))
send {blind}{Shift down}8{Shift up}
else if (not(lernModus) or lernModus_std_ZahlenReihe)
send {blind}8
if (PriorDeadKey = "comp")
CompKey := "8"
}
else if (Ebene = 2)
send
else if (Ebene = 3)
send {blind}
else if (Ebene = 4)
Send {blind}{NumpadDiv}
else if (Ebene = 5)
SendUnicodeChar(0x27E8) ;bra (öffnende spitze klammer)
else if (Ebene = 6)
SendUnicodeChar(0x2204) ; es existiert nicht
return
neo_9:
EbeneAktualisieren()
if (Ebene = 1)
{
if !(CheckDeadUni("c1",0x2079)
or CheckDeadUni("c5",0x2089)
or CheckCompUni("r",0x2178) ; römisch ix
or CheckCompUni("R",0x2168)) ; römisch IX
if (GetKeyState("CapsLock","T"))
send {blind}{Shift down}9{Shift up}
else if (not(lernModus) or lernModus_std_ZahlenReihe)
send {blind}9
if (PriorDeadKey = "comp")
CompKey := "9"
}
else if (Ebene = 2)
send
else if (Ebene = 3)
send {blind}
else if (Ebene = 4)
Send {blind}{NumpadMult}
else if (Ebene = 5)
SendUnicodeChar(0x27E9) ;ket (schließende spitze klammer)
else if (Ebene = 6)
SendUnicodeChar(0x2226) ; nicht parallel
return
neo_0:
EbeneAktualisieren()
if (Ebene = 1)
{
if !(CheckDeadUni("c1",0x2070)
or CheckDeadUni("c5",0x2080)
or CheckComp3Uni("r_1",0x2179) ; römisch x
or CheckComp3Uni("R_1",0x2169)) ; römisch X
if (GetKeyState("CapsLock","T"))
send {blind}{Shift down}0{Shift up}
else if (not(lernModus) or lernModus_std_ZahlenReihe)
send {blind}0
if (PriorDeadKey = "comp")
CompKey := "0"
}
else if (Ebene = 2)
send
else if (Ebene = 3)
send {blind}
else if (Ebene = 4)
Send {blind}{NumpadSub}
else if (Ebene = 5)
{
CompKey := PriorCompKey
DeadKey := PriorDeadKey
} ; leer
else if (Ebene = 6)
SendUnicodeChar(0x2205) ; leere Menge
return
neo_strich:
EbeneAktualisieren()
if (Ebene = 1)
if (GetKeyState("CapsLock","T"))
send {blind}{Shift down}-{Shift up}
else
send {blind}- ; Bindestrich-Minus
else if (Ebene = 2)
SendUnicodeChar(0x2013) ; Gedankenstrich
else if (Ebene = 3)
SendUnicodeChar(0x2014) ; Englischer Gedankenstrich (Geviertstrich)
else if (Ebene = 4)
{
CompKey := PriorCompKey
DeadKey := PriorDeadKey
} ; leer
else if (Ebene = 5)
SendUnicodeChar(0x2011) ; geschützter Bindestrich (Bindestrich ohne Zeilenumbruch)
else if (Ebene = 6)
SendUnicodeChar(0x00AD) ; weicher Bindestrich
return
neo_tot2:
EbeneAktualisieren()
if (Ebene = 1)
{
deadAsc("{´}{space}") ; Akut, tot
DeadKey := "a1"
}
else if (Ebene = 2)
{
deadAsc("``{space}") ; Gravis, tot
DeadKey := "a2"
}
else if (Ebene = 3)
{
deadAsc("¸") ; Cedilla, tot
DeadKey := "a3"
}
else if (Ebene = 4)
{
deadUni(0x02D9) ; Punkt obendrüber
DeadKey := "a4"
}
else if (Ebene = 5)
{
deadUni(0x02DB) ; Ogonek
DeadKey := "a5"
}
else if (Ebene = 6)
{
deadUni(0x02DA) ; Ring obendrauf
DeadKey := "a6"
}
CompKey := PriorCompKey
return
/*
Reihe 2
*/
neo_x:
EbeneAktualisieren()
if (Ebene12)
OutputChar("x","X")
else if (Ebene = 3)
SendUnicodeChar(0x2026) ;Ellipse
else if (Ebene = 5)
SendUnicodeChar(0x03BE) ;xi
else if (Ebene = 6)
SendUnicodeChar(0x039E) ; Xi
return
neo_v:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("c6",0x1E7F,0x1E7E)))
OutputChar("v","V")
else if (Ebene = 3)
send {blind}_
else if (Ebene = 4)
if (not(lernModus) or lernModus_neo_Backspace)
Send {blind}{Backspace}
else
{
CompKey := PriorCompKey
DeadKey := PriorDeadKey
} ; leer
else if (Ebene = 6)
SendUnicodeChar(0x2259) ; estimates
return
neo_l:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x013A,0x0139)
or CheckDeadUni12("a3",0x013C,0x013B)
or CheckDeadUni12("c2",0x013E,0x013D)
or CheckDeadUni12("c4",0x0140,0x013F)
or CheckDeadUni12("c6",0x1E37,0x1E36)
or CheckDeadUni12("t4",0x0142,0x0141)))
OutputChar("l","L")
else if (Ebene = 3)
send {blind}[
else if (Ebene = 4)
Send {Blind}{Up}
else if (Ebene = 5)
SendUnicodeChar(0x03BB) ; lambda
else if (Ebene = 6)
SendUnicodeChar(0x039B) ; Lambda
return
neo_c:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x0107,0x0106)
or CheckDeadUni12("a3",0x00E7,0x00E6)
or CheckDeadUni12("a4",0x010B,0x010A)
or CheckDeadUni12("c1",0x0109,0x0108)
or CheckDeadUni12("c2",0x010D,0x010C)
or CheckCompAsc12("o","©","©")
or CheckCompAsc12("O","©","©")))
OutputChar("c","C")
else if (Ebene = 3)
send {blind}]
else if (Ebene = 4)
if (not(lernModus) or lernModus_neo_Entf)
Send {blind}{Del}
else
{
CompKey := PriorCompKey
DeadKey := PriorDeadKey
} ; leer
else if (Ebene = 5)
SendUnicodeChar(0x03C7) ;chi
else if (Ebene = 6)
SendUnicodeChar(0x2102) ; C (Komplexe Zahlen)
return
neo_w:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("c1",0x0175,0x0174)))
OutputChar("w","W")
else if (Ebene = 3)
SendUnicodeChar(0x005E) ; untotes ^ - Unicode-Name: CIRCUMFLEX ACCENT
;send {^}{space} ; Funktioniert nicht unter Java-Programmen
else if (Ebene = 4)
Send {blind}{Insert}
else if (Ebene = 5)
SendUnicodeChar(0x03C9) ; omega
else if (Ebene = 6)
SendUnicodeChar(0x03A9) ; Omega
return
neo_k:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a3",0x0137,0x0136)
or CheckDeadUni12("c6",0x1E33,0x1E32)))
OutputChar("k","K")
else if (Ebene = 3)
send {blind}{!}
else if (Ebene = 4)
Send ¡
else if (Ebene = 5)
SendUnicodeChar(0x03F0) ;kappa symbol (varkappa)
else if (Ebene = 6)
SendUnicodeChar(0x221A) ; Wurzel
return
neo_h:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E23,0x1E22)
or CheckDeadUni12("c1",0x0125,0x0124)
or CheckDeadUni12("c5",0x0127,0x0126)
or CheckDeadUni12("c6",0x1E25,0x1E24)))
OutputChar("h","H")
else if ((Ebene = 3) and !(CheckDeadUni("c5",0x2264))) ; kleiner gleich
send {blind}<
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2077)
or CheckDeadUni("c5",0x2087)))
Send {blind}{NumPad7}
else if (Ebene = 5)
SendUnicodeChar(0x03C8) ;psi
else if (Ebene = 6)
SendUnicodeChar(0x03A8) ; Psi
return
neo_g:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a3",0x0123,0x0122)
or CheckDeadUni12("a4",0x0121,0x0120)
or CheckDeadUni12("c1",0x011D,0x011C)
or CheckDeadUni12("c3",0x011F,0x011E)))
OutputChar("g","G")
else if ((Ebene = 3) and !(CheckDeadUni("c5",0x2265))) ; größer gleich
send {blind}>
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2078)
or CheckDeadUni("c5",0x2088)))
Send {blind}{NumPad8}
else if (Ebene = 5)
SendUnicodeChar(0x03B3) ;gamma
else if (Ebene = 6)
SendUnicodeChar(0x0393) ; Gamma
return
neo_f:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E1F,0x1E1E)
or CheckDeadUni12("t4",0x0192,0x0191)))
OutputChar("f","F")
else if ((Ebene = 3) and !(CheckDeadUni("a6",0x2257) ; ring equal to
or CheckDeadUni("c1",0x2259) ; entspricht
or CheckDeadUni("c2",0x225A) ; EQUIANGULAR TO
or CheckDeadUni("c5",0x2261) ; identisch
or CheckDeadUni("t1",0x2245) ; ungefähr gleich
or CheckDeadUni("t4",0x2260))) ; ungleich
send {blind}`=
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2079)
or CheckDeadUni("c5",0x2089)))
Send {blind}{NumPad9}
else if (Ebene = 5)
SendUnicodeChar(0x03C6) ; phi
else if (Ebene = 6)
SendUnicodeChar(0x03A6) ; Phi
return
neo_q:
EbeneAktualisieren()
if (Ebene12)
OutputChar("q","Q")
else if (Ebene = 3)
send {blind}{&}
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x207A)
or CheckDeadUni("c5",0x208A)))
Send {blind}{NumPadAdd}
else if (Ebene = 5)
SendUnicodeChar(0x03D5) ; phi symbol (varphi)
else if (Ebene = 6)
SendUnicodeChar(0x211A) ; Q (rationale Zahlen)
return
neo_sz:
EbeneAktualisieren()
if (Ebene = 1)
if (GetKeyState("CapsLock","T"))
SendUnicodeChar(0x1E9E) ; versal-ß
else if (LangSTastatur = 1)
send {blind}s
else
send ß
else if (Ebene = 2)
if (GetKeyState("CapsLock","T"))
if (LangSTastatur = 1)
send {blind}s
else
send ß
else
SendUnicodeChar(0x1E9E) ; versal-ß
else if (Ebene = 3)
if (LangSTastatur = 1)
send ß
else
SendUnicodeChar(0x017F) ; langes s
else if (Ebene = 5)
SendUnicodeChar(0x03C2) ; varsigma
else if (Ebene = 6)
SendUnicodeChar(0x2218) ; Verknüpfungsoperator
return
neo_tot3:
EbeneAktualisieren()
if (Ebene = 1)
{
deadUni(0x02DC) ;Tilde, tot
DeadKey := "t1"
}
else if (Ebene = 2)
{
deadUni(0x00AF) ; Macron, tot
DeadKey := "t2"
}
else if (Ebene = 3)
{
deadUni(0x00A8) ; Diärese
DeadKey := "t3"
}
else if (Ebene = 4)
{
deadUni(0x002F) ; Schrägstrich, tot
DeadKey := "t4"
}
else if (Ebene = 5)
{
deadUni(0x02DD) ;Doppelakut
DeadKey := "t5"
}
else if (Ebene = 6)
{
deadUni(0x02CF) ; Komma drunter, tot
DeadKey := "t6"
}
return
/*
Reihe 3
*/
neo_u:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x00FA,0x00DA)
or CheckDeadUni12("a2",0x00F9,0x00D9)
or CheckDeadUni12("a5",0x0173,0x0172)
or CheckDeadUni12("a6",0x016F,0x016E)
or CheckDeadUni12("c1",0x00FB,0x00DB)
or CheckDeadUni12("c2",0x01D4,0x01D3)
or CheckDeadUni12("c3",0x016D,0x016C)
or CheckDeadUni12("t1",0x0169,0x0168)
or CheckDeadUni12("t2",0x016B,0x016A)
or CheckDeadAsc12("t3","ü","Ü")
or CheckDeadUni12("t5",0x0171,0x0170)))
OutputChar("u","U")
else if (Ebene = 3)
send {blind}\
else if (Ebene = 4)
Send {blind}{Home}
else if (Ebene = 5)
{
CompKey := PriorCompKey
DeadKey := PriorDeadKey
} ; leer
else if (Ebene = 6)
SendUnicodeChar(0x222E) ; contour integral
return
neo_i:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x00ED,0x00CD)
or CheckDeadUni12("a2",0x00EC,0x00CC)
or CheckDeadUni12("a4",0x012F,0x012E)
or CheckDeadUni12("a5",0x0131,0x0130)
or CheckDeadUni12("c1",0x00EE,0x00CE)
or CheckDeadUni12("c2",0x01D0,0x01CF)
or CheckDeadUni12("c3",0x012D,0x012C)
or CheckDeadUni12("t1",0x0129,0x0128)
or CheckDeadUni12("t2",0x012B,0x012A)
or CheckDeadAsc12("t3","ï","Ï")))
OutputChar("i","I")
else if (Ebene = 3)
send {blind}`/
else if (Ebene = 4)
Send {Blind}{Left}
else if (Ebene = 5 )
SendUnicodeChar(0x03B9) ; iota
else if (Ebene = 6)
SendUnicodeChar(0x222B) ; integral
return
neo_a:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x00E1,0x00C1)
or CheckDeadUni12("a2",0x00E0,0x00C0)
or CheckDeadUni12("a5",0x0105,0x0104)
or CheckDeadAsc12("a6","å","Å")
or CheckDeadUni12("c1",0x00E2,0x00C2)
or CheckDeadUni12("c2",0x01CE,0x01CD)
or CheckDeadUni12("c3",0x0103,0x0102)
or CheckDeadUni12("t1",0x00E3,0x00C3)
or CheckDeadUni12("t2",0x0101,0x0100)
or CheckDeadAsc12("t3","ä","Ä")))
OutputChar("a","A")
else if (Ebene = 3)
send {blind}{{}
else if (Ebene = 4)
Send {Blind}{Down}
else if (Ebene = 5)
SendUnicodeChar(0x03B1) ;alpha
else if (Ebene = 6)
SendUnicodeChar(0x2200) ;für alle
return
neo_e:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x00E9,0x00C9)
or CheckDeadUni12("a2",0x00E8,0x00C8)
or CheckDeadUni12("a4",0x0117,0x0116)
or CheckDeadUni12("a5",0x0119,0x0118)
or CheckDeadUni12("c1",0x00EA,0x00CA)
or CheckDeadUni12("c2",0x011B,0x011A)
or CheckDeadUni12("c3",0x0115,0x0114)
or CheckDeadUni12("t2",0x0113,0x0112)
or CheckDeadAsc12("t3","ë","Ë")
or CheckCompAsc12("a","æ","Æ")
or CheckCompAsc12("A","Æ","Æ")
or CheckCompAsc12("o","œ","Œ")
or CheckCompAsc12("O","Œ","Œ")))
OutputChar("e","E")
else if (Ebene = 3) ; {
send {blind}{}}
else if (Ebene = 4)
Send {Blind}{Right}
else if (Ebene = 5)
SendUnicodeChar(0x03B5) ;epsilon
else if (Ebene = 6)
SendUnicodeChar(0x2203) ;es existiert
return
neo_o:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x00F3,0x00D3)
or CheckDeadUni12("a2",0x00F2,0x00D2)
or CheckDeadUni12("a5",0x01EB,0x01EA)
or CheckDeadUni12("c1",0x00F4,0x00D4)
or CheckDeadUni12("c2",0x01D2,0x01D1)
or CheckDeadUni12("c3",0x014F,0x014E)
or CheckDeadUni12("t1",0x00F5,0x00D5)
or CheckDeadUni12("t2",0x014D,0x014C)
or CheckDeadAsc12("t3","ö","Ö")
or CheckDeadUni12("t4",0x00F8,0x00D8)
or CheckDeadUni12("t5",0x0151,0x0150)))
OutputChar("o","O")
else if (Ebene = 3)
send {blind}*
else if (Ebene = 4)
Send {blind}{End}
else if (Ebene = 5)
SendUnicodeChar(0x03BF) ; omicron
else if (Ebene = 6)
SendUnicodeChar(0x2208) ; element of
return
neo_s:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x015B,0x015A)
or CheckDeadUni12("a3",0x015F,0x015E)
or CheckDeadUni12("a4",0x1E61,0x1E60)
or CheckDeadUni12("c1",0x015D,0x015C)
or CheckDeadUni12("c2",0x0161,0x0160)
or CheckDeadUni12("c6",0x1E63,0x1A62)))
if (Ebene = 1)
{
if LangSTastatur
if (GetKeyState("CapsLock","T"))
send {blind}s
else
SendUnicodeChar(0x017F) ;langes S
else
send {blind}s
if (PriorDeadKey = "comp")
CompKey := "s"
}
else if (Ebene = 2)
{
if LangSTastatur
if (GetKeyState("CapsLock","T"))
SendUnicodeChar(0x017F) ;langes S
else
send {blind}S
else
send {blind}S
if (PriorDeadKey = "comp")
CompKey := "S"
}
else if (Ebene = 3)
send {blind}?
else if (Ebene = 4)
Send ¿
else if (Ebene = 5)
SendUnicodeChar(0x03C3) ;sigma
else if (Ebene = 6)
SendUnicodeChar(0x03A3) ; Sigma
return
neo_n:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x0144,0x0143)
or CheckDeadUni12("a3",0x0146,0x0145)
or CheckDeadUni12("a4",0x1E45,0x1E44)
or CheckDeadUni12("c2",0x0148,0x0147)
or CheckDeadUni12("t1",0x00F1,0x00D1)))
OutputChar("n","N")
else if (Ebene = 3)
send {blind}( ; )
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2074)
or CheckDeadUni("c5",0x2084)))
Send {blind}{NumPad4}
else if (Ebene = 5)
SendUnicodeChar(0x03BD) ; nu
else if (Ebene = 6)
SendUnicodeChar(0x2115) ; N (natürliche Zahlen)
return
neo_r:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x0155,0x0154)
or CheckDeadUni12("a3",0x0157,0x0156)
or CheckDeadUni12("a4",0x0E59,0x0E58)
or CheckDeadUni12("c2",0x0159,0x0158)
or CheckDeadUni12("c6",0x1E5B,0x1E5A)
or CheckCompAsc12("o","®","®")
or CheckCompAsc12("O","®","®")))
OutputChar("r","R")
else if (Ebene = 3) ;(
send {blind})
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2075)
or CheckDeadUni("c5",0x2085)))
Send {blind}{NumPad5}
else if (Ebene = 5)
SendUnicodeChar(0x03F1) ; rho symbol (varrho)
else if (Ebene = 6)
SendUnicodeChar(0x211D) ; R (reelle Zahlen)
return
neo_t:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a3",0x0163,0x0162)
or CheckDeadUni12("a4",0x1E6B,0x1E6A)
or CheckDeadUni12("c2",0x0165,0x0164)
or CheckDeadUni12("c5",0x0167,0x0166)
or CheckDeadUni12("c6",0x1E6D,0x1E6C)))
OutputChar("t","T")
else if (Ebene = 3)
send {blind}- ; Bis
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2076)
or CheckDeadUni("c5",0x2086)))
Send {blind}{NumPad6}
else if (Ebene = 5)
SendUnicodeChar(0x03C4) ; tau
else if (Ebene = 6)
SendUnicodeChar(0x2202 ) ; partielle Ableitung
return
neo_d:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E0B,0x1E0A)
or CheckDeadUni12("c2",0x010F,0x010E)
or CheckDeadUni12("c5",0x0111,0x0110)
or CheckDeadUni12("c6",0x1E0D,0x1E0C)
or CheckDeadUni12("t4",0x00F0,0x00D0)))
OutputChar("d","D")
else if (Ebene = 3)
send {blind}:
else if (Ebene = 4)
send `,
else if (Ebene = 5)
SendUnicodeChar(0x03B4) ;delta
else if (Ebene = 6)
SendUnicodeChar(0x0394) ; Delta
return
neo_y:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x00FD,0x00DD)
or CheckDeadUni12("c1",0x0177,0x0176)
or CheckDeadAsc12("t3","ÿ",Ÿ)))
OutputChar("y","Y")
else if (Ebene = 3)
send {blind}@
else if (Ebene = 4)
Send {blind}.
else if (Ebene = 5)
SendUnicodeChar(0x03C5) ; upsilon
else if (Ebene = 6)
SendUnicodeChar(0x2207) ; nabla
return
/*
Reihe 4
*/
neo_ü:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x01D8,0x01D7)
or CheckDeadUni12("a2",0x01DC,0x01DB)
or CheckDeadUni12("c2",0x01DA,0x01D9)
or CheckDeadUni12("t2",0x01D6,0x01D5)))
OutputChar("ü","Ü")
else if (Ebene = 3)
send {#}
else if (Ebene = 4)
Send {blind}{Esc}
else if (Ebene = 5)
{
DeadKey := PriorDeadKey
CompKey := PriorCompKey
} ; leer
else if (Ebene = 6)
SendUnicodeChar(0x221D) ; proportional
return
neo_ö:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("t2",0x022B,0x022A)))
OutputChar("ö","Ö")
else if (Ebene = 3)
send {blind}$
else if (Ebene = 4)
send {blind}{Tab}
else if (Ebene = 5)
{
DeadKey := PriorDeadKey
CompKey := PriorCompKey
} ; leer
else if (Ebene = 6)
SendUnicodeChar(0x2111) ; Fraktur I
return
neo_ä:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("t2",0x01DF,0x01DE)))
OutputChar("ä","Ä")
else if (Ebene = 3)
send {blind}|
else if (Ebene = 4)
Send {blind}{PgDn} ; Next
else if (Ebene = 5)
SendUnicodeChar(0x03B7) ; eta
else if (Ebene = 6)
SendUnicodeChar(0x211C) ; altes R
return
neo_p:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E57,0x1E56)))
OutputChar("p","P")
else if ((Ebene = 3) and !(CheckDeadUni("t1",0x2248)))
send {blind}~
else if (Ebene = 4)
Send {blind}{Enter}
else if (Ebene = 5)
SendUnicodeChar(0x03C0) ;pi
else if (Ebene = 6)
SendUnicodeChar(0x03A0) ; Pi
return
neo_z:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x017A,0x0179)
or CheckDeadUni12("a4",0x017C,0x017B)
or CheckDeadUni12("c2",0x017E,0x017D)
or CheckDeadUni12("c6",0x1E93,0x1E92)))
OutputChar("z","Z")
else if (Ebene = 3)
send ``{space} ; untot
else if (Ebene = 4)
{
DeadKey := PriorDeadKey
CompKey := PriorCompKey
} ; leer
else if (Ebene = 5)
SendUnicodeChar(0x03B6) ;zeta
else if (Ebene = 6)
SendUnicodeChar(0x2124) ; Z (ganze Zahlen)
return
neo_b:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E03,0x1E02)))
OutputChar("b","B")
else if (Ebene = 3)
send {blind}{+}
else if (Ebene = 4)
send {blind}:
else if (Ebene = 5)
SendUnicodeChar(0x03B2) ; beta
else if (Ebene = 6)
SendUnicodeChar(0x21D2) ; Doppel-Pfeil rechts
return
neo_m:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E41,0x1E40)
or CheckDeadUni12("c6",0x1E43,0x1E42)
or CheckCompUni12("t",0x2122,0x2122) ; TM
or CheckCompUni12("T",0x2122,0x2122) ; TM
or CheckCompUni12("s",0x2120,0x2120) ; SM
or CheckCompUni12("S",0x2120,0x2120))) ; SM
OutputChar("m","M")
else if (Ebene = 3)
send {blind}`%
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x00B9)
or CheckDeadUni("c5",0x2081)))
Send {blind}{NumPad1}
else if (Ebene = 5)
SendUnicodeChar(0x03BC) ; griechisch mu, micro wäre 0x00B5
else if (Ebene = 6)
SendUnicodeChar(0x21D4) ; doppelter Doppelpfeil (genau dann wenn)
return
neo_komma:
EbeneAktualisieren()
if (Ebene = 1)
if (GetKeyState("CapsLock","T"))
send {blind}{Shift down},{Shift up}
else
send {blind},
else if (Ebene = 2)
SendUnicodeChar(0x22EE) ; vertikale ellipse
else if (Ebene = 3)
send {blind}"
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x00B2)
or CheckDeadUni("c5",0x2082)))
Send {blind}{NumPad2}
else if (Ebene = 5)
SendUnicodeChar(0x03C1) ; rho
else if (Ebene = 6)
SendUnicodeChar(0x21D0) ; Doppelpfeil links
return
neo_punkt:
EbeneAktualisieren()
if (Ebene = 1)
if (GetKeyState("CapsLock","T"))
send {blind}{Shift down}.{Shift up}
else
send {blind}.
else if (Ebene = 2)
SendUnicodeChar(0x2026) ; ellipse
else if (Ebene = 3)
send {blind}'
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x00B3)
or CheckDeadUni("c5",0x2083)))
Send {blind}{NumPad3}
else if (Ebene = 5)
SendUnicodeChar(0x03D1) ; theta symbol (vartheta)
else if (Ebene = 6)
SendUnicodeChar(0x0398) ; Theta
return
neo_j:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("c1",0x0135,0x0134)
or CheckDeadUni12("c2",0x01F0,"")
or CheckCompUni12("i",0x0133,"") ; ij
or CheckCompUni12("I","",0x0132) ; IJ
or CheckCompUni12("l",0x01C9,"") ; lj
or CheckCompUni12("L",0x01C8,0x01C7) ; Lj/LJ
or CheckCompUni12("n",0x01CC,"") ; nj
or CheckCompUni12("N",0x01CB,0x01CA))) ; Nj/NJ
OutputChar("j","J")
else if (Ebene = 3)
send {blind}`;
else if (Ebene = 4)
Send {blind}`;
else if (Ebene = 5)
SendUnicodeChar(0x03B8) ; theta
else if (Ebene = 6)
SendUnicodeChar(0x2261) ; identisch
return
/*
Numpad
folgende Tasten verhalten sich bei ein- und ausgeschaltetem
NumLock gleich:
*/
neo_NumpadDiv:
EbeneAktualisieren()
if ((Ebene = 1) or (Ebene = 2))
send {blind}{NumpadDiv}
else if (Ebene = 3)
send {blind}÷
else if ((Ebene = 4) or (Ebene = 5))
SendUnicodeChar(0x2215) ; slash
return
neo_NumpadMult:
EbeneAktualisieren()
if ((Ebene = 1) or (Ebene = 2))
send {blind}{NumpadMult}
else if (Ebene = 3)
send {blind}×
else if ((Ebene = 4) or (Ebene = 5))
SendUnicodeChar(0x22C5) ; cdot
return
neo_NumpadSub:
EbeneAktualisieren()
if (((Ebene = 1) or (Ebene = 2)) and !(CheckDeadUni("c1",0x207B)
or CheckDeadUni("c5",0x208B)))
send {blind}{NumpadSub}
else if (Ebene = 3)
SendUnicodeChar(0x2212) ; echtes minus
return
neo_NumpadAdd:
EbeneAktualisieren()
if (((Ebene = 1) or (Ebene = 2)) and !(CheckDeadUni("c1",0x207A)
or CheckDeadUni("c5",0x208A)))
send {blind}{NumpadAdd}
else if (Ebene = 3)
send {blind}±
else if ((Ebene = 4) or (Ebene = 5))
SendUnicodeChar(0x2213) ; -+
return
neo_NumpadEnter:
EbeneAktualisieren()
if ((Ebene = 1) or (Ebene = 2))
send {blind}{NumpadEnter}
else if (Ebene = 3)
SendUnicodeChar(0x2260) ; neq
else if ((Ebene = 4) or (Ebene = 5))
SendUnicodeChar(0x2248) ; approx
return
/*
folgende Tasten verhalten sich bei ein- und ausgeschaltetem NumLock
unterschiedlich
*/
neo_Numpad7:
EbeneAktualisieren()
if ((Ebene = 1) and (NumLock = 0))
send {blind}{NumpadHome}
else if ((Ebene = 2) and (NumLock = 1))
send {blind}{Shift up}{NumpadHome}{Shift down}
else if (((Ebene = 1) and (NumLock = 1)) or ((Ebene = 2) and (NumLock = 0)))
{
if (Ebene = 1)
send {blind}{Numpad7}
else
send {blind){Shift up}{Numpad7}{Shift down}
if (PriorDeadKey = "comp")
CompKey := "Num_7"
}
else if (Ebene = 3)
SendUnicodeChar(0x2195) ; Hoch-Runter-Pfeil
else if ((Ebene = 4) or (Ebene = 5))
SendUnicodeChar(0x226A) ; ll
return
neo_Numpad8:
EbeneAktualisieren()
if ((Ebene = 1) and (NumLock = 0))
send {blind}{NumpadUp}
else if ((Ebene = 2) and (NumLock = 1))
send {blind}{Shift up}{NumpadUp}{Shift down}
else if (((Ebene = 1) and (NumLock = 1)) or ((Ebene = 2) and (NumLock = 0)))
{
if !(CheckCompUni("Num_1",0x215B) ; 1/8
or CheckCompUni("1",0x215B) ; 1/8
or CheckCompUni("Num_3",0x215C) ; 3/8
or CheckCompUni("3",0x215C) ; 3/8
or CheckCompUni("Num_5",0x215D) ; 3/8
or CheckCompUni("5",0x215D) ; 5/8
or CheckCompUni("Num_7",0x215E) ; 7/8
or CheckCompUni("7",0x215E)) ; 7/8
if (Ebene = 1)
send {blind}{Numpad8}
else
send {blind){Shift up}{Numpad8}{Shift down}
if (PriorDeadKey = "comp")
CompKey := "Num_8"
}
else if (Ebene = 3)
SendUnicodeChar(0x2191) ; uparrow
else if ((Ebene = 4) or (Ebene = 5))
SendUnicodeChar(0x2229) ; intersection
return
neo_Numpad9:
EbeneAktualisieren()
if ((Ebene = 1) and (NumLock = 0))
send {blind}{NumpadPgUp}
else if ((Ebene = 2) and (NumLock = 1))
send {blind}{Shift up}{NumpadPgUp}{Shift down}
else if (((Ebene = 1) and (NumLock = 1)) or ((Ebene = 2) and (NumLock = 0)))
{
if (Ebene = 1)
send {blind}{Numpad9}
else
send {blind){Shift up}{Numpad9}{Shift down}
if (PriorDeadKey = "comp")
CompKey := "Num_9"
}
else if (Ebene = 3)
SendUnicodeChar(0x2297) ; Tensorprodukt ; Vektor in die Ebene zeigend
else if ((Ebene = 4) or (Ebene = 5))
SendUnicodeChar(0x226B) ; gg
return
neo_Numpad4:
EbeneAktualisieren()
if ((Ebene = 1) and (NumLock = 0))
send {blind}{NumpadLeft}
else if ((Ebene = 2) and (NumLock = 1))
send {blind}{Shift up}{NumpadLeft}{Shift down}
else if (((Ebene = 1) and (NumLock = 1)) or ((Ebene = 2) and (NumLock = 0)))
{
if !(CheckCompUni("Num_1",0x00BC) ; 1/4
or CheckCompUni("1",0x00BE) ; 1/4
or CheckCompUni("Num_3",0x00BE) ; 3/4
or CheckCompUni("3",0x00BE)) ; 3/4
if (Ebene = 1)
send {blind}{Numpad4}
else
send {blind){Shift up}{Numpad4}{Shift down}
if (PriorDeadKey = "comp")
CompKey := "Num_4"
}
else if (Ebene = 3)
SendUnicodeChar(0x2190) ; leftarrow
else if ((Ebene = 4) or (Ebene = 5))
SendUnicodeChar(0x2282) ; subset of
return
neo_Numpad5:
EbeneAktualisieren()
if ((Ebene = 1) and (NumLock = 0))
send {blind}{NumpadClear}
else if ((Ebene = 2) and (NumLock = 1))
send {blind}{Shift up}{NumpadClear}{Shift down}
else if (((Ebene = 1) and (NumLock = 1)) or ((Ebene = 2) and (NumLock = 0)))
{
if !(CheckCompUni("Num_1",0x2155) ; 1/5
or CheckCompUni("1",0x2155) ; 1/5
or CheckCompUni("Num_2",0x2156) ; 2/5
or CheckCompUni("2",0x2156) ; 2/5
or CheckCompUni("Num_3",0x2157) ; 3/5
or CheckCompUni("3",0x2157) ; 3/5
or CheckCompUni("Num_4",0x2158) ; 4/5
or CheckCompUni("4",0x2158)) ; 4/5
if (Ebene = 1)
send {blind}{Numpad5}
else
send {blind){Shift up}{Numpad5}{Shift down}
if (PriorDeadKey = "comp")
CompKey := "Num_5"
}
else if (Ebene = 3)
SendUnicodeChar(0x221E) ; INFINITY
else if ((Ebene = 4) or (Ebene = 5))
SendUnicodeChar(0x220B) ; enthält das Element
return
neo_Numpad6:
EbeneAktualisieren()
if ((Ebene = 1) and (NumLock = 0))
send {blind}{NumpadRight}
else if ((Ebene = 2) and (NumLock = 1))
send {blind}{Shift up}{NumpadRight}{Shift down}
else if (((Ebene = 1) and (NumLock = 1)) or ((Ebene = 2) and (NumLock = 0)))
{
if !(CheckCompUni("Num_1",0x2159) ; 1/6
or CheckCompUni("1",0x2159) ; 1/6
or CheckCompUni("Num_5",0x215A) ; 5/6
or CheckCompUni("5",0x215A)) ; 5/6
if (Ebene = 1)
send {blind}{Numpad6}
else
send {blind){Shift up}{Numpad6}{Shift down}
if (PriorDeadKey = "comp")
CompKey := "Num_6"
}
else if (Ebene = 3)
SendUnicodeChar(0x2192) ; rightarrow
else if ((Ebene = 4) or (Ebene = 5))
SendUnicodeChar(0x2283) ; superset of
return
neo_Numpad1:
EbeneAktualisieren()
if ((Ebene = 1) and (NumLock = 0))
send {blind}{NumpadEnd}
else if ((Ebene = 2) and (NumLock = 1))
send {blind}{Shift up}{NumpadEnd}{Shift down}
else if (((Ebene = 1) and (NumLock = 1)) or ((Ebene = 2) and (NumLock = 0)))
{
if (Ebene = 1)
send {blind}{Numpad1}
else
send {blind){Shift up}{Numpad1}{Shift down}
if (PriorDeadKey = "comp")
CompKey := "Num_1"
}
else if (Ebene = 3)
SendUnicodeChar(0x2194) ; Links-Rechts-Pfeil
else if ((Ebene = 4) or (Ebene = 5))
SendUnicodeChar(0x2264) ; leq
return
neo_Numpad2:
EbeneAktualisieren()
if ((Ebene = 1) and (NumLock = 0))
send {blind}{NumpadDown}
else if ((Ebene = 2) and (NumLock = 1))
send {blind}{Shift up}{NumpadDown}{Shift down}
else if (((Ebene = 1) and (NumLock = 1)) or ((Ebene = 2) and (NumLock = 0)))
{
if !(CheckCompUni("Num_1",0x00BD) ; 1/2
or CheckCompUni("1",0x00BD)) ; 1/2
if (Ebene = 1)
send {blind}{Numpad2}
else
send {blind){Shift up}{Numpad2}{Shift down}
if (PriorDeadKey = "comp")
CompKey := "Num_2"
}
else if (Ebene = 3)
SendUnicodeChar(0x2193) ; downarrow
else if ((Ebene = 4) or (Ebene = 5))
SendUnicodeChar(0x222A) ; vereinigt
return
neo_Numpad3:
EbeneAktualisieren()
if ((Ebene = 1) and (NumLock = 0))
send {blind}{NumpadPgDn}
else if ((Ebene = 2) and (NumLock = 1))
send {blind}{Shift up}{NumpadPgDn}{Shift down}
else if (((Ebene = 1) and (NumLock = 1)) or ((Ebene = 2) and (NumLock = 0)))
{
if !(CheckCompUni("Num_1",0x2153) ; 1/3
or CheckCompUni("1",0x2154) ; 1/3
or CheckCompUni("Num_2",0x2154) ; 2/3
or CheckCompUni("2",0x2154)) ; 2/3
if (Ebene = 1)
send {blind}{Numpad3}
else
send {blind){Shift up}{Numpad3}{Shift down}
if (PriorDeadKey = "comp")
CompKey := "Num_3"
}
else if (Ebene = 3)
SendUnicodeChar(0x21CC) ; RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON
else if ((Ebene = 4) or (Ebene = 5))
SendUnicodeChar(0x2265) ; geq
return
neo_Numpad0:
EbeneAktualisieren()
if ((Ebene = 1) and (NumLock = 0))
send {blind}{NumpadIns}
else if ((Ebene = 2) and (NumLock = 1))
send {blind}{Shift up}{NumpadIns}{Shift down}
else if (((Ebene = 1) and (NumLock = 1)) or ((Ebene = 2) and (NumLock = 0)))
{
if (Ebene = 1)
send {blind}{Numpad0}
else
send {blind){Shift up}{Numpad0}{Shift down}
if (PriorDeadKey = "comp")
CompKey := "Num_0"
}
else if (Ebene = 3)
send {blind}`%
else if ((Ebene = 4) or (Ebene = 5))
send
return
neo_NumpadDot:
EbeneAktualisieren()
if ((Ebene = 1) and (NumLock = 0))
send {blind}{NumpadDel}
else if ((Ebene = 2) and (NumLock = 1))
send {blind}{Shift up}{NumpadDel}{Shift down}
else if (((Ebene = 1) and (NumLock = 1)) or ((Ebene = 2) and (NumLock = 0)))
if (Ebene = 1)
send {blind}{NumpadDot}
else
send {blind){Shift up}{NumpadDot}{Shift down}
else if (Ebene = 3)
send {blind}.
else if ((Ebene = 4) or (Ebene = 5))
send `,
return
/*
Sondertasten
*/
*space::
if ((einHandNeo))
spacepressed := 1
else
goto neo_SpaceUp
return
*space up::
if ((einHandNeo))
{
if ((keypressed))
{
keypressed := 0
spacepressed := 0
}
else
{
goto neo_SpaceUp
}
}
else
{ } ;do nothing
return
neo_SpaceUp:
EbeneAktualisieren()
if ((Ebene = 1) and !(CheckComp3Uni("r_1",0x2170) ; römisch i
or CheckComp3Uni("R_1",0x2160))) ; römisch I
Send {blind}{Space}
else if ((Ebene = 2) or (Ebene = 3))
Send {blind}{Space}
else if (Ebene = 4 and !(CheckDeadUni("c1",0x2070)
or CheckDeadUni("c5",0x2080)))
Send {blind}{NumPad0}
else if (Ebene = 5)
SendUnicodeChar(0x00A0) ; geschütztes Leerzeichen
else if (Ebene = 6)
SendUnicodeChar(0x202F) ; schmales Leerzeichen
DeadKey := "" CompKey := ""
spacepressed := 0
keypressed := 0
return
/*
Folgende Tasten sind nur aufgeführt, um PriorDeadKey zu leeren.
Irgendwie sieht das noch nicht schön aus. Vielleicht lässt sich dieses
Problem irgendwie eleganter lösen...
Nachtrag:
Weil es mit Alt+Tab Probleme gab, wird hier jetzt erstmal rumgeflickschustert,
bis eine allgemeinere Lösung gefunden wurde.
*/
*Enter::
if (not(lernModus) or lernModus_std_Return)
{
send {Blind}{Enter}
DeadKey := "" CompKey := ""
}
return
*Backspace::
if (not(lernModus) or lernModus_std_Backspace)
{
send {Blind}{Backspace}
DeadKey := "" CompKey := ""
}
return
*Del::
if (not(lernModus) or lernModus_std_Entf)
send {Blind}{Del}
return
*Ins::
if (not(lernModus) or lernModus_std_Einf)
send {Blind}{Ins}
return
/*
Auf Mod3+Tab liegt Compose.
*/
neo_tab:
if (IsMod3Pressed()) ;#
{
DeadKey := "comp"
CompKey := ""
}
else
{
send {blind}{Tab}
DeadKey := ""
CompKey := ""
}
return
*Home::
if (not(lernModus) or lernModus_std_Pos1)
{
send {Blind}{Home}
DeadKey := "" CompKey := ""
}
return
*End::
if (not(lernModus) or lernModus_std_Ende)
{
send {Blind}{End}
DeadKey := "" CompKey := ""
}
return
*PgUp::
if (not(lernModus) or lernModus_std_PgUp)
{
send {Blind}{PgUp}
DeadKey := "" CompKey := ""
}
return
*PgDn::
if (not(lernModus) or lernModus_std_PgDn)
{
send {Blind}{PgDn}
DeadKey := "" CompKey := ""
}
return
*Up::
if (not(lernModus) or lernModus_std_Hoch)
{
send {Blind}{Up}
DeadKey := "" CompKey := ""
}
return
*Down::
if (not(lernModus) or lernModus_std_Runter)
{
send {Blind}{Down}
DeadKey := "" CompKey := ""
}
return
*Left::
if (not(lernModus) or lernModus_std_Links)
{
send {Blind}{Left}
DeadKey := "" CompKey := ""
}
return
*Right::
if (not(lernModus) or lernModus_std_Rechts)
{
send {Blind}{Right}
DeadKey := "" CompKey := ""
}
return
/*
------------------------------------------------------
Methode KeyboardLED zur Steuerung der Keyboard-LEDs
(NumLock/CapsLock/ScrollLock-Lichter)
Benutzungshinweise: Man benutze
KeyboardLED(LEDvalue,"Cmd"), wobei
Cmd = on/off/switch,
LEDvalue: ScrollLock=1, NumLock=2, CapsLock=4
bzw. eine beliebige Summe dieser Werte:
AlleAus=0, CapsLock+NumLock=6, etc.
Der folgende Code wurde übernommen von:
http://www.autohotkey.com/forum/viewtopic.php?t=10532
Um eventuelle Wechselwirkungen mit dem bestehenden
Code (insb. der Unicode-Konvertierung) auszuschießen,
sind auch alle (Hilfsmethoden) mit dem Postfix LED
versehen worden.
------------------------------------------------------
*/
KeyboardLED(LEDvalue, Cmd) ; LEDvalue: ScrollLock=1, NumLock=2, CapsLock=4 ; Cmd = on/off/switch
{
Static h_device
If ! h_device ; initialise
{
device =\Device\KeyBoardClass0
SetUnicodeStrLED(fn,device)
h_device:=NtCreateFileLED(fn,0+0x00000100+0x00000080+0x00100000,1,1,0x00000040+0x00000020,0)
}
VarSetCapacity( output_actual, 4, 0 )
input_size = 4
VarSetCapacity( input, input_size, 0 )
If Cmd= switch ;switches every LED according to LEDvalue
KeyLED:= LEDvalue
If Cmd= on ;forces all choosen LED's to ON (LEDvalue= 0 ->LED's according to keystate)
KeyLED:= LEDvalue | (GetKeyState("ScrollLock", "T") + 2*GetKeyState("NumLock", "T") + 4*GetKeyState("CapsLock", "T"))
If Cmd= off ;forces all choosen LED's to OFF (LEDvalue= 0 ->LED's according to keystate)
{
LEDvalue:= LEDvalue ^ 7
KeyLED:= LEDvalue & (GetKeyState("ScrollLock", "T") + 2*GetKeyState("NumLock", "T") + 4*GetKeyState("CapsLock", "T"))
}
; EncodeIntegerLED( KeyLED, 1, &input, 2 ) ;input bit pattern (KeyLED): bit 0 = scrolllock ;bit 1 = numlock ;bit 2 = capslock
input := Chr(1) Chr(1) Chr(KeyLED)
input := Chr(1)
input=
success := DllCall( "DeviceIoControl"
, "uint", h_device
, "uint", CTL_CODE_LED( 0x0000000b ; FILE_DEVICE_KEYBOARD
, 2
, 0 ; METHOD_BUFFERED
, 0 ) ; FILE_ANY_ACCESS
, "uint", &input
, "uint", input_size
, "uint", 0
, "uint", 0
, "uint", &output_actual
, "uint", 0 )
}
CTL_CODE_LED( p_device_type, p_function, p_method, p_access )
{
Return, ( p_device_type << 16 ) | ( p_access << 14 ) | ( p_function << 2 ) | p_method
}
NtCreateFileLED(ByRef wfilename,desiredaccess,sharemode,createdist,flags,fattribs)
{
VarSetCapacity(fh,4,0)
VarSetCapacity(objattrib,24,0)
VarSetCapacity(io,8,0)
VarSetCapacity(pus,8)
uslen:=DllCall("lstrlenW","str",wfilename)*2
InsertIntegerLED(uslen,pus,0,2)
InsertIntegerLED(uslen,pus,2,2)
InsertIntegerLED(&wfilename,pus,4)
InsertIntegerLED(24,objattrib,0)
InsertIntegerLED(&pus,objattrib,8)
status:=DllCall("ntdll\ZwCreateFile","str",fh,"UInt",desiredaccess,"str",objattrib,"str",io,"UInt",0,"UInt",fattribs
,"UInt",sharemode,"UInt",createdist,"UInt",flags,"UInt",0,"UInt",0, "UInt")
return ExtractIntegerLED(fh)
}
SetUnicodeStrLED(ByRef out, str_)
{
VarSetCapacity(st1, 8, 0)
InsertIntegerLED(0x530025, st1)
VarSetCapacity(out, (StrLen(str_)+1)*2, 0)
DllCall("wsprintfW", "str", out, "str", st1, "str", str_, "Cdecl UInt")
}
ExtractIntegerLED(ByRef pSource, pOffset = 0, pIsSigned = false, pSize = 4)
; pSource is a string (buffer) whose memory area contains a raw/binary integer at pOffset.
; The caller should pass true for pSigned to interpret the result as signed vs. unsigned.
; pSize is the size of PSource's integer in bytes (e.g. 4 bytes for a DWORD or Int).
; pSource must be ByRef to avoid corruption during the formal-to-actual copying process
; (since pSource might contain valid data beyond its first binary zero).
{
Loop %pSize% ; Build the integer by adding up its bytes.
result += *(&pSource + pOffset + A_Index-1) << 8*(A_Index-1)
if (!pIsSigned OR pSize > 4 OR result < 0x80000000)
return result ; Signed vs. unsigned doesn't matter in these cases.
; Otherwise, convert the value (now known to be 32-bit) to its signed counterpart:
return -(0xFFFFFFFF - result + 1)
}
InsertIntegerLED(pInteger, ByRef pDest, pOffset = 0, pSize = 4)
; The caller must ensure that pDest has sufficient capacity. To preserve any existing contents in pDest,
; only pSize number of bytes starting at pOffset are altered in it.
{
Loop %pSize% ; Copy each byte in the integer into the structure as raw binary data.
DllCall("RtlFillMemory", "UInt", &pDest + pOffset + A_Index-1, "UInt", 1, "UChar", pInteger >> 8*(A_Index-1) & 0xFF)
}
/*
Funktionen
*/
/*
Ebenen laut Referenz:
1. Ebene (kein Mod) 4. Ebene (Mod4)
2. Ebene (Umschalt) 5. Ebene (Umschalt+Mod3)
3. Ebene (Mod3) 6. Ebene (Mod3+Mod4)
*/
EbeneAktualisieren()
{
global
PriorDeadKey := DeadKey
PriorCompKey := CompKey
DeadKey := ""
CompKey := ""
Ebene12 := 0
Ebene7 := 0
Ebene8 := 0
Modstate := IsShiftPressed() . IsMod3Pressed() . IsMod4Pressed()
if (ahkTreiberKombi)
if ( Modstate = "001")
Ebene = 6
else
Ebene = -1
else
if (Modstate = "000")
Ebene = 1 ; Ebene 1: Ohne Mod
else if (Modstate = "100")
Ebene = 2 ; Ebene 2: Shift
else if (Modstate = "010")
Ebene = 3 ; Ebene 3: Mod3
else if (Modstate = "001")
Ebene = 4 ; Ebene 4: Mod4
else if (Modstate = "110")
Ebene = 5 ; Ebene 5: Shift+Mod3
else if (Modstate = "011")
Ebene = 6 ; Ebene 6: Mod3+Mod4
else if (Modstate = "101")
{
Ebene = 4 ; Ebene 7: Shift+Mod4 impliziert Ebene 4
Ebene7 = 1
}
else if (Modstate = "111")
{
Ebene = 6 ; Ebene 8: Shift+Mod3+Mod4 impliziert Ebene 6
Ebene8 = 1
}
Ebene12 := ((Ebene = 1) or (Ebene = 2))
if GetKeyState("NumLock","T")
NumLock = 1
else
NumLock = 0
}
IsShiftPressed()
{
return GetKeyState("Shift","P")
}
IsMod3Pressed()
{
global
if (IsMod3Locked)
{
return (not ( GetKeyState("CapsLock","P") or GetKeyState("#","P") )) ; # = SC02B
}
else {
return ( GetKeyState("CapsLock","P") or GetKeyState("#","P") ) ; # = SC02B
}
}
IsMod4Pressed()
{
global
if( not(einHandNeo) or not(spacepressed) )
{
if (IsMod4Locked)
{
return (not ( GetKeyState("<","P") or GetKeyState("SC138","P")))
}
else {
return ( GetKeyState("<","P") or GetKeyState("SC138","P"))
}
}
else
{
if (IsMod4Locked)
{
return (not ( GetKeyState("<","P") or GetKeyState("SC138","P") or GetKeyState("ä","P")))
}
else {
return ( GetKeyState("<","P") or GetKeyState("SC138","P") or GetKeyState("ä","P"))
}
}
}
SendUnicodeChar(charCode)
{
IfWinActive, ahk_class gdkWindowToplevel
{
StringLower, charCode, charCode
send % "^+u" . SubStr(charCode,3) . " "
} else {
VarSetCapacity(ki, 28 * 2, 0)
EncodeInteger(&ki + 0, 1)
EncodeInteger(&ki + 6, charCode)
EncodeInteger(&ki + 8, 4)
EncodeInteger(&ki +28, 1)
EncodeInteger(&ki +34, charCode)
EncodeInteger(&ki +36, 4|2)
DllCall("SendInput", "UInt", 2, "UInt", &ki, "Int", 28)
}
}
/*
Über den GTK-Workaround:
Dieser basiert auf http://www.autohotkey.com/forum/topic32947.html
Der Aufruf von »SubStr(charCode,3)« geht davon aus, dass alle charCodes in Hex mit führendem „0x“ angegeben sind. Die abenteuerliche „^+u“-Konstruktion benötigt im Übrigen den Hex-Wert in Kleinschrift, was derzeit nicht bei den Zeichendefinitionen umgesetzt ist, daher zentral und weniger fehlerträchtig an dieser Stelle. Außerdem ein abschließend gesendetes Space, sonst bleibt der „eingetippte“ Unicode-Wert noch kurz sichtbar stehen, bevor er sich GTK-sei-dank in das gewünschte Zeichen verwandelt.
*/
BSSendUnicodeChar(charCode)
{
send {bs}
SendUnicodeChar(charCode)
}
CompUnicodeChar(charCode)
{
send {bs}
SendUnicodeChar(charCode)
}
Comp3UnicodeChar(charCode)
{
send {bs}{bs}
SendUnicodeChar(charCode)
}
EncodeInteger(ref, val)
{
DllCall("ntdll\RtlFillMemoryUlong", "Uint", ref, "Uint", 4, "Uint", val)
}
deadAsc(val)
{
global
if (DeadSilence)
{} ; keine Ausgabe
else
send % "{blind}" . val
}
deadUni(val)
{
global
if (DeadSilence)
{} ; keine Ausgabe
else
SendUnicodeChar(val)
}
undeadAsc(val)
{
global
if (DeadSilence)
send % "{blind}" . val
else
send % "{blind}{bs}" . val
}
undeadUni(val)
{
global
if (DeadSilence)
{} ; keine ausgabe
else
send {bs}
SendUnicodeChar(val)
}
CheckDeadAsc(d,val)
{
global
if (PriorDeadKey == d)
{
undeadAsc(val)
return 1
}
else
return 0
}
CheckDeadUni(d,val)
{
global
if (PriorDeadKey == d)
{
undeadUni(val)
return 1
}
else
return 0
}
CheckDeadAsc12(d,val1,val2)
{
global
if (PriorDeadKey == d)
{
if ((Ebene = 1) and (val1 != ""))
{
undeadAsc(val1)
return 1
}
else if ((Ebene = 2) and (val2 != ""))
{
undeadAsc(val2)
return 1
}
else
return 0
}
else
return 0
}
CheckDeadUni12(d,val1,val2)
{
global
if (PriorDeadKey == d)
{
if ((Ebene = 1) and (val1 != ""))
{
undeadUni(val1)
return 1
}
else if ((Ebene = 2) and (val2 != ""))
{
undeadUni(val2)
return 1
}
else
return 0
}
else
return 0
}
compAsc(val)
{
global
if (DeadCompose)
{} ; keine Ausgabe
else
send % "{blind}" . val
}
compUni(val)
{
global
if (DeadCompose)
{} ; keine Ausgabe
else
SendUnicodeChar(val)
}
uncompAsc(val)
{
global
if (DeadCompose)
send % "{blind}" . val
else
send % "{blind}{bs}" . val
}
uncompUni(val)
{
global
if (DeadCompose)
{} ; keine ausgabe
else
send {bs}
SendUnicodeChar(val)
}
uncomp3Uni(val)
{
global
if (DeadCompose)
{} ; keine ausgabe
else
send {bs}{bs}
SendUnicodeChar(val)
}
CheckCompAsc(d,val)
{
global
if (PriorCompKey == d)
{
uncompAsc(val)
return 1
}
else
return 0
}
CheckCompAsc12(d,val1,val2)
{
global
if (PriorCompKey == d)
if ((Ebene = 1) and (val1 != ""))
{
uncompAsc(val1)
return 1
}
else if ((Ebene = 2) and (val2 != ""))
{
uncompAsc(val2)
return 1
}
else
return 0
else
return 0
}
CheckCompUni(d,val)
{
global
if (PriorCompKey == d)
{
uncompUni(val)
return 1
}
else
return 0
}
CheckCompUni12(d,val1,val2)
{
global
if (PriorCompKey == d)
{
if ((Ebene = 1) and (val1 != ""))
{
uncompUni(val1)
return 1
}
else if ((Ebene = 2) and (val2 != ""))
{
uncompUni(val2)
return 1
}
else
return 0
}
else
return 0
}
CheckComp3Uni(d,val)
{
global
if (PriorCompKey == d)
{
uncomp3Uni(val)
return 1
}
else
return 0
}
CheckComp3Uni12(d,val1,val2)
{
global
if (PriorCompKey == d)
{
if ((Ebene = 1) and (val1 != ""))
{
uncomp3Uni(val1)
return 1
}
else if ((Ebene = 2) and (val2 != ""))
{
uncomp3Uni(val2)
return 1
}
else
return 0
}
else
return 0
}
outputChar(val1,val2)
{
global
if (Ebene = 1)
c := val1
else
c := val2
send % "{blind}" . c
if (PriorDeadKey = "comp")
CompKey := c
}
/*
------------------------------------------------------
Methoden zum Senden von Unicode-Zeichen
------------------------------------------------------
*/
/************************************************************
Alter Weg Copy/Paste über die Zwischenablage
************************************************************/
/*
Unicode(code)
{
saved_clipboard := ClipboardAll
Transform, Clipboard, Unicode, %code%
sendplay ^v
Clipboard := saved_clipboard
}
BSUnicode(code)
{
saved_clipboard := ClipboardAll
Transform, Clipboard, Unicode, %code%
sendplay {bs}^v
Clipboard := saved_clipboard
}
*/
/************************************************************
Neuer Weg Benutzung der entsprechenden Win32-API-Methode
************************************************************/
/*
------------------------------------------------------
BildschirmTastatur
------------------------------------------------------
*/
guiErstellt = 0
alwaysOnTop = 1
*F1::
if (isMod4Pressed() and zeigeBildschirmTastatur)
goto Switch1
else
send {blind}{F1}
return
*F2::
if (isMod4Pressed() and zeigeBildschirmTastatur)
goto Switch2
else
send {blind}{F2}
return
*F3::
if (isMod4Pressed() and zeigeBildschirmTastatur)
goto Switch3
else
send {blind}{F3}
return
*F4::
if (isMod4Pressed() and zeigeBildschirmTastatur)
goto Switch4
else
send {blind}{F4}
return
*F5::
if (isMod4Pressed() and zeigeBildschirmTastatur)
goto Switch5
else
send {blind}{F5}
return
*F6::
if (isMod4Pressed() and zeigeBildschirmTastatur)
goto Switch6
else
send {blind}{F6}
return
*F7::
if (isMod4Pressed() and zeigeBildschirmTastatur)
goto Show
else
send {blind}{F7}
return
*F8::
if (isMod4Pressed() and zeigeBildschirmTastatur)
goto ToggleAlwaysOnTop
else
send {blind}{F8}
return
Switch1:
tImage := ResourceFolder . "\ebene1.png"
goto Switch
Return
Switch2:
tImage := ResourceFolder . "\ebene2.png"
goto Switch
Return
Switch3:
tImage := ResourceFolder . "\ebene3.png"
goto Switch
Return
Switch4:
tImage := ResourceFolder . "\ebene4.png"
goto Switch
Return
Switch5:
tImage := ResourceFolder . "\ebene5.png"
goto Switch
Return
Switch6:
tImage := ResourceFolder . "\ebene6.png"
goto Switch
Return
Switch:
if (guiErstellt)
{
if (Image = tImage)
goto Close
else
{
Image := tImage
SetTimer, Refresh
}
}
else
{
Image := tImage
goto Show
}
Return
Show:
if (guiErstellt)
{
goto Close
}
else
{
if (Image = "")
{
Image := ResourceFolder . "\ebene1.png"
}
yPosition := A_ScreenHeight -270
Gui, Color, FFFFFF
Gui, Add, Button, xm+5 gSwitch1, F1
Gui, Add, Text, x+5, kleine Buchstaben
Gui, Add, Button, xm+5 gSwitch2, F2
Gui, Add, Text, x+5, große Buchstaben
Gui, Add, Button, xm+5 gSwitch3, F3
Gui, Add, Text, x+5, Satz-/Sonderzeichen
Gui, Add, Button, xm+5 gSwitch4, F4
Gui, Add, Text, x+5, Zahlen / Steuerung
Gui, Add, Button, xm+5 gSwitch5, F5
Gui, Add, Text, x+5, Sprachen
Gui, Add, Button, xm+5 gSwitch6, F6
Gui, Add, Text, x+5, Mathesymbole
Gui, Add, Button, xm+5 gShow, F7
Gui, Add, Text, x+5, An /
Gui, Add, Text, y+3, Aus
Gui, Add, Button, x+10 y+-30 gShow, F8
Gui, Add, Text, x+5, OnTop
Gui, Add, Picture,AltSubmit ys w564 h200 vPicture, %Image%
Gui, +AlwaysOnTop
Gui, Show, y%yposition% Autosize
; SetTimer, Refresh
guiErstellt = 1
}
Return
Close:
guiErstellt = 0
Gui, Destroy
Return
Refresh:
If (Image != OldImage)
{
GuiControl, , Picture, %Image%
OldImage := Image
}
Return
ToggleAlwaysOnTop:
if (alwaysOnTop)
{
Gui, -AlwaysOnTop
alwaysOnTop = 0
}
else
{
Gui, +AlwaysOnTop
alwaysOnTop = 1
}
Return
; Ende der BildschirmTastatur
/*
------------------------------------------------------
Shift+Pause "pausiert" das Script.
------------------------------------------------------
*/
*pause::
Suspend, Permit
if isshiftpressed()
goto togglesuspend
else
send {blind}{pause}
return
; ------------------------------------
^.::einHandNeo := not(einHandNeo) ; Punkt
^,::lernModus := not(lernModus) ; Komma
togglesuspend:
if A_IsSuspended
{
menu, tray, rename, %enable%, %disable%
menu, tray, tip, %name%
if (iconBenutzen)
menu, tray, icon, %ResourceFolder%\neo.ico,,1
suspend , off ; Schaltet Suspend aus -> NEO
}
else
{
menu, tray, rename, %disable%, %enable%
menu, tray, tip, %name% : Deaktiviert
if (iconBenutzen)
menu, tray, icon, %ResourceFolder%\neo_disabled.ico,,1
suspend , on ; Schaltet Suspend ein -> QWERTZ
}
return
help:
Run, %A_WinDir%\hh mk:@MSITStore:autohotkey.chm
return
about:
msgbox, 64, %name% Ergonomische Tastaturbelegung,
(
%name%
`nDas Neo-Layout ersetzt das übliche deutsche
Tastaturlayout mit der Alternative Neo,
beschrieben auf http://neo-layout.org/.
`nDazu sind keine Administratorrechte nötig.
`nWenn Autohotkey aktiviert ist, werden alle Tastendrucke
abgefangen und statt dessen eine Übersetzung weitergeschickt.
`nDies geschieht transparent für den Anwender,
es muss nichts installiert werden.
`nDie Zeichenübersetzung kann leicht über das Icon im
Systemtray deaktiviert werden. `n
)
return
neo:
run http://neo-layout.org/
return
autohotkey:
run http://autohotkey.com/
return
open:
ListLines ; shows the Autohotkey window
return
edit:
edit
return
reload:
Reload
return
hide:
menu, tray, noicon
return
exitprogram:
exitapp
return