Layoutkorrigeraren "xswitcher" för linux: steg två

Eftersom föregående publikation (xswitcher i "proof of concept"-stadiet) har fått en hel del konstruktiv feedback (vilket är trevligt), jag fortsatte att spendera min fritid på att utveckla projektet. Nu vill jag spendera lite av er… Det andra steget kommer att vara ganska ovanligt: förslag/diskussion om konfigurationens design.

Det verkar stå så till att det är djupt tråkigt för normala programmerare att ställa in alla dessa kontroller.

För att inte vara orolig har jag ett exempel här på vad jag jobbar med.
Utmärkt genomtänkt (och väl genomfört) Apache Kafka & ZooKeeper.
— Konfiguration? Men det är så tråkigt! Slänga ihop xml (eftersom det är "ur lådan").
— Åh, vill ni också ha ACL? Men det är så komplicerat! Slänga ihop… Sådant.

Men i mitt arbete är det precis tvärtom. Rätt (tyvärr är det nästan aldrig korrekt från första gången) den byggda modellen tillåter enkelt och obehindrat vidare (nåja, nästan) att samla schemat.

Jag snubblade nyligen över en artikel på Habré om det tuffa arbetet hos data-scientister…
Det visar sig att den aspekten är fullt realiserad hos dem. Men i min praktik, som man brukar säga, "light-versionen". Mångfacetterade modeller, erfarna programmerare med OOP i bakgrunden osv. — det kommer senare, när/om det tar fart. Men byggaren måste börja här och nu.

Låt oss komma till saken. Som syntaktisk grund tog jag TOML från denna medborgare.

För att han (TOML) å ena sidan är människovänlig redigerbar. Å andra sidan översätts han 1:1 till vilken av de mer vanliga syntakterna: XML, JSON, YAML.
Mer än så, min implementering från "github.com/BurntSushi/toml" även om den inte är den mest trendiga (fortfarande syntax 1.4), är syntaxmässigt kompatibel med samma ("inbyggda") JSON.

Det vill säga, om man så önskar kan man enkelt säga "gå bort med din TOML, jag vill ha XXX" och "patcha" koden med bara en rad.

Därmed, om man vill skriva något för att ställa in xswitcher (definitivt inte jag) problem "med er jäkla config" — förväntas inte.

För alla andra är syntaxen baserad på "nyckel = värde" (och bokstavligen med ett par svårare alternativ, typ = [någon, sorts, array]) tror jag
är intuitivt användbar.
Vad som är intressant är att han själv "brann upp" ungefär vid samma tid (runt 2013). Men till skillnad från mig, så kom TOML:s skapare in med rätt stor kraft.

Därför är det nu enklare för mig att anpassa dess implementering åt mig själv, istället för tvärtom.

I stort sett tar vi TOML (mycket lik den gamla Windows INI). Och vi sätter upp en konfiguration där vi beskriver hur vi kopplar en serie hooks beroende på den senaste uppsättningen skenkoder från tangentbordet. Nedan i stycken – det här är vad som hittills har gjorts. Och förklaringar till varför jag har beslutat så.

0. Grundläggande abstraktioner

• Beteckningar för skenkoder. Det här måste definitivt göras något åt, eftersom de bara numeriska koderna är helt otydliga för människor (det är vad jag menar). loloswitcher).
  Jag har extraherat «ecodes.go» från «golang-evdev» (jag orkade inte kolla källan, även om den anges kulturellt av författaren). Jag har lite (för tillfället) justerat det som är riktigt ful. Typ «LEFTBRACE» → «L_BRACE».
• Dessutom har jag introducerat begreppet «tangenter med tillstånd». Eftersom den använda reguljära grammatiken inte tillåter längre passager. (Men det gör att man kan kontrollera med minimala overhead. Om man bara använder «direkt» inspelning.)
• Det kommer att finnas en inbyggd «deduplicator» för tryckta tangenter. På så sätt kommer tillståndet «upprepning»=2 att registreras. en gånger ner.

1. Mallsavsnitt

[Templates] # "@name@" för att förenkla uttryck
 # Ord kan bestå av dessa tecken (regex)
 "WORD" = "([0-9A-Z`;']|[LR]_BRACE|COMMA|DOT|SLASH|KP[0-9])"

Vad består ett ord i mänskligt språk av med fonetisk skrivning (till skillnad från grafemer aka «tecken»)? Какая-то ужасная «простыня». Поэтому сразу закладываю понятие «шаблона».

2. Vad göra när något trycks på (kom en ny skenkod)

[ActionKeys]
 # Samla nycklar och testa för kommandosekvens
 # !!! Upprepade koder (code=2) måste samlas in en gång per tangent!
 Add = ["1..0", "=", "BS", "Q..]", "L_CTRL..CAPS", "N_LOCK", "S_LOCK",
        "KP7..KPDOT", "R_CTRL", "KPSLASH", "R_ALT", "KPEQUAL..PAUSE",
        "KPCOMMA", "L_META..COMPOSE", "KPLEFTPAREN", "KPRIGHTPAREN"]

 # Droppa alla insamlade tangenter, inklusive denna. Detta är standardåtgärd.
 Drop = ["ESC", "-", "TAB", "ENTER", "KPENTER", "LINEFEED..POWER"]
 # Lagra extra karta för dessa tangenter, när någon är i «down»-läge.
 # Tillståndet kontrolleras via "OFF:"|"ON:" villkor i åtgärden.
 # (Dessutom måste tillståndet för dessa tangenter bestå mellan buffertdroppar.)
 # ??? Hur hanterar man CAPS och «LOCK»-tangenter ???
 StateKeys = ["L_CTRL", "L_SHIFT", "L_ALT", "L_META", "CAPS", "N_LOCK", "S_LOCK",
              "R_CTRL", "R_SHIFT", "R_ALT", "R_META"]

 # Testa endast, men samla inte in.
 # Exempelvis, jag använder F12 istället för BREAK på dumma bärbara datorer med dåliga tangentbord (nya ThinkPads)
 Test = ["F1..F10", "ZENKAKUHANKAKU", "102ND", "F11", "F12",
          "RO..KPJPCOMMA", "SYSRQ", "SCALE", "HANGEUL..YEN",
          "STOP..SCROLLDOWN", "NEW..MAX"]

Totalt finns det 768 koder. (Men «för säkerhets skull» lade jag in en fångst av «överraskningar» i koden).
Inuti har jag sammanställt en array med hänvisningar till funktionerna «vad man ska göra». På golang är detta (överraskande nog) visade sig vara praktiskt och uppenbart.

• Jag planerar att minimera «Drop» här. Till förmån för en mer flexibel bearbetning (se nedan).

3. Tabell med klassnamn för fönster

# Some behaviour can depend on application currently doing the input.
[[WindowClasses]]
 # VNC, VirtualBox, qemu etc. emulates there input independently, so never intercept.
 # With the exception of some stupid VNC clients, which does high-level (layout-based) keyboard input.
 Regex = "^VirtualBox"
 Actions = "" # Do nothing while focus stays in VirtualBox

[[WindowClasses]]
 Regex = "^konsole"
 # In general, mouse clicks leads to unpredictable (at the low-level where xswitcher resides) cursor jumps.
 # So, it's good choise to drop all buffers after click.
 # But some windows, e.g. terminals, can stay out of this problem.
 MouseClickDrops = 0
 Actions = "Actions"

[[WindowClasses]] # Default behaviour: no Regex (or wildcard like ".")
 MouseClickDrops = 1
 Actions = "Actions"

Raderna i tabellen — inom dubbla hakparenteser med dess namn. Det var svårt att få till det från början. Beroende på det aktuella aktiva fönstret kan alternativ väljas:

• Egen uppsättning av «hotkeys» «Actions = …». Om det inte finns/på blank — gör ingenting.
• Ombrytaren «MouseClickDrops» — vad som ska göras vid registrering av ett musklick. Eftersom det inte finns några detaljer om «var de klickar» i xswitcher, återställs bufferten som standard. Men på terminaler kan man kanske hoppa över det. (som regel).

4. En (eller flera) trycksekvenser aktiverar en viss hook

# action = [ regex1, regex2, ... ]
# "CLEAN" state: all keys are released
[Actions]
# Inverse regex is hard to understand, so extract negation to external condition.
# Expresions will be checked in direct order, one-by-one. Condition succceds when ALL results are True.
 # Maximum key sequence length, extra keys will be dropped. More length - more CPU.
 SeqLength = 8
 # Drop word buffer and start collecting new one
 NewWord = [ "OFF:(CTRL|ALT|META)  SEQ:(((BACK)?SPACE|[LR]_SHIFT):[01],)*(@WORD@:1)", # "@WORD@:0" then collects the char
             "SEQ:(@WORD@:2,@WORD@:0)", # Drop repeated char at all: unlikely it needs correction
             "SEQ:((KP)?MINUS|(KP)?ENTER|ESC|TAB)" ] # Be more flexible: chars line "-" can start new word, but must not completelly invalidate buffer!
 # Drop all buffers
 NewSentence = [ "SEQ:(ENTER:0)" ]

 # Single char must be deleted by single BS, so there is need in compose sequence detector.
 Compose = [ "OFF:(CTRL|L_ALT|META|SHIFT)  SEQ:(R_ALT:1,(R_ALT:2,)?(,@WORD@:1,@WORD@:0){2},R_ALT:0)" ]

 "Action.RetypeWord" = [ "OFF:(CTRL|ALT|META|SHIFT)  SEQ:(PAUSE:0)" ]
 "Action.CyclicSwitch" = [ "OFF:(R_CTRL|ALT|META|SHIFT)  SEQ:(L_CTRL:1,L_CTRL:0)" ] # Single short LEFT CONTROL
 "Action.Respawn" = [ "OFF:(CTRL|ALT|META|SHIFT)  SEQ:(S_LOCK:2,S_LOCK:0)" ] # Long-pressed SCROLL LOCK

 "Action.Layout0" = [ "OFF:(CTRL|ALT|META|R_SHIFT)  SEQ:(L_SHIFT:1,L_SHIFT:0)" ] # Single short LEFT SHIFT
 "Action.Layout1" = [ "OFF:(CTRL|ALT|META|L_SHIFT)  SEQ:(R_SHIFT:1,R_SHIFT:0)" ] # Single short RIGHT SHIFT

 "Action.Hook1" = [ "OFF:(CTRL|R_ALT|META|SHIFT)  SEQ:(L_ALT:1,L_ALT:0)" ]

Jag har delat upp hooks i två typer. Inbyggda med «talar» namn (NewWord, NewSentence, Compose) och programmerbara.

Namn på programmerbara börjar med «Action.». Eftersom TOML v1.4, ska namn med punkter vara inom citationstecken.

Nedan ska varje antecknas med en avsnitt med samma namn.

För att inte överväldiga folk med «nakna» reguljära uttryck (från erfarenhet, deras skriva-det kan vara en av tio yrkesverksamma), introducerar jag genast en extra syntax.

• «OFF:» (eller «ON:») före regexp (reguljärt uttryck) kräver att de angivna knapparna ska vara släppta (eller tryckta).
  Därefter planerar jag att skapa ett «orättvist» reguljärt uttryck. Med separat verifiering av segment mellan rörledningar "|". För att minska antalet postningar som "[LR]_SHIFT" (där det uppenbarligen inte behövs).
• «SEQ:» Om det föregående villkoret är uppfyllt (eller saknas), kontrolleras det gällande det «vanliga» reguljära uttrycket. För detaljer hänvisar jag direkt till biblioteks «regexp». För jag har fortfarande inte lyckats ta reda på graden av kompatibilitet med mina favoritpcre («perl compatible»).
• Uttrycket skrivs som «KNAPP_1: KOD1, KNAPP_2: KOD2» och så vidare, i ordning av inkommande skenkoder.
• Kontrollen är alltid «tryckt» mot slutet av sekvensen, så därför behöver inget "$» läggas till i slutet.
• Alla kontroller i en rad utförs i följd och kombineras med «OCH». Men eftersom värdet är beskrivet som en array kan en alternativ kontroll skrivas efter kommatecknet. Om det behövs av någon anledning.
• Värde «SeqLength = 8» begränsar storleken på bufferten, i förhållande till vilken alla kontroller utförs. Eftersom jag (inte än) har stött på oändliga resurser i mitt liv.

5. Uppgiftshämtning som beskrivits i föregående avsnitt

# Action is the array, so actions could be chained (m.b., infinitely... Have I to check this?).
# For each action type, extra named parameters could be collected. Invalid parameters will be ignored(?).
[Action.RetypeWord] # Switch layout, drop last word and type it again
 Action = [ "Action.CyclicSwitch", "RetypeWord" ] # Call Switch() between layouts tuned below, then RetypeWord()

[Action.CyclicSwitch] # Cyclic layout switching
 Action = [ "Switch" ] # Internal layout switcher func
 Layouts = [0, 1]

[Action.Layout0] # Direct layout selection
 Action = [ "Layout" ] # Internal layout selection func
 Layout = 0

[Action.Layout1] # Direct layout selection
 Action = [ "Layout" ] # Internal layout selection func
 Layout = 1

[Action.Respawn] # Completely respawn xswitcher. Reload config as well
 Action = [ "Respawn" ]

[Action.Hook1] # Run external commands
  Action = [ "Exec" ]
  Exec = "/path/to/exec -a -b --key_x"
  Wait = 1
  SendBuffer = "Word" # External hook can process collected buffer by it's own means.

Det viktiga här är — «Action = [Array]». På samma sätt som i föregående avsnitt finns det en begränsad uppsättning inbyggda åtgärder. Och en i princip obegränsad möjlighet till koppling (att skriva «Action.XXX» och inte vara lat nog att beskriva en ytterligare sektion för den).
Inklusive, att omkonfigurera ordet i den korrekta layouten är uppdelat i två delar: «ändra layout som angivet där borta» och «omskriv» («RetypeWord»).

Övriga parametrar skrivs in i en «ordbok» («map» i golang) för denna åtgärd, deras lista beror på vad som skrivs i «Action».

Flera olika åtgärder kan beskrivas i ett enda block (sektioner). Och man kan dela upp dem. Som jag visade ovan.

Jag lägger omedelbart in åtgärden «Exec» — utföra ett externt skript. Med alternativet att matas in i stdin en inspelad buffert.

• «Wait = 1» — vänta på att den startade processen ska avslutas.
• Förmodligen, «dessutom» vill man ställa in ytterligare information i miljön, som namn på fönsterklassen från vilken det har fångats.
  «Vill du ansluta din egen handler? Du går hit.»

Puh (lättat). Verkar som jag inte glömde något.

Oj! Ja, jag glömde inte…
Men var är startkonfigurationen? I hard-koden? Ungefär så här:

[ScanDevices]
 # Måste finnas vid start. Självrestarts om den är yngre än 30 sekunder
 Test = "/dev/input/event0"
 Respawn = 30
 # Sökmask
 Search = "/dev/input/event*"
 # I mina thinkPads finns det sådana pseudo-tangentbord med massor av onödiga händelser
 Bypass = "(?i)Video|Camera" # "(?i)" skiljer sig tydligt från "klassisk" pcre.

Och var glömde/eller gjorde jag fel (utan detta — inget), hoppas jag verkligen att uppmärksamma läsare inte tvekar att peka med näsan.

Lycka till!

Källa: habr.com