- 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).

Revision 556 (von Matthias Berg):

- lernModus (an/aus mit Strg+Komma)

• im Skript konfigurierbar.

------------------------------------------------------

*/

#Include %a_scriptdir%\Warning.ahk

#Include %a_scriptdir%\Global-Part.ahk

#Include %a_scriptdir%\Methods-Layers.ahk

#Include %a_scriptdir%\Methods-Other.ahk

#Include %a_scriptdir%\Methods-Unicode.ahk

#Include %a_scriptdir%\Methods-ScreenKeyboard.ahk

; Eines sch�nen Tages sollten auch die Compose-Kombinationen automatisch aus der Referenz erzeugt werden. Derzeitig gibt es nur den (h�chst instabilen und experimentellen!) Compose-Playground:

;#Include *i %a_scriptdir%\..\Compose\Compose-all-in-one.ahk

/****************

* Verzeichnisse *

EnvGet, WindowsEnvAppDataFolder, APPDATA

ApplicationFolder = %WindowsEnvAppDataFolder%\NEO2

FileCreateDir, %ApplicationFolder%

/*******************

* Globale Schalter *

********************

*/

; Im folgenden gilt (soweit nicht anders angegeben) Ja = 1, Nein = 0:

; 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)?

; Soll der Treiber im Einhandmodus betrieben werden?

; Soll der Lernmodus aktiviert werden?

; Soll mit einer MsgBox explizit auf das Ein- und Ausschalten des Mod4-Locks hingewiesen werden?

; Soll aktivierter Mod4-Lock �ber die Rollen-LED des Keybord angezeigt werden (analog zu CapsLock)?

; Soll Lang-s auf s, s auf � und � auf Lang-s gelegt (bzw. vertauscht) werden?

; Sollen tote Tasten blind angezeigt werden?

;Sollen Compose-Tasten blind angezeigt werden?

/***********************

* Recourcen-Verwaltung *

************************

*/

; Versuche, alle m�glicherweise in die EXE eingebundenen Dateien zu extrahieren

}

}

; Benutze die Dateien auch dann, wenn sie eventuell im aktuellen Verzeichnis vorhanden sind

*/

{

suspend

(

Nicht kompatibles Tastaturlayout:

`t%inputlocale%

exitapp

}

*/

*/

;Blinde/Sichtbare Tote Tasten

*F9::

if (isMod4pressed())

else

send {blind}{F9}

return

;Blinde/Sichtbare Compose

*F10::

if (isMod4pressed())

else

send {blind}{F10}

return

;Lang-s-Tastatur:

*F11::

else

send {blind}{F11}

return

*Esc::

if (isMod4pressed())

reload

send {blind}{Esc}

return

*pause::

Suspend, Permit

return

togglesuspend:

return

help:

Run, %A_WinDir%\hh mk:@MSITStore:autohotkey.chm

return

about:

return

neo:

run http://neo-layout.org/

return

exitapp

return

Reihe 1

*/

neo_tot1:

EbeneAktualisieren()

deadUni(0x02C6) ; Zirkumflex, tot

deadUni(0x02C7) ; Caron, tot

deadUni(0x02D8) ; Brevis, tot

deadUni(0x00B7) ; Mittenpunkt, tot

deadUni(0x002D) ; Querstrich, tot

return

neo_1:

EbeneAktualisieren()

return

neo_2:

EbeneAktualisieren()

SendUnicodeChar(0x2116) ; Numero

SendUnicodeChar(0x00B2) ; Hochgestellte 2

SendUnicodeChar(0x2023) ; Aufz�hlungspfeil

SendUnicodeChar(0x26A5) ; Piktogramm Zwitter

SendUnicodeChar(0x2228) ; Logisches Oder

return

neo_3:

EbeneAktualisieren()

or CheckDeadUni("c5",0x2083)

SendUnicodeChar(0x00B3) ; Hochgestellte 3

SendUnicodeChar(0x2642) ; Piktogramm Mann

SendUnicodeChar(0x2227) ; Logisches Und

return

neo_4:

EbeneAktualisieren()

or CheckDeadUni("c5",0x2084)

SendUnicodeChar(0x00BB) ; Double guillemot right

Send {blind}{PgUp}

SendUnicodeChar(0x2113) ; Script small L

SendUnicodeChar(0x22A5) ; Senkrecht

return

neo_5:

EbeneAktualisieren()

or CheckDeadUni("c5",0x2085)

SendUnicodeChar(0x00AB) ; Double guillemot left

SendUnicodeChar(0x2020) ; Kreuz (Dagger)

SendUnicodeChar(0x2221) ; Winkel

return

neo_6:

EbeneAktualisieren()

or CheckDeadUni("c5",0x2086)

send {blind}�

send {blind}�

SendUnicodeChar(0x2225) ; parallel

return

neo_7:

EbeneAktualisieren()

or CheckDeadUni("c5",0x2087)

send {blind}�

send {blind}�

SendUnicodeChar(0x03BA) ; greek small letter kappa

SendUnicodeChar(0x2209) ; nicht Element von

return

neo_8:

EbeneAktualisieren()

or CheckDeadUni("c5",0x2088)

send {blind}�

Send {blind}{NumpadDiv}

SendUnicodeChar(0x27E8) ; bra (�ffnende spitze Klammer)

SendUnicodeChar(0x2204) ; es existiert nicht

return

neo_9:

EbeneAktualisieren()

or CheckDeadUni("c5",0x2089)

send {blind}�

Send {blind}{NumpadMult}

SendUnicodeChar(0x27E9) ; ket (schlie�ende spitze Klammer)

SendUnicodeChar(0x2226) ; nicht parallel

return

neo_0:

EbeneAktualisieren()

send {blind}�

Send {blind}{NumpadSub}

SendUnicodeChar(0x2205) ; leere Menge

return

neo_strich:

EbeneAktualisieren()

SendUnicodeChar(0x2013) ; Gedankenstrich

SendUnicodeChar(0x2014) ; Englischer Gedankenstrich (Geviertstrich)

SendUnicodeChar(0x2011) ; gesch�tzter Bindestrich (Bindestrich ohne Zeilenumbruch)

SendUnicodeChar(0x00AD) ; weicher Bindestrich

return

neo_tot2:

EbeneAktualisieren()

deadAsc("{�}{space}") ; Akut, tot

DeadKey := "a1"

DeadKey := "a2"

DeadKey := "a3"

DeadKey := "a4"

DeadKey := "a5"

DeadKey := "a6"

return

neo_x:

EbeneAktualisieren()

OutputChar("x","X")

return

neo_v:

EbeneAktualisieren()

OutputChar("v","V")

send {blind}_

Send {blind}{Backspace}

SendUnicodeChar(0x2259) ; estimates

return

neo_l:

EbeneAktualisieren()

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")

send {blind}[

Send {Blind}{Up}

SendUnicodeChar(0x03BB) ; lambda

SendUnicodeChar(0x039B) ; Lambda

return

neo_c:

EbeneAktualisieren()

or CheckDeadUni12("a3",0x00E7,0x00E6)

or CheckDeadUni12("a4",0x010B,0x010A)

or CheckDeadUni12("c1",0x0109,0x0108)

or CheckDeadUni12("c2",0x010D,0x010C)

or CheckCompAsc("o","�")))

OutputChar("c","C")

send {blind}]

Send {blind}{Del}

SendUnicodeChar(0x03C7) ; chi

SendUnicodeChar(0x2102) ; C (Komplexe Zahlen)

return

neo_w:

EbeneAktualisieren()

OutputChar("w","W")

SendUnicodeChar(0x005E) ; Zirkumflex

SendUnicodeChar(0x03C9) ; omega

SendUnicodeChar(0x03A9) ; Omega

return

neo_k:

EbeneAktualisieren()

or CheckDeadUni12("c6",0x1E33,0x1E32)))

OutputChar("k","K")

send {blind}{!}

Send �

SendUnicodeChar(0x221A) ; Wurzel

return

neo_h:

EbeneAktualisieren()

or CheckDeadUni12("c1",0x0125,0x0124)

or CheckDeadUni12("c5",0x0127,0x0126)

or CheckDeadUni12("c6",0x1E25,0x1E24)))

OutputChar("h","H")

send {blind}<

or CheckDeadUni("c5",0x2087)))

Send {blind}{NumPad7}

SendUnicodeChar(0x03C8) ; psi

SendUnicodeChar(0x03A8) ; Psi

return

neo_g:

EbeneAktualisieren()

or CheckDeadUni12("a4",0x0121,0x0120)

or CheckDeadUni12("c1",0x011D,0x011C)

or CheckDeadUni12("c3",0x011F,0x011E)))

OutputChar("g","G")

Send {blind}{NumPad8}

SendUnicodeChar(0x03B3) ; gamma

SendUnicodeChar(0x0393) ; Gamma

return

neo_f:

EbeneAktualisieren()

or CheckDeadUni12("t4",0x0192,0x0191)))

OutputChar("f","F")

send {blind}`=

or CheckDeadUni("c5",0x2089)))

send {blind}{NumPad9}

SendUnicodeChar(0x03C6) ; phi

SendUnicodeChar(0x03A6) ; Phi

return

neo_q:

EbeneAktualisieren()

OutputChar("q","Q")

send {blind}{&}

or CheckDeadUni("c5",0x208A)))

Send {blind}{NumPadAdd}

SendUnicodeChar(0x03D5) ; phi symbol (varphi)

SendUnicodeChar(0x211A) ; Q (rationale Zahlen)

return

neo_sz:

EbeneAktualisieren()

SendUnicodeChar(0x1E9E) ; versal-�

else if LangSTastatur

send {blind}s

else

send �

if LangSTastatur

send {blind}s

else

send �

else

SendUnicodeChar(0x1E9E) ; versal-�

if LangSTastatur

send �

else

SendUnicodeChar(0x017F) ; langes s

return

neo_tot3:

EbeneAktualisieren()

{

DeadKey := "t1"

}

{

DeadKey := "t2"

}

{

DeadKey := "t3"

}

{

DeadKey := "t4"

}

{

DeadKey := "t5"

}

{

DeadKey := "t6"

}

neo_u:

EbeneAktualisieren()

or CheckDeadUni12("a2",0x00F9,0x00D9)

or CheckDeadUni12("a5",0x0173,0x0172)

or CheckDeadUni12("a6",0x016F,0x016E)

or CheckDeadAsc12("t3","�","�")

or CheckDeadUni12("t5",0x0171,0x0170)))

OutputChar("u","U")

send {blind}\

Send {blind}{Home}

{

CompKey := PriorCompKey

DeadKey := PriorDeadKey

}

SendUnicodeChar(0x222E) ; contour integral

return

neo_i:

EbeneAktualisieren()

or CheckDeadUni12("a2",0x00EC,0x00CC)

or CheckDeadUni12("a4",0x012F,0x012E)

or CheckDeadUni12("a5",0x0131,0x0130)

or CheckDeadUni12("t2",0x012B,0x012A)

or CheckDeadAsc12("t3","�","�")))

OutputChar("i","I")

send {blind}`/

Send {Blind}{Left}

SendUnicodeChar(0x03B9) ; iota

SendUnicodeChar(0x222B) ; integral

return

neo_a:

EbeneAktualisieren()

OutputChar("a","A")

send {blind}{{}

Send {Blind}{Down}

SendUnicodeChar(0x03B1) ; alpha

SendUnicodeChar(0x2200) ; f�r alle

return

neo_e:

EbeneAktualisieren()

or CheckDeadUni12("a2",0x00E8,0x00C8)

or CheckDeadUni12("a4",0x0117,0x0116)

or CheckDeadUni12("a5",0x0119,0x0118)

or CheckCompAsc12("o","�","�")

or CheckCompAsc12("O","�","�")))

OutputChar("e","E")

send {blind}{}}

Send {Blind}{Right}

SendUnicodeChar(0x03B5) ; epsilon

SendUnicodeChar(0x2203) ; es existiert

return

neo_o:

EbeneAktualisieren()

or CheckDeadUni12("a2",0x00F2,0x00D2)

or CheckDeadUni12("a5",0x01EB,0x01EA)

or CheckDeadUni12("c1",0x00F4,0x00D4)

or CheckDeadUni12("t4",0x00F8,0x00D8)

or CheckDeadUni12("t5",0x0151,0x0150)))

OutputChar("o","O")

send {blind}*

Send {blind}{End}

SendUnicodeChar(0x03BF) ; omicron

SendUnicodeChar(0x2208) ; element of

return

neo_s:

EbeneAktualisieren()

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 LangSTastatur

{

send {blind}s

Compkey := "s"

}

else

{

SendUnicodeChar(0x017F) ;langes S

CompKey := "lang_s"

}

else

{

send {blind}s

CompKey := "s"

}

}

{

if LangSTastatur

{

SendUnicodeChar(0x017F) ;langes S

CompKey := "lang_s"

}

else

{

send {blind}S

CompKey := "s"

}

else

{

send {blind}S

CompKey := "S"

}

}

}

send {blind}?

Send �

SendUnicodeChar(0x03C3) ;sigma

SendUnicodeChar(0x03A3) ;Sigma

return

neo_n:

EbeneAktualisieren()

or CheckDeadUni12("a3",0x0146,0x0145)

or CheckDeadUni12("a4",0x1E45,0x1E44)

or CheckDeadUni12("c2",0x0148,0x0147)

or CheckDeadUni12("t1",0x00F1,0x00D1)))

OutputChar("n","N")

send {blind}(

or CheckDeadUni("c5",0x2084)))

Send {blind}{NumPad4}

SendUnicodeChar(0x03BD) ; nu

SendUnicodeChar(0x2115) ; N (nat�rliche Zahlen)

return

neo_r:

EbeneAktualisieren()

or CheckDeadUni12("a3",0x0157,0x0156)

or CheckDeadUni12("a4",0x0E59,0x0E58)

or CheckDeadUni12("c2",0x0159,0x0158)

or CheckCompAsc12("o","�","�")

or CheckCompAsc12("O","�","�")))

OutputChar("r","R")

send {blind})

or CheckDeadUni("c5",0x2085)))

Send {blind}{NumPad5}

SendUnicodeChar(0x03F1) ; rho symbol (varrho)

SendUnicodeChar(0x211D) ; R (reelle Zahlen)

return

neo_t:

EbeneAktualisieren()

or CheckDeadUni12("a4",0x1E6B,0x1E6A)

or CheckDeadUni12("c2",0x0165,0x0164)

or CheckDeadUni12("c5",0x0167,0x0166)

or CheckDeadUni12("c6",0x1E6D,0x1E6C)))

OutputChar("t","T")

or CheckDeadUni("c5",0x2086)))

Send {blind}{NumPad6}

SendUnicodeChar(0x03C4) ; tau

SendUnicodeChar(0x2202) ; partielle Ableitung

return

neo_d:

EbeneAktualisieren()

or CheckDeadUni12("c2",0x010F,0x010E)

or CheckDeadUni12("c5",0x0111,0x0110)

or CheckDeadUni12("c6",0x1E0D,0x1E0C)

or CheckDeadUni12("t4",0x00F0,0x00D0)))

OutputChar("d","D")

send {blind}:

send `,

SendUnicodeChar(0x03B4) ; delta

SendUnicodeChar(0x0394) ; Delta

return

neo_y:

EbeneAktualisieren()

or CheckDeadUni12("c1",0x0177,0x0176)

or CheckDeadAsc12("t3","�","�")))

OutputChar("y","Y")

send {blind}@

Send {blind}.

SendUnicodeChar(0x03C5) ; upsilon

SendUnicodeChar(0x2207) ; nabla

return

neo_�:

EbeneAktualisieren()

or CheckDeadUni12("a2",0x01DC,0x01DB)

or CheckDeadUni12("c2",0x01DA,0x01D9)

or CheckDeadUni12("t2",0x01D6,0x01D5)))

OutputChar("�","�")

send {#}

Send {blind}{Esc}

{

DeadKey := PriorDeadKey

CompKey := PriorCompKey

}

SendUnicodeChar(0x221D) ; proportional

return

neo_�:

EbeneAktualisieren()

OutputChar("�","�")

send {blind}$

send {blind}{Tab}

{

DeadKey := PriorDeadKey

CompKey := PriorCompKey

} ; leer

SendUnicodeChar(0x2111) ; Fraktur I

return

neo_�:

EbeneAktualisieren()

OutputChar("�","�")

send {blind}|

SendUnicodeChar(0x03B7) ; eta

SendUnicodeChar(0x211C) ; Fraktur R

return

neo_p:

EbeneAktualisieren()

OutputChar("p","P")

send {blind}~

Send {blind}{Enter}

SendUnicodeChar(0x03C0) ; pi

SendUnicodeChar(0x03A0) ; Pi

return

neo_z:

EbeneAktualisieren()

or CheckDeadUni12("a4",0x017C,0x017B)

or CheckDeadUni12("c2",0x017E,0x017D)

or CheckDeadUni12("c6",0x1E93,0x1E92)))

OutputChar("z","Z")

{

DeadKey := PriorDeadKey

CompKey := PriorCompKey

} ; leer

SendUnicodeChar(0x03B6) ; zeta

SendUnicodeChar(0x2124) ; Z (ganze Zahlen)

return

neo_b:

EbeneAktualisieren()

OutputChar("b","B")

send {blind}{+}

send {blind}:

SendUnicodeChar(0x03B2) ; beta

SendUnicodeChar(0x21D2) ; Doppel-Pfeil rechts

return

neo_m:

EbeneAktualisieren()

or CheckDeadUni12("c6",0x1E43,0x1E42)

OutputChar("m","M")

send {blind}`%

or CheckDeadUni("c5",0x2081)))

Send {blind}{NumPad1}

SendUnicodeChar(0x03BC) ; griechisch mu, micro w�re 0x00B5

SendUnicodeChar(0x21D4) ; doppelter Doppelpfeil (genau dann wenn)

return

neo_komma:

EbeneAktualisieren()

send {blind}{Shift down},{Shift up}

else

send {blind},

send {blind}"

or CheckDeadUni("c5",0x2082)))

Send {blind}{NumPad2}

SendUnicodeChar(0x03C1) ; rho

SendUnicodeChar(0x21D0) ; Doppelpfeil links

return

neo_punkt:

EbeneAktualisieren()

send {blind}{Shift down}.{Shift up}

else

send {blind}.

send {blind}'

or CheckDeadUni("c5",0x2083)))

Send {blind}{NumPad3}

SendUnicodeChar(0x03D1) ; theta symbol (vartheta)

SendUnicodeChar(0x0398) ; Theta

return

neo_j:

EbeneAktualisieren()

or CheckDeadUni12("c2",0x01F0,"")

or CheckCompUni12("N",0x01CB,0x01CA))) ; Nj/NJ

OutputChar("j","J")

send {blind}`;

Send {blind}`;

SendUnicodeChar(0x03B8) ; theta

SendUnicodeChar(0x2261) ; identisch

return

neo_NumLock:

EbeneAktualisieren()

send `=

{

SetNumLockState

send {NumLock}

}

SendUnicodeChar(0x2248) ; Fast gleich

SendUnicodeChar(0x2260) ; Ungleich zu

return

EbeneAktualisieren()

if Ebene14

send {blind}{NumpadDiv}

send {blind}�

return

EbeneAktualisieren()

if Ebene14

send {blind}{NumpadMult}

send {blind}�

return

neo_NumpadSub:

EbeneAktualisieren()

or CheckDeadUni("c5",0x208B)))

send {blind}{NumpadSub}

SendUnicodeChar(0x2212) ; Echtes Minus

return

neo_NumpadAdd:

EbeneAktualisieren()

or CheckDeadUni("c5",0x208A)))

send {blind}{NumpadAdd}

send {blind}�

return

neo_NumpadEnter:

neo_Numpad7:

EbeneAktualisieren()

{

if NumLock

send {blind}{Numpad7}

else

send {blind){Shift up}{Numpad7}

CompKey := "7"

}

SendUnicodeChar(0x2020) ; Kreuz

SendUnicodeChar(0x2195) ; Hoch-Runter-Pfeil

if NumLock

send {blind}{Shift up}{NumpadHome}

else

neo_Numpad8:

EbeneAktualisieren()

or CheckCompUni("7",0x215E))) ; 7/8

{

if NumLock

send {blind}{Numpad8}

else

send {blind){Shift up}{Numpad8}

CompKey := "8"

}

SendUnicodeChar(0x2229) ; Durchschnitt

SendUnicodeChar(0x2191) ; Hochpfeil

if NumLock

send {blind}{Shift up}{NumpadUp}

else

neo_Numpad9:

EbeneAktualisieren()

{

if NumLock

send {blind}{Numpad9}

else

send {blind){Shift up}{Numpad9}

CompKey := "9"

}

SendUnicodeChar(0x2297) ; Tensorprodukt / Vektor in die Ebene zeigend

SendUnicodeChar(0x220D) ; Kleines umgekehrtes Elementzeichen

if NumLock

send {blind}{Shift up}{NumpadPgUp}

else

neo_Numpad4:

EbeneAktualisieren()

{

if NumLock

send {blind}{Numpad4}

else

send {blind){Shift up}{Numpad4}

CompKey := "4"

}

SendUnicodeChar(0x2282) ; Teilmenge

SendUnicodeChar(0x2190) ; Linkspfeil

if NumLock

send {blind}{Shift up}{NumpadLeft}

else

neo_Numpad5:

EbeneAktualisieren()

or CheckCompUni("4",0x2158))) ; 4/5

{

if NumLock

send {blind}{Numpad5}

else

send {blind){Shift up}{Numpad5}

CompKey := "5"

}

SendUnicodeChar(0x221E) ; Unendlich

SendUnicodeChar(0x20AC) ; Euro

if NumLock

send {NumPad5}

else

neo_Numpad6:

EbeneAktualisieren()

or CheckCompUni("5",0x215a))) ; 5/6

{

if NumLock

send {blind}{Numpad6}

else

send {blind){Shift up}{Numpad6}

CompKey := "6"

}

SendUnicodeChar(0x2283) ; Obermenge

SendUnicodeChar(0x2192) ; Rechtspfeil

if NumLock

send {blind}{Shift up}{NumpadRight}

else

neo_Numpad1:

EbeneAktualisieren()

{

if NumLock

send {blind}{Numpad1}

else

send {blind){Shift up}{Numpad1}

CompKey := "1"

}

SendUnicodeChar(0x2714) ; H�kchen

SendUnicodeChar(0x2194) ; Links-Rechts-Pfeil

if NumLock

send {blind}{Shift up}{NumpadEnd}

else

neo_Numpad2:

EbeneAktualisieren()

{

if NumLock

send {blind}{Numpad2}

else

send {blind){Shift up}{Numpad2}

CompKey := "2"

}

SendUnicodeChar(0x222A) ; Vereinigung

SendUnicodeChar(0x2192) ; Untenpfeil

if NumLock

send {blind}{Shift up}{NumpadDown}

else

neo_Numpad3:

EbeneAktualisieren()

or CheckCompUni("5",0x2154))) ; 2/3

{

if NumLock

send {blind}{Numpad3}

else

send {blind){Shift up}{Numpad3}

CompKey := "3"

}

SendUnicodeChar(0x2718) ; Kreuzchen

SendUnicodeChar(0x2192) ; Rechtspfeil

if NumLock

send {blind}{Shift up}{NumpadPgDn}

else

neo_Numpad0:

EbeneAktualisieren()

{

if NumLock

send {blind}{Numpad0}

else

send {blind){Shift up}{Numpad0}

CompKey := "0"

}

SendUnicodeChar(0x2030) ; Promille

SendUnicodeChar(0x0025) ; Prozent

if NumLock

send {blind}{Shift up}{NumpadIns}

else

neo_NumpadDot:

EbeneAktualisieren()

{

if NumLock

send {blind}{NumpadDot}

else

send {blind){Shift up}{NumpadDot}

}

send `,

send {blind}.

if NumLock

send {blind}{Shift up}{NumpadDel}

else

send {blind}{NumpadDel}

return

/*

Sondertasten

*/

*space::

spacepressed := 1

else

goto neo_SpaceUp

return

*space up::

{

{

keypressed := 0

spacepressed := 0

neo_SpaceUp:

EbeneAktualisieren()

Send {blind}{Space}

Send {blind}{Space}

or CheckDeadUni("c5",0x2080)))

Send {blind}{NumPad0}

SendUnicodeChar(0x202F) ; schmales gesch�tztes Leerzeichen

spacepressed := 0

keypressed := 0

return

*/

*Enter::

{

send {Blind}{Enter}

}

return

*Backspace::

{

send {Blind}{Backspace}

}

return

*Del::

send {Blind}{Del}

return

*Ins::

send {Blind}{Ins}

return

/*

Auf Mod3+Tab liegt Compose.

*/

neo_tab:

{

DeadKey := "comp"

CompKey := ""

return

*Home::

{

send {Blind}{Home}

}

return

*End::

{

send {Blind}{End}

}

return

*PgUp::

{

send {Blind}{PgUp}

}

return

*PgDn::

{

send {Blind}{PgDn}

}

return

*Up::

{

send {Blind}{Up}

}

return

*Down::

{

send {Blind}{Down}

}

return

*Left::

{

send {Blind}{Left}

}

return

*Right::

{

send {Blind}{Right}

}

return

}

return

EbeneAktualisieren()

{

global

DeadKey := ""

CompKey := ""

Modstate := IsMod4Pressed() . IsMod3Pressed() . IsShiftPressed()

if ahkTreiberKombi

if ( Modstate = "001")

Ebene = 6

}

Ebene12 := ((Ebene = 1) or (Ebene = 2))

Ebene14 := ((Ebene = 1) or (Ebene = 4))

}

IsShiftPressed()

{

global

if GetKeyState("Shift","P")

return 0

else

return 1

else

return 1

else

return 0

}

IsMod3Pressed()

------------------------------------------------------

*/

Static h_device

If ! h_device ; initialise

SetUnicodeStrLED(fn,device)

h_device:=NtCreateFileLED(fn,0+0x00000100+0x00000080+0x00100000,1,1,0x00000040+0x00000020,0)

{

}

input=

}

Return, ( p_device_type << 16 ) | ( p_access << 14 ) | ( p_function << 2 ) | p_method

}

VarSetCapacity(fh,4,0)

VarSetCapacity(objattrib,24,0)

VarSetCapacity(io,8,0)

return ExtractIntegerLED(fh)

}

VarSetCapacity(st1, 8, 0)

InsertIntegerLED(0x530025, st1)

VarSetCapacity(out, (StrLen(str_)+1)*2, 0)

DllCall("wsprintfW", "str", out, "str", st1, "str", str_, "Cdecl UInt")

}

; 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 -(0xFFFFFFFF - result + 1)

}

; 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)

}

global

}

global

SendUnicodeChar(val)

}

global

else

}

global

send {bs}

}

global

undeadAsc(val)

return 1

}

global

undeadUni(val)

return 1

}

global

undeadAsc(val1)

return 1

undeadAsc(val2)

return 1

}

global

undeadUni(val1)

return 1

undeadUni(val2)

return 1

}

global

}

global

SendUnicodeChar(val)

}

global

}

uncompUni(val)

{

global

send {bs}

SendUnicodeChar(val)

}

uncomp3Uni(val)

{

global

send {bs}{bs}

SendUnicodeChar(val)

}

global

uncompAsc(val)

return 1

}

global

uncompAsc(val1)

return 1

uncompAsc(val2)

return 1

}

global

uncompUni(val)

return 1

}

global

uncompUni(val1)

return 1

uncompUni(val2)

return 1

}

global

uncomp3Uni(val)

return 1

}

global

uncomp3Uni(val1)

return 1

uncomp3Uni(val2)

return 1

}

global

c := val1

else

c := val2

send % "{blind}{Shift Up}" . c . "{Shift Down}"

else

send % "{blind}" . c

CompKey := c

}

BildschirmTastatur

------------------------------------------------------

*/

guiErstellt = 0

alwaysOnTop = 1

*F1::

goto Switch1

return

*F2::

goto Switch2

return

*F3::

goto Switch3

return

*F4::

goto Switch4

return

*F5::

goto Switch5

return

*F6::

goto Switch6

return

*F7::

goto Show

return

*F8::

goto ToggleAlwaysOnTop

return

Switch1:

goto Switch

Return

------------------------------------------------------

Methoden zum Senden von Unicode-Zeichen

------------------------------------------------------

�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.

*/

}

}

SetNumLockState AlwaysOff

/****************

* Verzeichnisse *

EnvGet, WindowsEnvAppDataFolder, APPDATA

ApplicationFolder = %WindowsEnvAppDataFolder%\NEO2

FileCreateDir, %ApplicationFolder%

/*******************

* Globale Schalter *

********************

*/

; Im folgenden gilt (soweit nicht anders angegeben) Ja = 1, Nein = 0:

; 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)?

; Soll der Treiber im Einhandmodus betrieben werden?

; Soll der Lernmodus aktiviert werden?

; Soll mit einer MsgBox explizit auf das Ein- und Ausschalten des Mod4-Locks hingewiesen werden?

; Soll aktivierter Mod4-Lock �ber die Rollen-LED des Keybord angezeigt werden (analog zu CapsLock)?

; Soll Lang-s auf s, s auf � und � auf Lang-s gelegt (bzw. vertauscht) werden?

; Sollen tote Tasten blind angezeigt werden?

;Sollen Compose-Tasten blind angezeigt werden?

/***********************

* Recourcen-Verwaltung *

************************

*/

; Versuche, alle m�glicherweise in die EXE eingebundenen Dateien zu extrahieren

}

; Benutze die Dateien auch dann, wenn sie eventuell im aktuellen Verzeichnis vorhanden sind

*/

{

suspend

(

Nicht kompatibles Tastaturlayout:

`t%inputlocale%

exitapp

}

*/

*/

;Blinde/Sichtbare Tote Tasten

*F9::

if (isMod4pressed())

else

send {blind}{F9}

return

;Blinde/Sichtbare Compose

*F10::

if (isMod4pressed())

else

send {blind}{F10}

return

;Lang-s-Tastatur:

*F11::

else

send {blind}{F11}

return

*Esc::

if (isMod4pressed())

reload

send {blind}{Esc}

return

*pause::

Suspend, Permit

return

togglesuspend:

return

help:

Run, %A_WinDir%\hh mk:@MSITStore:autohotkey.chm

return

about:

return

neo:

run http://neo-layout.org/

return

exitapp

return

; LShift+RShift == CapsLock (simuliert)

; Es werden nur die beiden Tastenkombinationen abgefragt,

}

return

EbeneAktualisieren()

{

global

DeadKey := ""

CompKey := ""

Modstate := IsMod4Pressed() . IsMod3Pressed() . IsShiftPressed()

if ahkTreiberKombi

if ( Modstate = "001")

Ebene = 6

}

Ebene12 := ((Ebene = 1) or (Ebene = 2))

Ebene14 := ((Ebene = 1) or (Ebene = 4))

}

IsShiftPressed()

{

global

if GetKeyState("Shift","P")

return 0

else

return 1

else

return 1

else

return 0

}

IsMod3Pressed()

Reihe 1

*/

neo_tot1:

EbeneAktualisieren()

deadUni(0x02C6) ; Zirkumflex, tot

deadUni(0x02C7) ; Caron, tot

deadUni(0x02D8) ; Brevis, tot

deadUni(0x00B7) ; Mittenpunkt, tot

deadUni(0x002D) ; Querstrich, tot

return

neo_1:

EbeneAktualisieren()

return

neo_2:

EbeneAktualisieren()

SendUnicodeChar(0x2116) ; Numero

SendUnicodeChar(0x00B2) ; Hochgestellte 2

SendUnicodeChar(0x2023) ; Aufz�hlungspfeil

SendUnicodeChar(0x26A5) ; Piktogramm Zwitter

SendUnicodeChar(0x2228) ; Logisches Oder

return

neo_3:

EbeneAktualisieren()

or CheckDeadUni("c5",0x2083)

SendUnicodeChar(0x00B3) ; Hochgestellte 3

SendUnicodeChar(0x2642) ; Piktogramm Mann

SendUnicodeChar(0x2227) ; Logisches Und

return

neo_4:

EbeneAktualisieren()

or CheckDeadUni("c5",0x2084)

SendUnicodeChar(0x00BB) ; Double guillemot right

Send {blind}{PgUp}

SendUnicodeChar(0x2113) ; Script small L

SendUnicodeChar(0x22A5) ; Senkrecht

return

neo_5:

EbeneAktualisieren()

or CheckDeadUni("c5",0x2085)

SendUnicodeChar(0x00AB) ; Double guillemot left

SendUnicodeChar(0x2020) ; Kreuz (Dagger)

SendUnicodeChar(0x2221) ; Winkel

return

neo_6:

EbeneAktualisieren()

or CheckDeadUni("c5",0x2086)

send {blind}�

send {blind}�

SendUnicodeChar(0x2225) ; parallel

return

neo_7:

EbeneAktualisieren()

or CheckDeadUni("c5",0x2087)

send {blind}�

send {blind}�

SendUnicodeChar(0x03BA) ; greek small letter kappa

SendUnicodeChar(0x2209) ; nicht Element von

return

neo_8:

EbeneAktualisieren()

or CheckDeadUni("c5",0x2088)

send {blind}�

Send {blind}{NumpadDiv}

SendUnicodeChar(0x27E8) ; bra (�ffnende spitze Klammer)

SendUnicodeChar(0x2204) ; es existiert nicht

return

neo_9:

EbeneAktualisieren()

or CheckDeadUni("c5",0x2089)

send {blind}�

Send {blind}{NumpadMult}

SendUnicodeChar(0x27E9) ; ket (schlie�ende spitze Klammer)

SendUnicodeChar(0x2226) ; nicht parallel

return

neo_0:

EbeneAktualisieren()

send {blind}�

Send {blind}{NumpadSub}

SendUnicodeChar(0x2205) ; leere Menge

return

neo_strich:

EbeneAktualisieren()

SendUnicodeChar(0x2013) ; Gedankenstrich

SendUnicodeChar(0x2014) ; Englischer Gedankenstrich (Geviertstrich)

SendUnicodeChar(0x2011) ; gesch�tzter Bindestrich (Bindestrich ohne Zeilenumbruch)

SendUnicodeChar(0x00AD) ; weicher Bindestrich

return

neo_tot2:

EbeneAktualisieren()

deadAsc("{�}{space}") ; Akut, tot

DeadKey := "a1"

DeadKey := "a2"

DeadKey := "a3"

DeadKey := "a4"

DeadKey := "a5"

DeadKey := "a6"

return

neo_x:

EbeneAktualisieren()

OutputChar("x","X")

return

neo_v:

EbeneAktualisieren()

OutputChar("v","V")

send {blind}_

Send {blind}{Backspace}

SendUnicodeChar(0x2259) ; estimates

return

neo_l:

EbeneAktualisieren()

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")

send {blind}[

Send {Blind}{Up}

SendUnicodeChar(0x03BB) ; lambda

SendUnicodeChar(0x039B) ; Lambda

return

neo_c:

EbeneAktualisieren()

or CheckDeadUni12("a3",0x00E7,0x00E6)

or CheckDeadUni12("a4",0x010B,0x010A)

or CheckDeadUni12("c1",0x0109,0x0108)

or CheckDeadUni12("c2",0x010D,0x010C)

or CheckCompAsc("o","�")))

OutputChar("c","C")

send {blind}]

Send {blind}{Del}

SendUnicodeChar(0x03C7) ; chi

SendUnicodeChar(0x2102) ; C (Komplexe Zahlen)

return

neo_w:

EbeneAktualisieren()

OutputChar("w","W")

SendUnicodeChar(0x005E) ; Zirkumflex

Send {blind}{Insert} ; Einfg

SendUnicodeChar(0x03C9) ; omega

SendUnicodeChar(0x03A9) ; Omega

return

neo_k:

EbeneAktualisieren()

or CheckDeadUni12("c6",0x1E33,0x1E32)))

OutputChar("k","K")

send {blind}{!}

Send �

SendUnicodeChar(0x221A) ; Wurzel

return

neo_h:

EbeneAktualisieren()

or CheckDeadUni12("c1",0x0125,0x0124)

or CheckDeadUni12("c5",0x0127,0x0126)

or CheckDeadUni12("c6",0x1E25,0x1E24)))

OutputChar("h","H")

send {blind}<

or CheckDeadUni("c5",0x2087)))

Send {blind}{NumPad7}

SendUnicodeChar(0x03C8) ; psi

SendUnicodeChar(0x03A8) ; Psi

return

neo_g:

EbeneAktualisieren()

or CheckDeadUni12("a4",0x0121,0x0120)

or CheckDeadUni12("c1",0x011D,0x011C)

or CheckDeadUni12("c3",0x011F,0x011E)))

OutputChar("g","G")

Send {blind}{NumPad8}

SendUnicodeChar(0x03B3) ; gamma

SendUnicodeChar(0x0393) ; Gamma

return

neo_f:

EbeneAktualisieren()

or CheckDeadUni12("t4",0x0192,0x0191)))

OutputChar("f","F")

send {blind}`=

or CheckDeadUni("c5",0x2089)))

send {blind}{NumPad9}

SendUnicodeChar(0x03C6) ; phi

SendUnicodeChar(0x03A6) ; Phi

return

neo_q:

EbeneAktualisieren()

OutputChar("q","Q")

send {blind}{&}

or CheckDeadUni("c5",0x208A)))

Send {blind}{NumPadAdd}

SendUnicodeChar(0x03D5) ; phi symbol (varphi)

SendUnicodeChar(0x211A) ; Q (rationale Zahlen)

return

neo_sz:

EbeneAktualisieren()

SendUnicodeChar(0x1E9E) ; versal-�

else if LangSTastatur

send {blind}s

else

send �

if LangSTastatur

send {blind}s

else

send �

else

SendUnicodeChar(0x1E9E) ; versal-�

if LangSTastatur

send �

else

SendUnicodeChar(0x017F) ; langes s

return

neo_tot3:

EbeneAktualisieren()

{

DeadKey := "t1"

}

{

DeadKey := "t2"

}

{

DeadKey := "t3"

}

{

DeadKey := "t4"

}

{

DeadKey := "t5"

}

{

DeadKey := "t6"

}

neo_u:

EbeneAktualisieren()

or CheckDeadUni12("a2",0x00F9,0x00D9)

or CheckDeadUni12("a5",0x0173,0x0172)

or CheckDeadUni12("a6",0x016F,0x016E)

or CheckDeadAsc12("t3","�","�")

or CheckDeadUni12("t5",0x0171,0x0170)))

OutputChar("u","U")

send {blind}\

Send {blind}{Home}

{

CompKey := PriorCompKey

DeadKey := PriorDeadKey

}

SendUnicodeChar(0x222E) ; contour integral

return

neo_i:

EbeneAktualisieren()

or CheckDeadUni12("a2",0x00EC,0x00CC)

or CheckDeadUni12("a4",0x012F,0x012E)

or CheckDeadUni12("a5",0x0131,0x0130)

or CheckDeadUni12("t2",0x012B,0x012A)

or CheckDeadAsc12("t3","�","�")))

OutputChar("i","I")

send {blind}`/

Send {Blind}{Left}

SendUnicodeChar(0x03B9) ; iota

SendUnicodeChar(0x222B) ; integral

return

neo_a:

EbeneAktualisieren()

OutputChar("a","A")

send {blind}{{}

Send {Blind}{Down}

SendUnicodeChar(0x03B1) ; alpha

SendUnicodeChar(0x2200) ; f�r alle

return

neo_e:

EbeneAktualisieren()

or CheckDeadUni12("a2",0x00E8,0x00C8)

or CheckDeadUni12("a4",0x0117,0x0116)

or CheckDeadUni12("a5",0x0119,0x0118)

or CheckCompAsc12("o","�","�")

or CheckCompAsc12("O","�","�")))

OutputChar("e","E")

send {blind}{}}

Send {Blind}{Right}

SendUnicodeChar(0x03B5) ; epsilon

SendUnicodeChar(0x2203) ; es existiert

return

neo_o:

EbeneAktualisieren()

or CheckDeadUni12("a2",0x00F2,0x00D2)

or CheckDeadUni12("a5",0x01EB,0x01EA)

or CheckDeadUni12("c1",0x00F4,0x00D4)

or CheckDeadUni12("t4",0x00F8,0x00D8)

or CheckDeadUni12("t5",0x0151,0x0150)))

OutputChar("o","O")

send {blind}*

Send {blind}{End}

SendUnicodeChar(0x03BF) ; omicron

SendUnicodeChar(0x2208) ; element of

return

neo_s:

EbeneAktualisieren()

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 LangSTastatur

{

send {blind}s

Compkey := "s"

}

else

{

SendUnicodeChar(0x017F) ;langes S

CompKey := "lang_s"

}

else

{

send {blind}s

CompKey := "s"

}

}

{

if LangSTastatur

{

SendUnicodeChar(0x017F) ;langes S

CompKey := "lang_s"

}

else

{

send {blind}S

CompKey := "s"

}

else

{

send {blind}S

CompKey := "S"

}

}

}

send {blind}?

Send �

SendUnicodeChar(0x03C3) ;sigma

SendUnicodeChar(0x03A3) ;Sigma

return

neo_n:

EbeneAktualisieren()

or CheckDeadUni12("a3",0x0146,0x0145)

or CheckDeadUni12("a4",0x1E45,0x1E44)

or CheckDeadUni12("c2",0x0148,0x0147)

or CheckDeadUni12("t1",0x00F1,0x00D1)))

OutputChar("n","N")

send {blind}(

or CheckDeadUni("c5",0x2084)))

Send {blind}{NumPad4}

SendUnicodeChar(0x03BD) ; nu

SendUnicodeChar(0x2115) ; N (nat�rliche Zahlen)

return

neo_r:

EbeneAktualisieren()

or CheckDeadUni12("a3",0x0157,0x0156)

or CheckDeadUni12("a4",0x0E59,0x0E58)

or CheckDeadUni12("c2",0x0159,0x0158)

or CheckCompAsc12("o","�","�")

or CheckCompAsc12("O","�","�")))

OutputChar("r","R")

send {blind})

or CheckDeadUni("c5",0x2085)))

Send {blind}{NumPad5}

SendUnicodeChar(0x03F1) ; rho symbol (varrho)

SendUnicodeChar(0x211D) ; R (reelle Zahlen)

return

neo_t:

EbeneAktualisieren()

or CheckDeadUni12("a4",0x1E6B,0x1E6A)

or CheckDeadUni12("c2",0x0165,0x0164)

or CheckDeadUni12("c5",0x0167,0x0166)

or CheckDeadUni12("c6",0x1E6D,0x1E6C)))

OutputChar("t","T")

send {blind}- ; Bisstrich

or CheckDeadUni("c5",0x2086)))

Send {blind}{NumPad6}

SendUnicodeChar(0x03C4) ; tau

SendUnicodeChar(0x2202) ; partielle Ableitung

return

neo_d:

EbeneAktualisieren()

or CheckDeadUni12("c2",0x010F,0x010E)

or CheckDeadUni12("c5",0x0111,0x0110)

or CheckDeadUni12("c6",0x1E0D,0x1E0C)

or CheckDeadUni12("t4",0x00F0,0x00D0)))

OutputChar("d","D")

send {blind}:

send `,

SendUnicodeChar(0x03B4) ; delta

SendUnicodeChar(0x0394) ; Delta

return

neo_y:

EbeneAktualisieren()

or CheckDeadUni12("c1",0x0177,0x0176)

or CheckDeadAsc12("t3","�","�")))

OutputChar("y","Y")

send {blind}@

Send {blind}.

SendUnicodeChar(0x03C5) ; upsilon

SendUnicodeChar(0x2207) ; nabla

return

neo_�:

EbeneAktualisieren()

or CheckDeadUni12("a2",0x01DC,0x01DB)

or CheckDeadUni12("c2",0x01DA,0x01D9)

or CheckDeadUni12("t2",0x01D6,0x01D5)))

OutputChar("�","�")

send {#}

Send {blind}{Esc}

{

DeadKey := PriorDeadKey

CompKey := PriorCompKey

}

SendUnicodeChar(0x221D) ; proportional

return

neo_�:

EbeneAktualisieren()

OutputChar("�","�")

send {blind}$

send {blind}{Tab}

{

DeadKey := PriorDeadKey

CompKey := PriorCompKey

} ; leer

SendUnicodeChar(0x2111) ; Fraktur I

return

neo_�:

EbeneAktualisieren()

OutputChar("�","�")

send {blind}|

SendUnicodeChar(0x03B7) ; eta

SendUnicodeChar(0x211C) ; Fraktur R

return

neo_p:

EbeneAktualisieren()

OutputChar("p","P")

send {blind}~

Send {blind}{Enter}

SendUnicodeChar(0x03C0) ; pi

SendUnicodeChar(0x03A0) ; Pi

return

neo_z:

EbeneAktualisieren()

or CheckDeadUni12("a4",0x017C,0x017B)

or CheckDeadUni12("c2",0x017E,0x017D)

or CheckDeadUni12("c6",0x1E93,0x1E92)))

OutputChar("z","Z")

{

DeadKey := PriorDeadKey

CompKey := PriorCompKey

} ; leer

SendUnicodeChar(0x03B6) ; zeta

SendUnicodeChar(0x2124) ; Z (ganze Zahlen)

return

neo_b:

EbeneAktualisieren()

OutputChar("b","B")

send {blind}{+}

send {blind}:

SendUnicodeChar(0x03B2) ; beta

SendUnicodeChar(0x21D2) ; Doppel-Pfeil rechts

return

neo_m:

EbeneAktualisieren()

or CheckDeadUni12("c6",0x1E43,0x1E42)

or CheckCompUni12("t",0x2122,0x2122) ; TM

or CheckCompUni12("s",0x2120,0x2120))) ; SM

OutputChar("m","M")

send {blind}`%

or CheckDeadUni("c5",0x2081)))

Send {blind}{NumPad1}

SendUnicodeChar(0x03BC) ; griechisch mu, micro w�re 0x00B5

SendUnicodeChar(0x21D4) ; doppelter Doppelpfeil (genau dann wenn)

return

neo_komma:

EbeneAktualisieren()

send {blind}{Shift down},{Shift up}

else

send {blind},

send {blind}"

or CheckDeadUni("c5",0x2082)))

Send {blind}{NumPad2}

SendUnicodeChar(0x03C1) ; rho

SendUnicodeChar(0x21D0) ; Doppelpfeil links

return

neo_punkt:

EbeneAktualisieren()

send {blind}{Shift down}.{Shift up}

else

send {blind}.

send {blind}'

or CheckDeadUni("c5",0x2083)))

Send {blind}{NumPad3}

SendUnicodeChar(0x03D1) ; theta symbol (vartheta)

SendUnicodeChar(0x0398) ; Theta

return

neo_j:

EbeneAktualisieren()

or CheckDeadUni12("c2",0x01F0,"")

or CheckCompUni("i",0x0133) ; ij

or CheckCompUni("l",0x01C9) ; lj

or CheckCompUni12("L",0x01C8,0x01C7) ; Lj/LJ

or CheckCompUni12("N",0x01CB,0x01CA))) ; Nj/NJ

OutputChar("j","J")

send {blind}`;

Send {blind}`;

SendUnicodeChar(0x03B8) ; theta

SendUnicodeChar(0x2261) ; identisch

return

neo_NumLock:

EbeneAktualisieren()

send `=

{

SetNumLockState

send {NumLock}

}

SendUnicodeChar(0x2248) ; Fast gleich

SendUnicodeChar(0x2260) ; Ungleich zu

return

EbeneAktualisieren()

if Ebene14

send {blind}{NumpadDiv}

send {blind}�

return

EbeneAktualisieren()

if Ebene14

send {blind}{NumpadMult}

send {blind}�

return

neo_NumpadSub:

EbeneAktualisieren()

or CheckDeadUni("c5",0x208B)))

send {blind}{NumpadSub}

SendUnicodeChar(0x2212) ; Echtes Minus

return

neo_NumpadAdd:

EbeneAktualisieren()

or CheckDeadUni("c5",0x208A)))

send {blind}{NumpadAdd}

send {blind}�

return

neo_NumpadEnter:

neo_Numpad7:

EbeneAktualisieren()

{

if NumLock

send {blind}{Numpad7}

else

send {blind){Shift up}{Numpad7}

CompKey := "7"

}

SendUnicodeChar(0x2020) ; Kreuz

SendUnicodeChar(0x2195) ; Hoch-Runter-Pfeil

if NumLock

send {blind}{Shift up}{NumpadHome}

else

neo_Numpad8:

EbeneAktualisieren()

or CheckCompUni("3",0x215C) ; 3/8

or CheckCompUni("5",0x215D) ; 5/8

or CheckCompUni("7",0x215E))) ; 7/8

send {blind}{Numpad8}

else

send {blind){Shift up}{Numpad8}

CompKey := "8"

}

SendUnicodeChar(0x2229) ; Durchschnitt

SendUnicodeChar(0x2191) ; Hochpfeil

if NumLock

send {blind}{Shift up}{NumpadUp}

else

neo_Numpad9:

EbeneAktualisieren()

{

if NumLock

send {blind}{Numpad9}

else

send {blind){Shift up}{Numpad9}

CompKey := "9"

}

SendUnicodeChar(0x2297) ; Tensorprodukt / Vektor in die Ebene zeigend

SendUnicodeChar(0x220D) ; Kleines umgekehrtes Elementzeichen

if NumLock

send {blind}{Shift up}{NumpadPgUp}

else

neo_Numpad4:

EbeneAktualisieren()

or CheckCompUni("3",0x00BE))) ; 3/4

{

if NumLock

send {blind}{Numpad4}

else

send {blind){Shift up}{Numpad4}

CompKey := "4"

}

SendUnicodeChar(0x2282) ; Teilmenge

SendUnicodeChar(0x2190) ; Linkspfeil

if NumLock

send {blind}{Shift up}{NumpadLeft}

else

neo_Numpad5:

EbeneAktualisieren()

or CheckCompUni("2",0x2156) ; 2/5

or CheckCompUni("3",0x2157) ; 3/5

or CheckCompUni("4",0x2158))) ; 4/5

send {blind}{Numpad5}

else

send {blind){Shift up}{Numpad5}

CompKey := "5"

}

SendUnicodeChar(0x221E) ; Unendlich

SendUnicodeChar(0x20AC) ; Euro

if NumLock

send {NumPad5}

else

neo_Numpad6:

EbeneAktualisieren()

or CheckCompUni("5",0x215a))) ; 5/6

{

if NumLock

send {blind}{Numpad6}

else

send {blind){Shift up}{Numpad6}

CompKey := "6"

}

SendUnicodeChar(0x2283) ; Obermenge

SendUnicodeChar(0x2192) ; Rechtspfeil

if NumLock

send {blind}{Shift up}{NumpadRight}

else

neo_Numpad1:

EbeneAktualisieren()

{

if NumLock

send {blind}{Numpad1}

else

send {blind){Shift up}{Numpad1}

CompKey := "1"

}

SendUnicodeChar(0x2714) ; H�kchen

SendUnicodeChar(0x2194) ; Links-Rechts-Pfeil

if NumLock

send {blind}{Shift up}{NumpadEnd}

else

neo_Numpad2:

EbeneAktualisieren()

{

if NumLock

send {blind}{Numpad2}

else

send {blind){Shift up}{Numpad2}

CompKey := "2"

}

SendUnicodeChar(0x222A) ; Vereinigung

SendUnicodeChar(0x2192) ; Untenpfeil

if NumLock

send {blind}{Shift up}{NumpadDown}

else

neo_Numpad3:

EbeneAktualisieren()

or CheckCompUni("5",0x2154))) ; 2/3

{

if NumLock

send {blind}{Numpad3}

else

send {blind){Shift up}{Numpad3}

CompKey := "3"

}

SendUnicodeChar(0x2718) ; Kreuzchen

SendUnicodeChar(0x2192) ; Rechtspfeil

if NumLock

send {blind}{Shift up}{NumpadPgDn}

else

neo_Numpad0:

EbeneAktualisieren()

{

if NumLock

send {blind}{Numpad0}

else

send {blind){Shift up}{Numpad0}

CompKey := "0"

}

SendUnicodeChar(0x2030) ; Promille

SendUnicodeChar(0x0025) ; Prozent

if NumLock

send {blind}{Shift up}{NumpadIns}

else

neo_NumpadDot:

EbeneAktualisieren()

{

if NumLock

send {blind}{NumpadDot}

else

send {blind){Shift up}{NumpadDot}

}

send `,

send {blind}.

if NumLock

send {blind}{Shift up}{NumpadDel}

else

send {blind}{NumpadDel}

return

/*

Sondertasten

*/

*space::

spacepressed := 1

else

goto neo_SpaceUp

return

*space up::

{

{

keypressed := 0

spacepressed := 0

neo_SpaceUp:

EbeneAktualisieren()

Send {blind}{Space}

else if ((Ebene = 2) or (Ebene = 3))

Send {blind}{Space}

or CheckDeadUni("c5",0x2080)))

Send {blind}{NumPad0}

SendUnicodeChar(0x00A0) ; gesch�tztes Leerzeichen

DeadKey := "" CompKey := ""

spacepressed := 0

keypressed := 0

*/

*Enter::

{

send {Blind}{Enter}

DeadKey := "" CompKey := ""

return

*Backspace::

{

send {Blind}{Backspace}

DeadKey := "" CompKey := ""

}

return

*Del::

send {Blind}{Del}

return

*Ins::

send {Blind}{Ins}

return

/*

Auf Mod3+Tab liegt Compose.

*/

neo_tab:

{

DeadKey := "comp"

CompKey := ""

return

*Home::

{

send {Blind}{Home}

DeadKey := "" CompKey := ""

return

*End::

{

send {Blind}{End}

DeadKey := "" CompKey := ""

return

*PgUp::

{

send {Blind}{PgUp}

DeadKey := "" CompKey := ""

return

*PgDn::

{

send {Blind}{PgDn}

DeadKey := "" CompKey := ""

return

*Up::

{

send {Blind}{Up}

DeadKey := "" CompKey := ""

return

*Down::

{

send {Blind}{Down}

DeadKey := "" CompKey := ""

return

*Left::

{

send {Blind}{Left}

DeadKey := "" CompKey := ""

return

*Right::

{

send {Blind}{Right}

DeadKey := "" CompKey := ""

}

return

/*

------------------------------------------------------

Methode KeyboardLED zur Steuerung der Keyboard-LEDs

------------------------------------------------------

*/

Static h_device

If ! h_device ; initialise

SetUnicodeStrLED(fn,device)

h_device:=NtCreateFileLED(fn,0+0x00000100+0x00000080+0x00100000,1,1,0x00000040+0x00000020,0)

{

}

input=

}

Return, ( p_device_type << 16 ) | ( p_access << 14 ) | ( p_function << 2 ) | p_method

}

VarSetCapacity(fh,4,0)

VarSetCapacity(objattrib,24,0)

VarSetCapacity(io,8,0)

return ExtractIntegerLED(fh)

}

VarSetCapacity(st1, 8, 0)

InsertIntegerLED(0x530025, st1)

VarSetCapacity(out, (StrLen(str_)+1)*2, 0)

DllCall("wsprintfW", "str", out, "str", st1, "str", str_, "Cdecl UInt")

}

; 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 -(0xFFFFFFFF - result + 1)

}

; 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)

}

global

}

global

SendUnicodeChar(val)

}

global

else

}

global

send {bs}

}

global

undeadAsc(val)

return 1

}

global

undeadUni(val)

return 1

}

global

undeadAsc(val1)

return 1

undeadAsc(val2)

return 1

}

global

undeadUni(val1)

return 1

undeadUni(val2)

return 1

}

global

}

global

SendUnicodeChar(val)

}

global

}

uncompUni(val)

{

global

send {bs}

SendUnicodeChar(val)

}

uncomp3Uni(val)

{

global

send {bs}{bs}

SendUnicodeChar(val)

}

global

uncompAsc(val)

return 1

}

global

uncompAsc(val1)

return 1

uncompAsc(val2)

return 1

}

global

uncompUni(val)

return 1

}

global

uncompUni(val1)

return 1

uncompUni(val2)

return 1

}

global

uncomp3Uni(val)

return 1

}

global

uncomp3Uni(val1)

return 1

uncomp3Uni(val2)

return 1

}

global

c := val1

else

c := val2

send % "{blind}{Shift Up}" . c . "{Shift Down}"

else

send % "{blind}" . c

CompKey := c

}

/*

------------------------------------------------------

Methoden zum Senden von Unicode-Zeichen

------------------------------------------------------

�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.

*/

}

}

/*

BildschirmTastatur

------------------------------------------------------

*/

guiErstellt = 0

alwaysOnTop = 1

*F1::

goto Switch1

return

*F2::

goto Switch2

return

*F3::

goto Switch3

return

*F4::

goto Switch4

return

*F5::

goto Switch5

return

*F6::

goto Switch6

return

*F7::

goto Show

return

*F8::

goto ToggleAlwaysOnTop

return

Switch1:

goto Switch

Return