def __init__(self, keycode, modifiers, keysym): """Create an event instance. Arguments: keycode -- The keycode that identifies a physical key. modifiers -- An 8-bit mask. A set bit means the corresponding modifier is active. See Xlib.X.ShiftMask, Xlib.X.LockMask, Xlib.X.ControlMask, and Xlib.X.Mod1Mask through Xlib.X.Mod5Mask. keysym -- The symbol obtained when the key corresponding to keycode without any modifiers. The KeyboardEmulation class does not track modifiers such as Shift and Control. """ self.keycode = keycode self.modifiers = modifiers self.keysym = keysym # Only want printable characters. if keysym < 255 or keysym in (XK.XK_Return, XK.XK_Tab): self.keystring = XK.keysym_to_string(keysym) if self.keystring == '\x00': self.keystring = None else: self.keystring = None
def wait(p_keys_list): """Block the whole keyboard!!! And wait until some key from p_keys_list is pressed. By now p_keys_list is a list of strings, so use single ascii symbols. There is a way out of this hell - hit 'Escape'. The function returns hit button`s string representation Eg. for p_keys_list == ['1','2','3'] the function will hand untill 1,2 or 3 key is preseed or Escape is pressed.""" ds = display window.grab_keyboard(1, X.GrabModeAsync, X.GrabModeAsync, X.CurrentTime) while True: ev = ds.next_event() if ev.type == X.KeyPress: keysym = ds.keycode_to_keysym(ev._data['detail'], 0) keystr = XK.keysym_to_string(keysym) print("Got keysym/keystr: "+str(keysym)+ ' / '+str(keystr)) if keystr in p_keys_list: ds.ungrab_keyboard(X.CurrentTime) ds.flush() return keystr elif str(keysym) in p_keys_list: ds.ungrab_keyboard(X.CurrentTime) ds.flush() return keysym elif keysym == 65307: ds.ungrab_keyboard(X.CurrentTime) ds.flush() return 'Escape'
def main(options): # current display pid_file = "/var/lock/easyxmotion.pid" # kill any old versions that are still running, # we do it this way so the current one has input focus. # might be a better way to just exit and give focus to the old one. try: with open(pid_file, "r") as fp: pid = int(fp.read()) try: os.kill(pid, signal.SIGTERM) except OSError: # other isn't running pass except IOError: # first ever run pass with open(pid_file, "w") as fp: fp.write(str(os.getpid())) osds, windows = display_osd(options) disp = Display() root = disp.screen().root root.change_attributes(event_mask=X.KeyPressMask) root.grab_keyboard(False, X.GrabModeAsync, X.GrabModeAsync, X.CurrentTime) event = disp.next_event() keycode = event.detail if event.type == X.KeyPress: key = XK.keysym_to_string(disp.keycode_to_keysym(keycode, 0)) if key and key in string.lowercase and string.lowercase.index(key) < len(windows): windows[string.lowercase.index(key)].activate(timestamp) disp.ungrab_keyboard(X.CurrentTime) sys.exit()
def main(options): # current display pid_file = '/var/lock/easyxmotion.pid' # kill any old versions that are still running, # we do it this way so the current one has input focus. # might be a better way to just exit and give focus to the old one. try: with open(pid_file, 'r') as fp: pid = int(fp.read()) try: os.kill(pid, signal.SIGTERM) except OSError: #other isn't running pass except IOError: # first ever run pass with open(pid_file, 'w') as fp: fp.write(str(os.getpid())) osds, windows = display_osd(options) disp = Display() root = disp.screen().root root.change_attributes(event_mask = X.KeyPressMask) root.grab_keyboard(False, X.GrabModeAsync, X.GrabModeAsync, X.CurrentTime) event = disp.next_event() keycode = event.detail if event.type == X.KeyPress: key = XK.keysym_to_string(disp.keycode_to_keysym(keycode, 0)) if key and key in string.lowercase and string.lowercase.index(key) < len(windows): windows[string.lowercase.index(key)].activate(timestamp) disp.ungrab_keyboard(X.CurrentTime) sys.exit()
def handle_keypress_sym(self, k): name = XK.keysym_to_string(k) if k in self.modifier_map: self.modifier_map[k] = True return # in buffer mvmt if k == XK.XK_Right and self.is_ctrl(): self.shift_cursor_end_word() elif k == XK.XK_Right: self.shift_cursor_right() elif k == XK.XK_Left and self.is_ctrl(): self.shift_cursor_start_word() elif k == XK.XK_Left: self.shift_cursor_left() # del bk elif k == XK.XK_Delete: self.forward_delete() elif k == XK.XK_BackSpace: self.backward_delete() # printable char elif name is not None: if self.is_ctrl() and is_well_known_ctrl_hotkey(name): self.reset_buff() else: c = name.upper() if self.is_shift() else name self.type_char(c) else: print("other", k, name) self.reset_buff()
def wait(p_keys_list): """Block the whole keyboard!!! And wait until some key from p_keys_list is pressed. By now p_keys_list is a list of strings, so use single ascii symbols. There is a way out of this hell - hit 'Escape'. The function returns hit button`s string representation Eg. for p_keys_list == ['1','2','3'] the function will hand untill 1,2 or 3 key is preseed or Escape is pressed.""" ds = display window.grab_keyboard(1, X.GrabModeAsync, X.GrabModeAsync, X.CurrentTime) while True: ev = ds.next_event() if ev.type == X.KeyPress: keysym = ds.keycode_to_keysym(ev._data['detail'], 0) keystr = XK.keysym_to_string(keysym) print("Got keysym/keystr: " + str(keysym) + ' / ' + str(keystr)) if keystr in p_keys_list: ds.ungrab_keyboard(X.CurrentTime) ds.flush() return keystr elif str(keysym) in p_keys_list: ds.ungrab_keyboard(X.CurrentTime) ds.flush() return keysym elif keysym == 65307: ds.ungrab_keyboard(X.CurrentTime) ds.flush() return 'Escape'
def handler(self, reply): """ Self function is called when a xlib event is fired """ data = reply.data while len(data): event, data = rq.EventField(None).parse_binary_value(data, self.disp.display, None, None) if event.type == X.KeyPress: if event.detail == 36: self.record("enter") elif event.detail == 22: self.record("backspace") elif event.detail == 37: self.record("control") elif event.detail == 64: self.record("alt") elif event.detail == 108: self.record("alt-gr") key = XK.keysym_to_string( self.disp.keycode_to_keysym(event.detail, event.state)) if key: self.record(key)
def interpret_keysym(keysym): '''Convert keysym to keyname''' if keysym in KEYSYM_TABLE: # Special keys return KEYSYM_TABLE[keysym] else: # Other keys (if not found, `None` will be returned) return XK.keysym_to_string(keysym)
def OnKeyPress(self, event): if event.Key == "space": self.completer.complete_whitespace() elif event.Key == "BackSpace": self.completer.complete_backspace() else: try: key_number = getattr(XK, "XK_" + event.Key) key = XK.keysym_to_string(key_number) if key is not None: self.completer.complete_letter(key) except AttributeError: pass
def event_to_string(self, event): mods = [] if event.state & X.ShiftMask: mods.append('Shift') if event.state & X.ControlMask: mods.append('Control') keycode = event.detail keysym = self.disp.keycode_to_keysym(keycode, 0) char = XK.keysym_to_string(keysym) return ''.join(mod + '+' for mod in mods) + (char if char else '?')
def keycode_to_string(self, key_code): codes_mod=[50,62,64,108,37,105,113,111,114,116,110,115,112,117,118,119,107, 67,68,69,70,71,72,73,74,75,76,95,96 ] names_mod=['Shift_L', 'Shift_R', 'Alt_L', 'Alt_R', 'Control_L', 'Control_R', 'Left', 'Up', 'Right', 'Down', 'Home', 'End', 'Page_Up', 'Page_Down', 'Insert', 'Delete', 'Print', 'F1','F2','F3','F4','F5','F6','F7','F8','F9','F10','F11','F12' ] if key_code in codes_mod: return names_mod[codes_mod.index(key_code)] #2nd: 0 is unshifted, 1 is shifted, 2 is alt grid, and 3 is shiftalt grid return XK.keysym_to_string(self.disp.keycode_to_keysym(key_code, 0))
def listen(self): self.grab() while True: evt = self.disp.next_event() if evt.type in [X.KeyPress, X.KeyRelease]: keycode = evt.detail keysym = self.disp.keycode_to_keysym(keycode, 0) char = XK.keysym_to_string(keysym) self.disp.allow_events(X.ReplayKeyboard, X.CurrentTime) self.mode(self, evt, char) if evt.type == X.DestroyNotify: if evt.window.id == self.id: self.ungrab() return
def keycode_to_string(key_code): syms_mod=[65505,65506,65513,65514,65507,65508, 65361,65362,65363,65364,65360,65367,65365,65366, 65379,65535,65491, 65470,65471,65472,65473,65474,65475,65476,65477,65478,65479,65480,65481 ] names_mod=['Shift_L', 'Shift_R', 'Alt_L', 'Alt_R', 'Control_L', 'Control_R', 'Left', 'Up', 'Right', 'Down', 'Home', 'End', 'Page_Up', 'Page_Down', 'Insert', 'Delete', 'Print', 'F1','F2','F3','F4','F5','F6','F7','F8','F9','F10','F11','F12' '\r' ] #2nd: 0 is unshifted, 1 is shifted, 2 is alt grid, and 3 is shiftalt grid key_sym=disp.keycode_to_keysym(key_code, 0) if key_sym in syms_mod: return names_mod[syms_mod.index(key_sym)] return XK.keysym_to_string(key_sym)
def handler(self, reply): """ Self function is called when a xlib event is fired """ data = reply.data while len(data): event, data = rq.EventField(None).parse_binary_value( data, self.disp.display, None, None) if event.type == X.KeyPress: if event.detail == 36: self.record("enter") elif event.detail == 22: self.record("backspace") elif event.detail == 37: self.record("control") elif event.detail == 64: self.record("alt") elif event.detail == 108: self.record("alt-gr") key = XK.keysym_to_string( self.disp.keycode_to_keysym(event.detail, event.state)) if key: self.record(key)
def get_keysym(key_code): key_sym = disp.keycode_to_keysym(key_code, 0) return XK.keysym_to_string(key_sym)
def code_to_char(cls, code, modifiers=0): if cls.device is "button": return "<%s>" % cls.key_to_name(code) if not cls.display: cls.display = Display() return XK.keysym_to_string(cls.display.keycode_to_keysym(code + 8, modifiers))
w.draw_message("uniclick: scanning screen...") # undraw w.draw(word_boxes, None) w.display.sync() filtered_boxes = word_boxes.copy() selection = None search_term = "" found = False while not found: e = w.display.next_event() if e.type == X.KeyRelease: w.draw(filtered_boxes, selection) # undraw current state keysym = w.display.keycode_to_keysym(e.detail, 0) string = XK.keysym_to_string(keysym) if keysym == XK.XK_BackSpace and len(search_term) >= 1: search_term = search_term[0:-1] elif keysym == XK.XK_Escape: raise SystemExit elif string is not None and string in ALPHABET: search_term += string elif selection is not None and keysym == XK.XK_Return: found = True elif keysym == XK.XK_Tab: if selection is not None:
def keycode_to_string(self, detail): return XK.keysym_to_string(self.dpy.keycode_to_keysym(detail, 0))