def register_keystroke_handler(self, keystring, method, context=WMActions.root_context):
""" Register a callback for a keystroke
Args:
keystring: string, format is 'mod1+mod2+modN+key'
such as 'alt+j'
method: method to be called
"""
data = keystring.split("+")
mod_list = data[:-1]
key = data[-1]
modifier_mask = 0
keysym = XK.string_to_keysym(key)
#print "%s => %s" % (key, keysym)
if keysym == X.NoSymbol:
print "%r is not a valid keysym" % key
return
keycode = self.display.keysym_to_keycode(keysym)
for mod in mod_list:
# Rename "alt" to "Alt_L" and such.
if mod in ("alt", "super", "meta"):
mod = mod.capitalize() + "_L"
modkey = self.display.keysym_to_keycode(XK.string_to_keysym(mod))
if modkey in self.modifier_map:
modifier_mask |= self.modifier_map[modkey]
else:
print "Invalid modifier key: '%s' (check xmodmap output)" % mod
if context == WMActions.root_context:
for screen in self.screens.itervalues():
self.grab_key(screen.root, keysym, modifier_mask)
keybinding = (context, keysym, modifier_mask)
print "Registered keystroke '%s' as %r)" % (keystring, keybinding,)
self.keybindings[keybinding] = method
def lookup_character_value(self, character):
"""
Looks up the keysym for the character then returns the keycode mapping
and modifier for that keysym.
"""
ch_keysym = XK.string_to_keysym(character)
ch_mask = 0
if ch_keysym == 0:
if character in SPECIAL_X_KEYSYMS:
ch_keysym = XK.string_to_keysym(SPECIAL_X_KEYSYMS[character])
elif len(character) == 1:
ch_keysym = ord(character)
ch_keycodes = self.display.keysym_to_keycodes(ch_keysym)
if len(ch_keycodes) == 0 and len(character) == 1:
ch_keycodes = self.display.keysym_to_keycodes(ord(character.lower()))
ch_mask ^= X.LockMask
if len(ch_keycodes) > 0:
ch_keycode, mask = self.__findUsableKeycode(ch_keycodes)
if ch_keycode == None or mask == None:
return None, None
else:
ch_mask ^= mask
else:
return None, None
if ch_mask ^ 4 < 4:
ch_mask ^= 4
ch_mask ^= self.modmasks[self.alt_gr_key]
return ch_keycode, ch_mask
def send_paste_keypress(self):
# TODO: configuration option for paste key-sequence?
ctrl = self.display.keysym_to_keycode(XK.string_to_keysym("Control_L"))
shift = self.display.keysym_to_keycode(XK.string_to_keysym("Shift_L"))
v = self.display.keysym_to_keycode(XK.string_to_keysym("v"))
if self.new_clip:
ins = self.display.keysym_to_keycode(XK.string_to_keysym("Insert"))
self.display.xtest_fake_input(X.KeyPress, shift)
self.display.xtest_fake_input(X.KeyPress, ins)
self.display.xtest_fake_input(X.KeyRelease, ins)
self.display.xtest_fake_input(X.KeyRelease, shift)
else:
term = self.name in self.terminals or "bash" in self.name
if term:
self.display.xtest_fake_input(X.KeyPress, shift)
self.display.xtest_fake_input(X.KeyPress, ctrl)
self.display.xtest_fake_input(X.KeyPress, v)
self.display.xtest_fake_input(X.KeyRelease, v)
self.display.xtest_fake_input(X.KeyRelease, ctrl)
if term:
self.display.xtest_fake_input(X.KeyRelease, shift)
self.display.sync()
# need to give xlib time to do it's thing as the calls are asyncronous
if self.old_text:
gobject.timeout_add(200, self.reset_clipboard, self.old_text)
# self.reset_clipboard (self.old_text)
else:
gobject.timeout_add(200, self.clear_clipboard)
def __init__(self) -> None:
self.active_keys = {
XK.string_to_keysym(key): False for key in SETTINGS.keybindings
}
self.modifying_keys = {
XK.string_to_keysym(key): False for key in SETTINGS.keybinding_modifier
}
self.zp = ZoneProfile.from_file()
self.coordinates = Coordinates()
self.display = Display()
self.root = self.display.screen().root
self.context = self.display.record_create_context(
0,
[record.AllClients],
[
{
"core_requests": (0, 0),
"core_replies": (0, 0),
"ext_requests": (0, 0, 0, 0),
"ext_replies": (0, 0, 0, 0),
"delivered_events": (0, 0),
"device_events": (X.KeyReleaseMask, X.ButtonReleaseMask),
"errors": (0, 0),
"client_started": False,
"client_died": False,
}
],
)
self.display.record_enable_context(self.context, self.handler)
self.display.record_free_context(self.context)
def __get_keysym(self, key):
keysym = XK.string_to_keysym(key)
if keysym == 0:
# Unfortunately, although this works to get the correct keysym
# i.e. keysym for '#' is returned as "numbersign"
# the subsequent display.keysym_to_keycode("numbersign") is 0.
keysym = XK.string_to_keysym(self._special_X_keysyms[key])
return keysym
def find_key(key):
if key == 18:
return d.keysym_to_keycode(XK.string_to_keysym('Left'))
elif key == 50:
return d.keysym_to_keycode(XK.string_to_keysym('Right'))
elif key == 34:
return d.keysym_to_keycode(XK.string_to_keysym('Home'))
else:
return 0
def _xlib_get_keycode(self, key):
keysym = XK.string_to_keysym(key)
if keysym == 0:
try:
keysym = XK.string_to_keysym(special_X_keysyms[key])
except KeyError:
return None
keycode = self.disp.keysym_to_keycode(keysym)
return keycode
def lookup_character_value(self, character):
"""
Looks up the keysym for the character then returns the keycode mapping
for that keysym.
"""
ch_keysym = XK.string_to_keysym(character)
if ch_keysym == 0:
ch_keysym = XK.string_to_keysym(SPECIAL_X_KEYSYMS[character])
return self.display.keysym_to_keycode(ch_keysym)
def _xlib_get_keycode(self, key) :
keysym = XK.string_to_keysym(key)
if keysym == 0:
try:
keysym = XK.string_to_keysym(special_X_keysyms[key])
except KeyError:
return None
keycode = self.disp.keysym_to_keycode(keysym)
return keycode
def _get_keysym(cls, ch):
keysym = XK.string_to_keysym(ch)
if keysym == 0:
# Unfortunately, although this works to get the correct keysym
# i.e. keysym for '#' is returned as "numbersign"
# the subsequent display.keysym_to_keycode("numbersign") is 0.
#print "b:" + cls._special_X_keysyms[ch]
keysym = XK.string_to_keysym(cls._special_X_keysyms[ch])
#print "keysim:" + str(keysym)
return keysym
def setup_funnylocks(self):
nlock_key = self.dpy.keysym_to_keycode(XK.string_to_keysym("Num_Lock"))
slock_key = self.dpy.keysym_to_keycode(XK.string_to_keysym("Scroll_Lock"))
mapping = self.dpy.get_modifier_mapping()
mod_names = "Shift Lock Control Mod1 Mod2 Mod3 Mod4 Mod5".split()
for modname in mod_names:
index = getattr(X, "%sMapIndex" % modname)
mask = getattr(X, "%sMask" % modname)
if nlock_key and nlock_key in mapping[index]:
self.nlock = mask
if slock_key and slock_key in mapping[index]:
self.slock = mask
def setup_funnylocks(self):
nlock_key = self.dpy.keysym_to_keycode(XK.string_to_keysym("Num_Lock"))
slock_key = self.dpy.keysym_to_keycode(
XK.string_to_keysym("Scroll_Lock"))
mapping = self.dpy.get_modifier_mapping()
mod_names = "Shift Lock Control Mod1 Mod2 Mod3 Mod4 Mod5".split()
for modname in mod_names:
index = getattr(X, "%sMapIndex" % modname)
mask = getattr(X, "%sMask" % modname)
if nlock_key and nlock_key in mapping[index]:
self.nlock = mask
if slock_key and slock_key in mapping[index]:
self.slock = mask
def string_to_keycode(key):
#'\r':'Return' for Shift+Return will trigger "\r" and enter string_to_keycode() refer: https://github.com/SavinaRoja/PyKeyboard/blob/master/pykeyboard/x11.py
keys_special={' ':'space','\t':'Tab','\r':'Return','\n':'Return','\b':'BackSpace','\e':'Escape',
'!':'exclam','#':'numbersign','%':'percent','$':'dollar','&':'ampersand','"':'quotedbl',
'\'':'apostrophe','(':'parenleft',')':'parenright','*':'asterisk','=':'equal','+':'plus',
',':'comma','-':'minus','.':'period','/':'slash',':':'colon',';':'semicolon','<':'less',
'>':'greater','?':'question','@':'at','[':'bracketleft',']':'bracketright','\\':'backslash',
'^':'asciicircum','_':'underscore','`':'grave','{':'braceleft','|':'bar','}':'braceright',
'~':'asciitilde'
}
key_sym=XK.string_to_keysym(key)
if key_sym==0:
key_sym=XK.string_to_keysym(keys_special[key])
return disp.keysym_to_keycode(key_sym)
def __init__(self, modifiers, key, action, *args, **kwargs):
self.modifiers, self.key = modifiers, key
self.action, self.args, self.kwargs = action, args, kwargs
self.keysym = XK.string_to_keysym(key)
if self.keysym == 0:
raise QTileError("Unknown key: %s" % key)
self.modmask = utils.translateMasks(self.modifiers)
def emulateWritingString(d, cmd, delay, k=None):
'''
Processes a string by writing it to the screen with a certain delay
'''
for c in cmd:
if k is not None:
# Emulate the key.
emulateSpecialKey(d, k, delay)
keysym = XK.string_to_keysym(c)
if keysym == 0:
# Its a symbol, not a letter.
emulateSpecialKey(d, c, delay)
else:
# It's a letter
keycode = d.keysym_to_keycode(keysym)
# If it's uppercase, we press shift.
if c.isupper():
xtest.fake_input(d, X.KeyPress, kmap[u'shift_l'])
# Its even a specialer key :P
if keycode == 0:
emulateSpecialKey(d, c, delay)
else:
xtest.fake_input(d, X.KeyPress, keycode)
d.flush()
time.sleep(delay)
xtest.fake_input(d, X.KeyRelease, keycode)
# Delay time between letters
# time.sleep(0.025)
# If it's uppercase, we release shift.
if c.isupper():
xtest.fake_input(d, X.KeyRelease, kmap[u'shift_l'])
d.flush()
def on_snippets_completed(self, text):
self.snippets.hide()
if text is not None:
pyperclip.copy(text)
keysym = XK.string_to_keysym('V')
keycode = self.display.keysym_to_keycode(keysym)
ev = protocol.event.KeyPress(
time=int(time.time()),
root=self.display.screen().root,
window=self.focus,
root_x=0,
root_y=0,
event_x=0,
event_y=0,
same_screen=0, child=X.NONE,
state=X.ControlMask,
detail=keycode
)
self.display.send_event(self.focus, ev)
self.display.sync()
time.sleep(1)
pyperclip.copy(self.cb_cache)
return True
def str2keycode(cls, code, key=''):
"""Convert key as string(s) into (modifiers, keycode) pair.
There must be both modifier(s) and key persenti. If you send both
modifier(s) and key in one string, they must be separated using '-'.
Modifiers must be separated using '-'.
Keys are case insensitive.
If you want to use upper case use Shift modifier.
Only modifiers defined in __KEY_MODIFIERS are valid.
For example: "Ctrl-A", "Super-Alt-x"
"""
code = code.split('-')
if not key:
key = code[-1]
masks = code[:-1]
else:
masks = code
# TODO: Check this part... not sure why it looks like that...
modifiers = 0
if masks[0]:
for mask in masks:
if not mask in cls.__KEY_MODIFIERS.keys():
continue
modifiers = modifiers | cls.__KEY_MODIFIERS[mask]
else:
modifiers = X.AnyModifier
keysym = XK.string_to_keysym(key)
keycode = cls.__DISPLAY.keysym_to_keycode(keysym)
cls.__KEYCODES[keycode] = key
return (modifiers, keycode)
def parse_keystring(self, keystring):
keys = keystring.split(" + ")
if len(keys) == 1:
keyval = XK.string_to_keysym(keys[0].upper())
modifier_mask = 0
else:
keyval = XK.string_to_keysym(keys[-1].upper())
modifier_mask = 0
if "Ctrl" in keys[0:-1]:
modifier_mask |= X.ControlMask
if "Alt" in keys[0:-1]:
modifier_mask |= X.Mod1Mask
# modifier_mask |= X.ShiftMask
return (keyval, modifier_mask)
def _keycode(self, sym):
if isinstance(sym, str):
sym = XK.string_to_keysym(sym)
result = self._keycodes.get(sym, None)
if result is None:
self._keycodes[sym] = result = self.display.keysym_to_keycode(sym)
return result
def parse_keys(self, display, config):
commands = ['next_window',
'prev_window',
'kill_window',
'split_horizontal',
'split_vertical',
'next_stack',
'prev_stack',
'kill_stack']
for command in commands:
key_def = getattr(config.keys, command)
(modifier, key) = key_def.split('+') # TODO Handle multiple modifiers
if modifier == 'Mod4':
mod_mask = X.Mod4Mask
elif modifier == 'Mod3':
mod_mask = X.Mod3Mask
elif modifier == 'Mod2':
mod_mask = X.Mod2Mask
elif modifier == 'Mod1':
mod_mask = X.Mod1Mask
else:
logging.critical("Command '%s' uses unknown modifier '%s'", command, modifier)
sys.exit(1)
keycode = display.keysym_to_keycode(XK.string_to_keysym(key))
self.keymap[(mod_mask, keycode)] = command
def __init__(self, display, path=os.path.join(os.path.dirname(os.path.realpath(__file__)), "default.json")):
self.config = {}
# Load and parse JSON config
with open(path) as data_file:
raw_config = json.load(data_file)
# Iterate through the items in the object
for dkey, value in raw_config.iteritems():
# If a value is not a list type, ignore it
if type(value) is not list:
logging.error("Key configurations must be listed in arrays.")
continue
# Convert all of the key strings into their proper codes
self.config[dkey] = []
for key in value:
code = XK.string_to_keysym(key)
# If the returned code is 0, then it could not be found by XK
if code is 0:
self.config[dkey] = None
logging.warning("Key ("+code+") was not recognized by XK")
break
else:
self.config[dkey].append(display.keysym_to_keycode(code))
def str2keycode(cls, code, key=''):
"""Convert key as string(s) into (modifiers, keycode) pair.
There must be both modifier(s) and key persenti. If you send both
modifier(s) and key in one string, they must be separated using '-'.
Modifiers must be separated using '-'.
Keys are case insensitive.
If you want to use upper case use Shift modifier.
Only modifiers defined in __KEY_MODIFIERS are valid.
For example: "Ctrl-A", "Super-Alt-x"
"""
code = code.split('-')
if not key:
key = code[-1]
masks = code[:-1]
else:
masks = code
# TODO: Check this part... not sure why it looks like that...
modifiers = 0
if masks[0]:
for mask in masks:
if not mask in cls.__KEY_MODIFIERS.keys():
continue
modifiers = modifiers | cls.__KEY_MODIFIERS[mask]
else:
modifiers = X.AnyModifier
keysym = XK.string_to_keysym(key)
keycode = cls.__DISPLAY.keysym_to_keycode(keysym)
cls.__KEYCODES[keycode] = key
return (modifiers, keycode)
def start(self):
mod = self.MOD_MASK
dpy = Display()
keys = {}
for key, name in self.KEY_MAP.items():
keys[key] = dpy.keysym_to_keycode(XK.string_to_keysym(key))
root = dpy.screen().root
for key, code in keys.items():
root.grab_key(code, mod, 1, X.GrabModeAsync, X.GrabModeAsync)
root.grab_button(
1, mod, 1,
X.ButtonPressMask | X.ButtonReleaseMask | X.PointerMotionMask,
X.GrabModeAsync, X.GrabModeAsync, X.NONE, X.NONE)
root.grab_button(
3, mod, 1,
X.ButtonPressMask | X.ButtonReleaseMask | X.PointerMotionMask,
X.GrabModeAsync, X.GrabModeAsync, X.NONE, X.NONE)
self.dpy = dpy
self.keys = keys
self.root = root
self.WM_PROTOCOLS = dpy.intern_atom("WM_PROTOCOLS")
self.WM_DELETE_WINDOW = dpy.intern_atom("WM_DELETE_WINDOW")
self._loop()
def emulateWritingString(d, cmd, delay, k=None):
'''
Processes a string by writing it to the screen with a certain delay
'''
for c in cmd:
if k is not None:
# Emulate the key.
emulateSpecialKey(d, k, delay)
keysym = XK.string_to_keysym(c)
if keysym == 0:
# Its a symbol, not a letter.
emulateSpecialKey(d, c, delay)
else:
# It's a letter
keycode = d.keysym_to_keycode(keysym)
# If it's uppercase, we press shift.
if c.isupper():
xtest.fake_input(d, X.KeyPress, kmap[u'shift_l'])
# Its even a specialer key :P
if keycode == 0:
emulateSpecialKey(d, c, delay)
else:
xtest.fake_input(d, X.KeyPress, keycode)
d.flush()
time.sleep(delay)
xtest.fake_input(d, X.KeyRelease, keycode)
# Delay time between letters
# time.sleep(0.025)
# If it's uppercase, we release shift.
if c.isupper():
xtest.fake_input(d, X.KeyRelease, kmap[u'shift_l'])
d.flush()
def set_key_aliases(self):
keystrings = [
"x", "q",
"minus", "equal", "bracketleft", "bracketright", "backslash", "slash",
"F1", "Tab", "Escape", "space", "Return", "BackSpace"
]
for keystring in keystrings:
self.key_alias[keystring] = self.dpy.keysym_to_keycode(XK.string_to_keysym(keystring))
def string_to_keycode(self, key):
codes_mod=[50,62,64,108,37,105]
names_mod=['Shift_L', 'Shift_R', 'Alt_L', 'Alt_R', 'Control_L', 'Control_R']
if key in names_mod:
return codes_mod[names_mod.index(key)]
keys_special={' ':'space','\t':'Tab','\n':'Return','\r':'BackSpace','\e':'Escape',
'!':'exclam','#':'numbersign','%':'percent','$':'dollar','&':'ampersand','"':'quotedbl',
'\'':'apostrophe','(':'parenleft',')':'parenright','*':'asterisk','=':'equal','+':'plus',
',':'comma','-':'minus','.':'period','/':'slash',':':'colon',';':'semicolon','<':'less',
'>':'greater','?':'question','@':'at','[':'bracketleft',']':'bracketright','\\':'backslash',
'^':'asciicircum','_':'underscore','`':'grave','{':'braceleft','|':'bar','}':'braceright',
'~':'asciitilde'
}
key_sym=XK.string_to_keysym(key)
if key_sym==0:
key_sym=XK.string_to_keysym(keys_special[key])
return self.disp.keysym_to_keycode(key_sym)
def key_spec_to_keycode_modifier_mask(self, key_spec):
modifiers, key = parse_modifier_mask(key_spec)
keysym = XK.string_to_keysym(key)
keycode = self.dpy.keysym_to_keycode(keysym)
if keycode not in self.keycode_to_char.keys():
self.keycode_to_char[keycode] = key
modifier_mask = reduce(lambda x, y: x | y, modifiers, 0)
return key, keycode, modifier_mask
def __init__(self):
"""Prepare to emulate keyboard events."""
self.display = display.Display()
self.modifier_mapping = self.display.get_modifier_mapping()
# Determine the backspace keycode.
backspace_keysym = XK.string_to_keysym('BackSpace')
self.backspace_keycode, mods = self._keysym_to_keycode_and_modifiers(
backspace_keysym)
def string_to_keysym(self, s):
k = self.keysyms[s]
if not k:
k = self.keysyms["XK_" + s]
if k:
return k
k = XK.string_to_keysym(s)
return k
def str2keycode(cls, key):
"""Parse keycode."""
keysym = XK.string_to_keysym(key)
keycode = cls.__DISPLAY.keysym_to_keycode(keysym)
cls.__KEYCODES[keycode] = key
if keycode == 0:
raise ValueError('No key specified!')
return keycode
def __init__(self):
"""Prepare to emulate keyboard events."""
self.display = display.Display()
self.modifier_mapping = self.display.get_modifier_mapping()
# Determine the backspace keycode.
backspace_keysym = XK.string_to_keysym('BackSpace')
self.backspace_keycode, mods = self._keysym_to_keycode_and_modifiers(
backspace_keysym)
def send_hotkey(self, *keys):
for key in keys:
if key not in self.keyboardMapping:
logging.warning('WARNING! Key {} is not supported.'.format(key))
return
for key in keys:
c = self.keyboardMapping[key][0]
keysym = XK.string_to_keysym(c)
code = self.d.keysym_to_keycode(keysym)
fake_input(self.d, X.KeyPress, code)
for key in reversed(keys):
c = self.keyboardMapping[key][0]
keysym = XK.string_to_keysym(c)
code = self.d.keysym_to_keycode(keysym)
fake_input(self.d, X.KeyRelease, code)
time.sleep(0.3)
self.d.sync()
def str2keycode(cls, key):
"""Parse keycode."""
keysym = XK.string_to_keysym(key)
keycode = cls.__DISPLAY.keysym_to_keycode(keysym)
cls.__KEYCODES[keycode] = key
if keycode == 0:
raise ValueError('No key specified!')
return keycode
def hold_button(key):
number = display.keysym_to_keycode(XK.string_to_keysym(key))
display.sync()
fake_input(display, X.KeyPress, number, X.CurrentTime)
yield
fake_input(display, X.KeyRelease, number, X.CurrentTime)
display.sync()
display.flush()
def interpret_keyname(keyname):
'''Convert keyname to list of keysyms'''
if keyname in KEYSYM_TABLE_INV:
# Special keys
return KEYSYM_TABLE_INV[keyname]
else:
# Other keys
keysym = XK.string_to_keysym(keyname)
return [keysym]
def toNativeKeycode(self, key): ''' Returns the X11 native keycode for a QT Key ''' keysim = XK.string_to_keysym(QKeySequence(key).toString()) if keysim == X.NoSymbol: keysim = int(key) #endif return keysim
def parse_keystring(keystring):
keys = keystring.split("+")
modifier_mask = 0
if len(keys) == 1:
keyval = XK.string_to_keysym(keys[0].upper())
else:
keyval = XK.string_to_keysym(keys[-1].lower())
if "Ctrl" in keys[0:-1]:
modifier_mask |= X.ControlMask
if "Alt" in keys[0:-1]:
modifier_mask |= X.Mod1Mask
if "Shift" in keys[0:-1]:
modifier_mask |= X.ShiftMask
keycode = local_dpy.keysym_to_keycode(keyval)
return (keycode, modifier_mask)
def parse_key(k):
(*parts, sym) = k.split("-")
modmask = 0
for mod in parts:
modmask |= mods[mod]
keysym = XK.string_to_keysym(sym)
if keysym == 0:
print("Invalid key '%s'" % parts)
return (keysym, modmask)
def type_char(self, char):
# Try to get keysym (works for non-special keys, returns 0 otherwise)
keysym = XK.string_to_keysym(char)
if (keysym == 0):
keysym = XK.string_to_keysym(special_X_keysyms[char])
keycode = self.disp.keysym_to_keycode(keysym)
# Does this char require shift?
if (ord(char) >= 0x41 and
ord(char) <= 0x51) or "~!@#$%^&*()_+{}|:\"<>?".find(char) >= 0:
self.press_button(VK_SHIFT)
self.type_button(keycode)
self.release_button(VK_SHIFT)
else:
self.type_button(keycode)
def mapKey(self, key):
if key in self.control_key_map:
return self.control_key_map[key]
keysym = XK.string_to_keysym(key)
if keysym != 0:
return keysym
return self.map.get(key, None)
def parse_keystring(keystring):
keys = keystring.split("+")
modifier_mask = 0
if len(keys) == 1:
keyval = XK.string_to_keysym(keys[0].upper())
else:
keyval = XK.string_to_keysym(keys[-1].lower())
if "Ctrl" in keys[0:-1]:
modifier_mask |= X.ControlMask
if "Alt" in keys[0:-1]:
modifier_mask |= X.Mod1Mask
if "Shift" in keys[0:-1]:
modifier_mask |= X.ShiftMask
keycode = local_dpy.keysym_to_keycode(keyval)
return (keycode, modifier_mask)
def press(key):
keys = re.findall("([\w\d]+)", key)
for key, event in chain(zip(keys, repeat(X.KeyPress)),
zip(reversed(keys), repeat(X.KeyRelease))):
number = display.keysym_to_keycode(XK.string_to_keysym(key))
display.sync()
fake_input(display, event, number, X.CurrentTime)
display.sync()
display.flush()
def get_keycode(key):
mod = X.NONE
for p in key.split("+"):
if p in key_mods:
mod |= key_mods[p]
else:
key = p
key_sym = XK.string_to_keysym(keys_to_code.get(key, key))
key_code = disp.keysym_to_keycode(key_sym)
return key_code, mod
def do_key_press(keys, target=None):
"""
executes a keypress
:param keys: argument tuple containing one or several modifier keys, and the key to press
:param target: list containing name(s) of the target window
the key to pass as a parameter has to be taken from Xlib.XK library
"""
log.debug("do_key_press")
root = disp.screen().root
keys = map(
lambda k: XK.string_to_keysym(k)
if isinstance(k, basestring) else k, keys)
for key in keys:
if not key in XK.__dict__.values():
return False
pointer_info = request.QueryPointer(display=disp.display, window=root)
root_xpos, root_ypos = (pointer_info._data['root_x'],
pointer_info._data['root_y'])
targetwindow = disp.get_input_focus().focus
if targetwindow.get_wm_name() is None and targetwindow.get_wm_class(
) is None:
targetwindow = targetwindow.query_tree().parent
ret = targetwindow.translate_coords(root, root_xpos, root_ypos)
target_xpos = ret.x
target_ypos = ret.y
if target and targetwindow.get_wm_class():
for t in target:
if t in targetwindow.get_wm_class():
break
else:
log.info("Window '%s' not found in target(s) %s" %
(targetwindow.get_wm_class(), target))
return False
def send_key(display, window, keycodes):
'''Send a KeyPress and KeyRelease event'''
if not type(keycodes) in (tuple, list):
keycodes = (keycodes, )
# send with modifier
for keycode in keycodes:
xtest.fake_input(window, X.KeyPress,
display.keysym_to_keycode(keycode))
for keycode in reversed(keycodes):
xtest.fake_input(window, X.KeyRelease,
display.keysym_to_keycode(keycode))
display.sync()
send_key(disp, root, keys)
return True
def asciivalue(self, keysym):
asciinum = XK.string_to_keysym(self.lookup_keysym(keysym))
if asciinum < 256:
return asciinum
else:
return 0
def __send_key(self, x_event, key_code):
key = key_code.X11
if key is None:
print("key not defined on X11!")
pass
d = Display()
x11key = d.keysym_to_keycode(XK.string_to_keysym(key))
fake_input(d, x_event, x11key)
d.sync()
def cmd_simulate_keypress(self, qtile, modifiers, key):
"""
Simulates a keypress on the focused window.
"""
keysym = XK.string_to_keysym(key)
if keysym == 0:
return "Unknown key: %s" % key
keycode = qtile.display.keysym_to_keycode(keysym)
try:
mask = utils.translateMasks(modifiers)
except manager.QTileError, v:
return str(v)
def do_key_press(keys, target=None):
"""
executes a keypress
:param keys: argument tuple containing one or several modifier keys, and the key to press
:param target: list containing name(s) of the target window
the key to pass as a parameter has to be taken from Xlib.XK library
"""
log.debug("do_key_press")
root = disp.screen().root
keys = map(lambda k: XK.string_to_keysym(k) if isinstance(k, basestring) else k,
keys)
for key in keys:
if not key in XK.__dict__.values():
return False
pointer_info = request.QueryPointer(display = disp.display,
window = root)
root_xpos, root_ypos = (pointer_info._data['root_x'], pointer_info._data['root_y'])
targetwindow = disp.get_input_focus().focus
if targetwindow.get_wm_name() is None and targetwindow.get_wm_class() is None:
targetwindow = targetwindow.query_tree().parent
ret = targetwindow.translate_coords(root, root_xpos, root_ypos)
target_xpos = ret.x
target_ypos = ret.y
if target and targetwindow.get_wm_class():
for t in target:
if t in targetwindow.get_wm_class():
break
else:
log.info("Window '%s' not found in target(s) %s" % (targetwindow.get_wm_class(), target))
return False
def send_key(display, window, keycodes):
'''Send a KeyPress and KeyRelease event'''
if not type(keycodes) in (tuple, list):
keycodes = (keycodes,)
# send with modifier
for keycode in keycodes:
xtest.fake_input(window,
X.KeyPress,
display.keysym_to_keycode(keycode))
for keycode in reversed(keycodes):
xtest.fake_input(window,
X.KeyRelease,
display.keysym_to_keycode(keycode))
display.sync()
send_key(disp, root, keys)
return True
def register_keystroke_handler(self,
keystring,
method,
context=WMActions.root_context):
""" Register a callback for a keystroke
Args:
keystring: string, format is 'mod1+mod2+modN+key'
such as 'alt+j'
method: method to be called
"""
data = keystring.split("+")
mod_list = data[:-1]
key = data[-1]
modifier_mask = 0
keysym = XK.string_to_keysym(key)
#print "%s => %s" % (key, keysym)
if keysym == X.NoSymbol:
print "%r is not a valid keysym" % key
return
keycode = self.display.keysym_to_keycode(keysym)
for mod in mod_list:
# Rename "alt" to "Alt_L" and such.
if mod in ("alt", "super", "meta"):
mod = mod.capitalize() + "_L"
modkey = self.display.keysym_to_keycode(XK.string_to_keysym(mod))
if modkey in self.modifier_map:
modifier_mask |= self.modifier_map[modkey]
else:
print "Invalid modifier key: '%s' (check xmodmap output)" % mod
if context == WMActions.root_context:
for screen in self.screens.itervalues():
self.grab_key(screen.root, keysym, modifier_mask)
keybinding = (context, keysym, modifier_mask)
print "Registered keystroke '%s' as %r)" % (
keystring,
keybinding,
)
self.keybindings[keybinding] = method
def sendkey(win, symbol):
if symbol in self.keyboardMapping:
c = self.keyboardMapping[symbol][0]
keysym = XK.string_to_keysym(c)
code = self.d.keysym_to_keycode(keysym)
case = self.keyboardMapping[symbol][1]
e = event(win, protocol.event.KeyPress, code, case)
win.send_event(e, propagate=True)
e = event(win, protocol.event.KeyRelease, code, case)
win.send_event(e, propagate=True)
else:
msg = 'Symbol {} is not supported.'.format(symbol)
logging.warning(msg)
def asciivalue(self, keysym: int):
# lookup_keysym finds the keys' common name
# based on the given x11 keycode and generates a string such
# as "KX_A", which has nothing to do with the actual input.
# print("keysym:"+chr(keysym))
num = XK.string_to_keysym(self.lookup_keysym(keysym))
# print("after keysym to string:"+chr(num))
if num == X.NoSymbol:
return 0
if num < 256:
return num
else:
return 0
def init_x11(self):
from Xlib import X, XK
from Xlib.display import Display
disp = Display()
root = disp.screen().root
root.change_attributes(event_mask=X.KeyPressMask)
self.WINDOW_KEY = disp.keysym_to_keycode(XK.string_to_keysym("n"))
root.grab_key(self.WINDOW_KEY, X.AnyModifier, 1, X.GrabModeAsync, X.GrabModeAsync)
import threading
t = threading.Thread(target=lambda: self.process_x11(disp))
t.daemon = True
t.start()
def grab_primary_key(self):
# TODO Ungrab key if already grabbed
# TODO Allow multiple modifiers
modifier, key = self.config.keys.activate.split('+')
if modifier == 'Mod4':
keymask = X.Mod4Mask
elif modifier == 'Mod3':
keymask = X.Mod3Mask
elif modifier == 'Mod2':
keymask = X.Mod2Mask
elif modifier == 'Mod1':
keymask = X.Mod1Mask
keycode = self.display.keysym_to_keycode(XK.string_to_keysym(key))
release_mod = X.AnyModifier << 1
self.root.grab_key(keycode, keymask & ~release_mod, 1, X.GrabModeAsync, X.GrabModeAsync)
def keystr_to_sym_mask(s):
"""
>>> keystr_to_sym_mask('<Control><Alt>KP_3')
(65459, 12)
>>> _ == (XK.XK_KP_3, X.Mod1Mask | X.ControlMask)
True
>>>
"""
mask = 0
sym_start = 0
for m in KEY_MOD_RE.finditer(s):
mask |= KEY_MASKS[m.group(1).lower()]
sym_start = max(sym_start, m.end())
keysym = XK.string_to_keysym(s[sym_start:])
if not keysym:
logging.warning('Ignoring Unknown keysym %r in key binding %r',
s[sym_start:], s)
return (keysym, mask)
def __init__(self, modifiers, key, *commands):
"""
:modifiers A list of modifier specifications. Modifier
specifications are one of: "shift", "lock", "control", "mod1",
"mod2", "mod3", "mod4", "mod5".
:key A key specification, e.g. "a", "Tab", "Return", "space".
:*commands A list of lazy command objects generated with the
command.lazy helper. If multiple Call objects are specified, they
are run in sequence.
"""
self.modifiers, self.key, self.commands = modifiers, key, commands
self.keysym = XK.string_to_keysym(key)
if self.keysym == 0:
raise QtileError("Unknown key: %s"%key)
try:
self.modmask = utils.translateMasks(self.modifiers)
except KeyError, v:
raise QtileError(v)
def cmd_simulate_keypress(self, modifiers, key):
"""
Simulates a keypress on the focused window.
:modifiers A list of modifier specification strings. Modifiers can
be one of "shift", "lock", "control" and "mod1" - "mod5".
:key Key specification.
Examples:
simulate_keypress(["control", "mod2"], "k")
"""
keysym = XK.string_to_keysym(key)
if keysym == 0:
raise command.CommandError("Unknown key: %s"%key)
keycode = self.display.keysym_to_keycode(keysym)
try:
mask = utils.translateMasks(modifiers)
except KeyError, v:
return v.args[0]
def __init__(self, display=None):
PyKeyboardMeta.__init__(self)
self.display = Display(display)
self.root = self.display.screen().root
XK.load_keysym_group('xkb')
altList = self.display.keysym_to_keycodes(XK.XK_ISO_Level3_Shift)
self.__usable_modifiers = (0, 1)
for code, offset in altList:
if code == 108 and offset == 0:
self.__usable_modifiers += (4, 5)
break
mapping = self.display.get_modifier_mapping()
self.modmasks = {}
for keyname in MODIFIERS:
keysym = XK.string_to_keysym(keyname)
keycodes = self.display.keysym_to_keycodes(keysym)
found = False
for keycode, lvl in keycodes:
for index, mask in MASK_INDEXES:
if keycode in mapping[index]:
self.modmasks[keycode] = mask
found = True
if found:
break
self.flags = {
'Shift': X.ShiftMask,
'Lock': X.LockMask,
'Ctrl': X.ControlMask,
'Alt': 0,
'AltGr': self.modmasks[altList[0][0]],
'Hankaku': 0}
self.special_key_assignment()
def asciivalue(self, keysym):
asciinum = XK.string_to_keysym(self.lookup_keysym(keysym))
if asciinum < 256:
return asciinum
else:
return 0
def _xlib_get_keycode(self, key) :
keysym = XK.string_to_keysym(key)
if keysym == 0:
keysym = XK.string_to_keysym(special_X_keysyms[key])
keycode = self.disp.keysym_to_keycode(keysym)
return keycode
# TinyWM is written by Nick Welch <*****@*****.**> in 2005 & 2011.
#
# This software is in the public domain
# and is provided AS IS, with NO WARRANTY.
from Xlib.display import Display
from Xlib import X, XK
dpy = Display()
dpy.screen().root.grab_key(dpy.keysym_to_keycode(XK.string_to_keysym("F1")), X.Mod1Mask, 1,
X.GrabModeAsync, X.GrabModeAsync)
dpy.screen().root.grab_button(1, X.Mod1Mask, 1, X.ButtonPressMask|X.ButtonReleaseMask|X.PointerMotionMask,
X.GrabModeAsync, X.GrabModeAsync, X.NONE, X.NONE)
dpy.screen().root.grab_button(3, X.Mod1Mask, 1, X.ButtonPressMask|X.ButtonReleaseMask|X.PointerMotionMask,
X.GrabModeAsync, X.GrabModeAsync, X.NONE, X.NONE)
start = None
while 1:
ev = dpy.next_event()
if ev.type == X.KeyPress and ev.child != X.NONE:
ev.child.configure(stack_mode = X.Above)
elif ev.type == X.ButtonPress and ev.child != X.NONE:
attr = ev.child.get_geometry()
start = ev
elif ev.type == X.MotionNotify and start:
xdiff = ev.root_x - start.root_x
ydiff = ev.root_y - start.root_y
start.child.configure(
x = attr.x + (start.detail == 1 and xdiff or 0),
y = attr.y + (start.detail == 1 and ydiff or 0),
