Switch to keysyms for Esc/Backspace etc. to be layout-independent

gui.py

@@ -3,17 +3,17 @@
 import sys
 
 from completer import PyMenuCompletions
-from utils import hextorgb, convert_code
+from utils import hextorgb, code_to_sym, sym_to_char
 
 class KeyCodes:
 
-    Backspace = 22
-    Enter     = 36
-    Esc       = 9
-    Left      = 113
-    Right     = 114
-    Space     = 65
-    Tab       = 23
+    Backspace = 65288
+    Enter     = 65293
+    Esc       = 65307
+    Left      = 65361
+    Right     = 65363
+    Space     = 32
+    Tab       = 65289
 
 class PyMenuGUI:
 
@@ -65,33 +65,34 @@ def __init__(self, model):
         self.eventloop()
 
     def precomplete(self, event):
-        keycode = event.detail
-        key = convert_code(self.disp, keycode, event.state)
-        if keycode == KeyCodes.Enter:
+        keysym = code_to_sym(self.disp, event.detail, event.state)
+        char = sym_to_char(self.disp, keysym)
+
+        if keysym == KeyCodes.Enter:
             self.setPrompt(self.model.getCurrent()[self.active])
             self.run()
-        elif keycode == KeyCodes.Esc:
+        elif keysym == KeyCodes.Esc:
             self.exit()
-        elif keycode == KeyCodes.Space:
+        elif keysym  == KeyCodes.Space:
             self.setPrompt(self.model.getCurrent()[self.active]+" ")
             self.active = 0
             self.step += 1
-        elif keycode == KeyCodes.Tab:
+        elif keysym == KeyCodes.Tab:
             self.setPrompt(self.model.getCurrent()[self.active]+" ")
             self.active = 0
             self.step += 1
             self.complete()
-        elif keycode == KeyCodes.Backspace:
+        elif keysym == KeyCodes.Backspace:
             self.setPrompt(self.getPrompt()[:-1])
             self.complete()
-        elif keycode in [KeyCodes.Left, KeyCodes.Right]:
+        elif keysym in [KeyCodes.Left, KeyCodes.Right]:
             if keycode == KeyCodes.Right:
                 self.active = (self.active + 1) % self.displayed
             else:
                 self.active = max(0, self.active - 1)
             self.refill(self.model.complete(self.prompt))
-        elif key:
-            self.setPrompt(self.getPrompt()+key)
+        elif keysym and char:
+            self.setPrompt(self.getPrompt()+char)
             self.complete()
 
     def eventloop(self):

utils.py

@@ -5,30 +5,39 @@ def hextorgb(hx):
         rgb.append((int('0x'+hx[i:i+2], 0)+1)*256-1)
     return rgb
 
+# TODO: Check if this works for none-QWERTZ-layouts
 def get_level(state):
     active = []
+    # The state we get from the keyboard-event is actually a mask
+    # Let's see which of its 12 bits are active
     for exp in reversed(range(0, 12+1)):
         if state == 0:
             break
         if state < 1<<exp:
             continue
         state = state % (1<<exp)
-        active.append(exp)
+        active.append(exp+1)
     level = 0
     modjump = False
+    # For those active bits, calculate the level
+    # modN-keys are bits > 3. They set a value
+    # bits 0-3 increment this value
+    # The final level is the key-lookup-level
     for mod in active:
         if mod > 3:
             if modjump:
                 continue
-            level += mod-3
+            level += mod-4
             modjump = True
         else:
-            level += mod+1
+            level += mod
     return level
 
-def convert_code(display, keycode, state):
-    level = get_level(state)
-    keysym = display.keycode_to_keysym(keycode, level)
+def sym_to_char(display, keysym):
     if keysym:
         char = display.lookup_string(keysym)
         return char
+
+def code_to_sym(display, keycode, state):
+    level = get_level(state)
+    return display.keycode_to_keysym(keycode, level)