def process_key_event(id_no, keyval, modmask, backslash, pressed = None):
def update_keymap():
display._update_keymap(display.display.info.min_keycode,
(display.display.info.max_keycode
- display.display.info.min_keycode + 1))
def reply(id_no, handled):
# editing = len()
# imcontexts[id_no].editing how do i know current input status
print_command('ibus_process_key_event_cb', id_no, handled)
return False
ic = imcontexts[id_no]
if use_surrounding_text and pressed != False \
and ic.needs_surrounding_text() and not ic.surrouding_text_received:
print_command('ibus_query_surrounding_text_cb',
id_no, keyval, modmask, backslash, pressed)
return
if backslash:
keycode = display.keysym_to_keycode(backslash) - 8
if keycode < 0:
update_keymap()
keycode = display.keysym_to_keycode(backslash) - 8
else:
keycodes = display.keysym_to_keycodes(keyval)
if not keycodes:
update_keymap()
keycodes = display.keysym_to_keycodes(keyval) or [(0, 0)]
if modmask & modifier.SHIFT_MASK:
for keycode_tuple in keycodes:
if keycode_tuple[1] & 1:
break
else:
keycode_tuple = keycodes[0]
elif keyval < 0x100:
for keycode_tuple in keycodes:
if keycode_tuple[1]:
if keycode_tuple[1] > 1:
keycode_tuple = keycodes[0]
break
else:
keycode_tuple = keycodes[0]
if keycode_tuple[1] & 1:
modmask |= modifier.SHIFT_MASK
else:
keycode_tuple = keycodes[0]
keycode = keycode_tuple[0] - 8
if pressed != None:
if not pressed:
modmask |= modifier.RELEASE_MASK
handled = ic.process_key_event(keyval, keycode, modmask)
else:
handled_p = ic.process_key_event(keyval, keycode, modmask)
handled_r = ic.process_key_event(keyval, keycode,
modmask | modifier.RELEASE_MASK)
handled = handled_p or handled_r
glib.idle_add(reply, id_no, handled)
def process_key_event(id_no, keyval, modmask, backslash, pressed=None):
def update_keymap():
display._update_keymap(display.display.info.min_keycode,
(display.display.info.max_keycode -
display.display.info.min_keycode + 1))
def reply(id_no, handled):
print_command('ibus_process_key_event_cb', id_no, handled)
return False
ic = imcontexts[id_no]
if use_surrounding_text and pressed != False \
and ic.needs_surrounding_text() and not ic.surrouding_text_received:
print_command('ibus_query_surrounding_text_cb', id_no, keyval, modmask,
backslash, pressed)
return
if backslash:
keycode = display.keysym_to_keycode(backslash) - 8
if keycode < 0:
update_keymap()
keycode = display.keysym_to_keycode(backslash) - 8
else:
keycodes = display.keysym_to_keycodes(keyval)
if not keycodes:
update_keymap()
keycodes = display.keysym_to_keycodes(keyval) or [(0, 0)]
if modmask & modifier.SHIFT_MASK:
for keycode_tuple in keycodes:
if keycode_tuple[1] & 1:
break
else:
keycode_tuple = keycodes[0]
elif keyval < 0x100:
for keycode_tuple in keycodes:
if keycode_tuple[1]:
if keycode_tuple[1] > 1:
keycode_tuple = keycodes[0]
break
else:
keycode_tuple = keycodes[0]
if keycode_tuple[1] & 1:
modmask |= modifier.SHIFT_MASK
else:
keycode_tuple = keycodes[0]
keycode = keycode_tuple[0] - 8
if pressed != None:
if not pressed:
modmask |= modifier.RELEASE_MASK
handled = ic.process_key_event(keyval, keycode, modmask)
else:
handled_p = ic.process_key_event(keyval, keycode, modmask)
handled_r = ic.process_key_event(keyval, keycode,
modmask | modifier.RELEASE_MASK)
handled = handled_p or handled_r
glib.idle_add(reply, id_no, handled)
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()
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()
def remap_keys(remap):
""" Remap keycode -> keysym for function keys
The keycode -> keysym mapping is so that the keycode generated
when the F1 key is pressed sends the F25 keysym. But to do that you
need to know the keycodes for F1-10, for Linux on x86 the keycode for
F1 is 67 but for other platforms it could be different. So the code
looks up the keycode mapped to F1 keysym if that is non zero (i.e. F1
is mapped) I map that keycode to F1 or F25 as required, if F1 is not
mapped I lookup the keycode for F25 and if that is non zero I map
that keycode to F1 or F25 as required. If F1 and F25 are not mapped
to any keycode I use 67 as the keycode for the F1 key. The code
assumes that the keycodes for F1-10 are sequential which may not be
true for all platforms. A more robust solution may be found by
accessing the keyboard layout somehow but I haven't had time to look
yet.
"""
display = Xlib.display.Display()
# only keycodes 8 to 255 are defined
first_keycode = 8
keymaps_orig = display.get_keyboard_mapping(first_keycode, 255 - first_keycode)
keymaps = list(keymaps_orig)
if remap == True:
keysym = 65494
else:
keysym = 65470
keycode_F1 = display.keysym_to_keycode(65470)
keycode_F25 = display.keysym_to_keycode(65494)
# set first_fkeycode to a sensible default incase F1 and F25 are not mapped
first_fkeycode = 67
if keycode_F1 > 0:
first_fkeycode = keycode_F1
elif keycode_F25 > 0:
first_fkeycode = keycode_F25
for i in range(0, 10):
keymaps[(i + first_fkeycode - first_keycode)][0] = keysym + i
keymaps[(i + first_fkeycode - first_keycode)][2] = keysym + i
keymaps[(i + first_fkeycode - first_keycode)][4] = keysym + i
display.change_keyboard_mapping(first_keycode, keymaps, onerror = None)
display.sync()
display.close()
def remap_keys(remap):
""" Remap keycode -> keysym for function keys
The keycode -> keysym mapping is so that the keycode generated
when the F1 key is pressed sends the F25 keysym. But to do that you
need to know the keycodes for F1-10, for Linux on x86 the keycode for
F1 is 67 but for other platforms it could be different. So the code
looks up the keycode mapped to F1 keysym if that is non zero (i.e. F1
is mapped) I map that keycode to F1 or F25 as required, if F1 is not
mapped I lookup the keycode for F25 and if that is non zero I map
that keycode to F1 or F25 as required. If F1 and F25 are not mapped
to any keycode I use 67 as the keycode for the F1 key. The code
assumes that the keycodes for F1-10 are sequential which may not be
true for all platforms. A more robust solution may be found by
accessing the keyboard layout somehow but I haven't had time to look
yet.
"""
display = Xlib.display.Display()
# only keycodes 8 to 255 are defined
first_keycode = 8
keymaps_orig = display.get_keyboard_mapping(first_keycode, 255 - first_keycode)
keymaps = list(keymaps_orig)
if remap == True:
keysym = 65494
else:
keysym = 65470
keycode_F1 = display.keysym_to_keycode(65470)
keycode_F25 = display.keysym_to_keycode(65494)
# set first_fkeycode to a sensible default incase F1 and F25 are not mapped
first_fkeycode = 67
if keycode_F1 > 0:
first_fkeycode = keycode_F1
elif keycode_F25 > 0:
first_fkeycode = keycode_F25
for i in range(0, int(number_of_suggestions)):
keymaps[(i + first_fkeycode - first_keycode)][0] = keysym + i
keymaps[(i + first_fkeycode - first_keycode)][2] = keysym + i
keymaps[(i + first_fkeycode - first_keycode)][4] = keysym + i
display.change_keyboard_mapping(first_keycode, keymaps, onerror = None)
display.sync()
display.close()
def right_action():
keycode = display.keysym_to_keycode(
Xlib.XK.string_to_keysym('Right')
)
Xlib.ext.xtest.fake_input(display, Xlib.X.KeyPress, keycode)
Xlib.ext.xtest.fake_input(display, Xlib.X.KeyRelease, keycode)
display.sync()
def char_to_keycode(ch):
keysym = get_keysym(ch)
keycode = display.keysym_to_keycode(keysym)
if keycode == 0:
print "Sorry, can't map", ch
return keycode
def char_to_keycode(ch):
keysym = get_keysym(ch)
keycode = display.keysym_to_keycode(keysym)
if keycode == 0:
print "Sorry, can't map", ch
return keycode
def char_to_keycode(ch) : keysym = get_keysym(ch) # print keysym keycode = display.keysym_to_keycode(keysym) # if keycode == 0 : # print "Sorry, can't map", ch # print keycode return keycode
def char_to_keycode(ch):
keysym = get_keysym(ch)
keycode = display.keysym_to_keycode(keysym)
keysym2 = display.keycode_to_keysym(keycode, 0)
if keysym != keysym2:
return keycode, True
else:
return keycode, False
def char_to_keycode(ch):
keysym = get_keysym(ch)
# print keysym
keycode = display.keysym_to_keycode(keysym)
# if keycode == 0 :
# print "Sorry, can't map", ch
# print keycode
return keycode
def char_to_keycode(ch) : keysym = get_keysym(ch) keycode = display.keysym_to_keycode(keysym) keysym2=display.keycode_to_keysym(keycode,0) if keysym != keysym2 : return keycode , True else : return keycode , False
def _find_mask(self, display, symbol):
modifier_keycode = display.keysym_to_keycode(
Xlib.XK.string_to_keysym(symbol))
for index, keycodes in enumerate(display.get_modifier_mapping()):
for keycode in keycodes:
if keycode == modifier_keycode:
return 1 << index
return 0
def char_to_keycode(ch) :
keysym = get_keysym(ch)
keycode = display.keysym_to_keycode(keysym)
if keycode == 0 :
print "Sorry, can't map", ch
if (is_shifted(ch)) :
shift_mask = Xlib.X.ShiftMask
else :
shift_mask = 0
return keycode, shift_mask
def char_to_keycode(ch):
keysym = get_keysym(ch)
keycode = display.keysym_to_keycode(keysym)
if keycode == 0:
print "Sorry, can't map", ch
if (is_shifted(ch)):
shift_mask = Xlib.X.ShiftMask
else:
shift_mask = 0
return keycode, shift_mask
def sequence2codes(display, sequence):
'''Convert a string to a series of keycodes to be gobled by CRiSP.'''
# start with F16
codes = [F16]
for string in sequence:
# add "<" to signal start of character
codes.append(Less)
for letter in string:
if letter.isupper():
# tuple indicates key with modifier pressed
codes.append((Shift_L, display.keysym_to_keycode(ord(letter))))
else:
# int means regular keycode
codes.append(display.keysym_to_keycode(ord(letter)))
# add ">" to signal end of character
codes.append((Shift_L, Less))
# finish with "Return"
codes.append(Return)
return codes
def send_key(emulated_key): window = display.get_input_focus()._data["focus"]; # Generate the correct keycode keysym = Xlib.XK.string_to_keysym(emulated_key) keycode = display.keysym_to_keycode(keysym) # Send a fake keypress via xtest Xlib.ext.xtest.fake_input(display, Xlib.X.KeyPress, keycode) display.sync() time.sleep(0.5) Xlib.ext.xtest.fake_input(display, Xlib.X.KeyRelease, keycode) display.sync()
def perform_key_event(accelerator, press, delay):
import Xlib
from Xlib import X
from Xlib.display import Display
from Xlib.ext.xtest import fake_input
from Xlib.protocol.event import KeyPress, KeyRelease
import time
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, Gdk, GdkX11
keysym, modifiers = Gtk.accelerator_parse(accelerator)
display = Display()
# root = display.screen().root
# window = root.query_pointer().child
# window.set_input_focus(X.RevertToParent, X.CurrentTime)
# window.configure(stack_mode=X.Above)
# display.sync()
keycode = display.keysym_to_keycode(keysym)
if press:
event_type = X.KeyPress
else:
event_type = X.KeyRelease
if keycode != 0:
if 'GDK_CONTROL_MASK' in modifiers.value_names:
modcode = display.keysym_to_keycode(Gdk.KEY_Control_L)
fake_input(display, event_type, modcode, delay)
if 'GDK_SHIFT_MASK' in modifiers.value_names:
modcode = display.keysym_to_keycode(Gdk.KEY_Shift_L)
fake_input(display, event_type, modcode, delay)
fake_input(display, event_type, keycode, delay)
display.sync()
def grab_keys(keys): for (code, mask), func in keys.items(): code = display.keysym_to_keycode(code) if (code, mask) == (0, 0): continue bound[code, mask] = func bound[code, mask | X.Mod2Mask] = func bound[code, mask | X.LockMask] = func bound[code, mask | X.Mod2Mask | X.LockMask] = func root = display.screen().root for key in bound.keys(): root.grab_key(key[0], key[1], 1, X.GrabModeAsync, X.GrabModeAsync) display.sync()
def release_key(keysym, shift_mask = 0) :
keycode = display.keysym_to_keycode(keysym)
if (UseXTest) :
Xlib.ext.xtest.fake_input(display, Xlib.X.KeyRelease, keycode)
if shift_mask != 0 :
Xlib.ext.xtest.fake_input(display, Xlib.X.KeyRelease, 50)
else :
event = Xlib.protocol.event.KeyRelease(
time = int(time.time()),
root = display.screen().root,
window = window,
same_screen = 0, child = Xlib.X.NONE,
root_x = 0, root_y = 0, event_x = 0, event_y = 0,
state = shift_mask,
detail = keycode
)
window.send_event(event, propagate = True)
display.sync()
def main():
display = Xlib.display.Display()
root = display.screen().root
root.change_attributes(event_mask = X.KeyReleaseMask)
screen = wnck.screen_get_default()
screen.force_update()
(root_width, root_height) = (screen.get_width(),
screen.get_height() - PANEL_HEIGHT)
for keysym in KEYMAP:
if keysym == XK.XK_Num_Lock:
modifier_mask = 0
elif keysym < XK.XK_KP_1:
modifier_mask = KEY_MODIFIER_MASK
else:
modifier_mask = PAD_MODIFIER_MASK
root.grab_key(display.keysym_to_keycode(keysym), modifier_mask, True,
X.GrabModeAsync, X.GrabModeAsync)
check_num_lock()
while True:
event = root.display.next_event()
run_idle()
if event.type == X.KeyRelease:
run_idle()
(root_width, root_height) = (screen.get_width(),
screen.get_height() - PANEL_HEIGHT)
w = screen.get_active_window()
for i in range(4):
try:
func = KEYMAP[display.keycode_to_keysym(event.detail, i)]
break
except KeyError:
continue
else:
raise
x, y, width, height = w.get_geometry()
y -= PANEL_HEIGHT
g = func(w, (root_width, root_height), (x, y, width, height))
if g is not None:
print w.get_name(), (x, y, width, height), g
w.set_geometry(0, 15, g[0], g[1], g[2], g[3])
run_idle()
def _find_mask(display, symbol):
"""Returns the mode flags to use for a modifier symbol.
:param Xlib.display.Display display: The *X* display.
:param str symbol: The name of the symbol.
:return: the modifier mask
"""
# Get the key code for the symbol
modifier_keycode = display.keysym_to_keycode(
Xlib.XK.string_to_keysym(symbol))
for index, keycodes in enumerate(display.get_modifier_mapping()):
for keycode in keycodes:
if keycode == modifier_keycode:
return 1 << index
return 0
def _find_mask(display, symbol):
"""Returns the mode flags to use for a modifier symbol.
:param Xlib.display.Display display: The *X* display.
:param str symbol: The name of the symbol.
:return: the modifier mask
"""
# Get the key code for the symbol
modifier_keycode = display.keysym_to_keycode(
Xlib.XK.string_to_keysym(symbol))
for index, keycodes in enumerate(display.get_modifier_mapping()):
for keycode in keycodes:
if keycode == modifier_keycode:
return 1 << index
return 0
actions["Mouse Move Slow Up"] = Action(win32KeyCode = (0,-5),mouseMovement=True)
actions["Mouse Move Slow Down"] = Action(win32KeyCode = (0,5),mouseMovement=True)
actions["Mouse Move Fast Left"] = Action(win32KeyCode = (-50,0),mouseMovement=True)
actions["Mouse Move Fast Right"] = Action(win32KeyCode = (50,0),mouseMovement=True)
actions["Mouse Move Fast Up"] = Action(win32KeyCode = (0,-50),mouseMovement=True)
actions["Mouse Move Fast Down"] = Action(win32KeyCode = (0,50),mouseMovement=True)
actions["Tab"] = Action(win32KeyCode = 0x09,extend=True )
actions["Shift"] = Action(win32KeyCode = 0x10,extend=True )
actions["Control"] = Action(win32KeyCode = 0x11,extend=True )
actions["Alt"] = Action(win32KeyCode = 0x12,extend=True )
if haveXlib:
display = Xlib.display.Display()
for each in "1234567890abcdefghijklmnopqrstuvwxyz":
actions[each] = Action(xLibKeyCode= display.keysym_to_keycode(ord(each)))
#actions[each.upper()] = Action(xLibKeyCode= display.keysym_to_keycode(each),shiftDown=True)
#actions["Ctrl "+each] = Action(xLibKeyCode= display.keysym_to_keycode(each),controlDown=True)
#actions["Ctrl "+each.upper()] = Action(xLibKeyCode= display.keysym_to_keycode(each),shiftDown=True,controlDown=True)
#actions["Alt "+each] = Action(xLibKeyCode= display.keysym_to_keycode(each),altDown=True)
#actions["Alt "+each.upper()] = Action(xLibKeyCode= display.keysym_to_keycode(each),shiftDown=True,altDown=True)
#actions["Ctrl Alt "+each] = Action(xLibKeyCode= display.keysym_to_keycode(each),controlDown=True,altDown=True)
#actions["Ctrl Alt "+each.upper()] = Action(xLibKeyCode= display.keysym_to_keycode(each),shiftDown=True,controlDown=True,altDown=True)
actions["Arrow Left"] = Action(xLibKeyCode=113)
actions["Arrow Right"] = Action(xLibKeyCode=114)
actions["Arrow Up"] = Action(xLibKeyCode=111)
actions["Arrow Down"] = Action(xLibKeyCode=116)
actions["F1"] = Action(xLibKeyCode=67)
actions["F2"] = Action(xLibKeyCode=68)
actions["F3"] = Action(xLibKeyCode=69)
actions["F4"] = Action(xLibKeyCode=70)
def getSpecialkeycode(keyname):
for speciealKey in specialKeys:
if speciealKey[0] == keyname:
return display.keysym_to_keycode(speciealKey[1])
return 0
def getSpecialkeycode(keyname): for speciealKey in specialKeys : if speciealKey[0] == keyname : return display.keysym_to_keycode(speciealKey[1]) return 0
actions["Mouse Move Fast Right"] = Action(win32KeyCode=(50, 0),
mouseMovement=True)
actions["Mouse Move Fast Up"] = Action(win32KeyCode=(0, -50),
mouseMovement=True)
actions["Mouse Move Fast Down"] = Action(win32KeyCode=(0, 50),
mouseMovement=True)
actions["Tab"] = Action(win32KeyCode=0x09, extend=True)
actions["Shift"] = Action(win32KeyCode=0x10, extend=True)
actions["Control"] = Action(win32KeyCode=0x11, extend=True)
actions["Alt"] = Action(win32KeyCode=0x12, extend=True)
if haveXlib:
display = Xlib.display.Display()
for each in "1234567890abcdefghijklmnopqrstuvwxyz":
actions[each] = Action(
xLibKeyCode=display.keysym_to_keycode(ord(each)))
#actions[each.upper()] = Action(xLibKeyCode= display.keysym_to_keycode(each),shiftDown=True)
#actions["Ctrl "+each] = Action(xLibKeyCode= display.keysym_to_keycode(each),controlDown=True)
#actions["Ctrl "+each.upper()] = Action(xLibKeyCode= display.keysym_to_keycode(each),shiftDown=True,controlDown=True)
#actions["Alt "+each] = Action(xLibKeyCode= display.keysym_to_keycode(each),altDown=True)
#actions["Alt "+each.upper()] = Action(xLibKeyCode= display.keysym_to_keycode(each),shiftDown=True,altDown=True)
#actions["Ctrl Alt "+each] = Action(xLibKeyCode= display.keysym_to_keycode(each),controlDown=True,altDown=True)
#actions["Ctrl Alt "+each.upper()] = Action(xLibKeyCode= display.keysym_to_keycode(each),shiftDown=True,controlDown=True,altDown=True)
actions["Arrow Left"] = Action(xLibKeyCode=113)
actions["Arrow Right"] = Action(xLibKeyCode=114)
actions["Arrow Up"] = Action(xLibKeyCode=111)
actions["Arrow Down"] = Action(xLibKeyCode=116)
actions["F1"] = Action(xLibKeyCode=67)
actions["F2"] = Action(xLibKeyCode=68)
actions["F3"] = Action(xLibKeyCode=69)
actions["F4"] = Action(xLibKeyCode=70)
import os
if os.name == 'nt':
# Windows
import win32com.client
shell = win32com.client.Dispatch("WScript.Shell")
elif os.name == 'posix':
# Linux
import Xlib.display
import Xlib.X
import Xlib.XK
import Xlib.protocol.event
import Xlib.ext.xtest
display = Xlib.display.Display()
ctrlkey=display.keysym_to_keycode(Xlib.XK.XK_Control_L)
altkey=display.keysym_to_keycode(Xlib.XK.XK_Alt_L)
shiftkey=display.keysym_to_keycode(Xlib.XK.XK_Shift_L)
specialKeys = (
("BACKSPACE",Xlib.XK.XK_BackSpace),
("BS",Xlib.XK.XK_BackSpace),
("BKSP",Xlib.XK.XK_BackSpace),
("BREAK",Xlib.XK.XK_Break),
("CAPSLOCK",Xlib.XK.XK_Caps_Lock),
("DELETE",Xlib.XK.XK_Delete),
("DEL",Xlib.XK.XK_Delete),
("DOWN",Xlib.XK.XK_Down),
("END",Xlib.XK.XK_End),
("ENTER",Xlib.XK.XK_KP_Enter),
("ESC",Xlib.XK.XK_Escape),
def main():
import sys
FORMAT = '%(asctime)-15s: %(message)s'
level = logging.INFO
if '-v' in sys.argv:
level = logging.DEBUG
logging.basicConfig(format=FORMAT, level=level)
display = Xlib.display.Display()
root = display.screen().root
root.change_attributes(event_mask = X.KeyReleaseMask)
wscreen = wnck.screen_get_default()
wscreen.force_update()
gscreen = gtk.gdk.screen_get_default()
name_to_plists = setup_plist_map(gscreen)
keysym_to_plists = {}
for keystr, put_type in OPTS.keymap.iteritems():
keysym, keymask = keystr_to_sym_mask(keystr)
if not keysym:
continue
logging.debug('%r (keysym %r, keymask %r) => %s', keystr, keysym,
keymask, put_type)
keysym_to_plists[keysym] = name_to_plists[put_type]
root.grab_key(display.keysym_to_keycode(keysym), keymask, True,
X.GrabModeAsync, X.GrabModeAsync)
check_num_lock()
while True:
event = root.display.next_event()
run_idle()
if event.type != X.KeyRelease:
continue
run_idle()
for i in range(4):
try:
keysym = display.keycode_to_keysym(event.detail, i)
plists = keysym_to_plists[keysym]
break
except KeyError:
continue
else:
logging.warning('got unhandled event %r', event)
continue
gw = gscreen.get_active_window()
if gw is None:
continue
mon_idx = gscreen.get_monitor_at_window(gw)
plist = plists[mon_idx]
wextents = gw.get_frame_extents()
p = get_next_placement(plist, wextents)
ww = wscreen.get_active_window()
logging.debug('%r (%d, %d, %d, %d) -> (%d, %d, %d, %d)',
ww.get_name(), wextents.x, wextents.y, wextents.width,
wextents.height, p.x, p.y, p.w, p.h)
if ww is None:
continue
if not p.maximize:
ww.unmaximize()
# ww.set_geometry(0, 15, p.x, p.y, p.w, p.h)
# workaround for set_geometry() not incorporating window decorations.
dg = ww.get_client_window_geometry()
ww.set_geometry(0, 15, p.x + (wextents.x - dg[0]),
p.y + (wextents.y - dg[1]), p.w, p.h)
if p.maximize:
ww.maximize()
run_idle()
# 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 = Xlib.XK.string_to_keysym(special_X_keysyms[ch])
return keysym
def char_to_keycode(ch) :
keysym = get_keysym(ch)
# print keysym
keycode = display.keysym_to_keycode(keysym)
# if keycode == 0 :
# print "Sorry, can't map", ch
# print keycode
return keycode
ctrlkey=display.keysym_to_keycode(Xlib.XK.XK_Control_L)
altkey=display.keysym_to_keycode(Xlib.XK.XK_Alt_L)
shiftkey=display.keysym_to_keycode(Xlib.XK.XK_Shift_L)
def sendkey(keystroke):
ctrl = alt = shift = 0
key = ""
splitted = keystroke.split(" ")
for stroke in splitted:
if stroke == "Ctrl":
ctrl = 1
elif stroke == "Shift":
shift = 1
elif stroke == "Alt":
alt = 1
elif stroke == "Space":
def keysym_to_keycode(keysym):
keycode = display.keysym_to_keycode(keysym)
shift_mask = 0
return keycode, shift_mask
# Image data, RGBA8 format, bottom-left coordinates
# Note that OpenCV expects BGRA8 and top-left coordinates
image = None
blob_pos = (0.0, 0.0)
mouse_down = 0
cursor_posx = 0.0
cursor_posy = 0.0
# X11 junk
display = Xlib.display.Display()
dest_window = None
charkeys = {
'w': display.keysym_to_keycode(latin1.XK_w),
'a': display.keysym_to_keycode(latin1.XK_a),
's': display.keysym_to_keycode(latin1.XK_s),
'd': display.keysym_to_keycode(latin1.XK_d),
'Escape': display.keysym_to_keycode(miscellany.XK_Escape)
}
old_keys = []
# Blob detector instance
params = cv2.SimpleBlobDetector_Params()
params.blobColor = 255
detector = cv2.SimpleBlobDetector(params)
def render():
global image
def _get_keycode(char):
return display.keysym_to_keycode(_get_keysym(char))
def keysym_to_keycode(keysym):
keycode = display.keysym_to_keycode(keysym)
shift_mask = 0
return keycode, shift_mask
def send_keysym( keysym, display ):
key = display.keysym_to_keycode( keysym )
Xlib.ext.xtest.fake_input(display, Xlib.X.KeyPress, key)
Xlib.ext.xtest.fake_input(display, Xlib.X.KeyRelease, key)
display.sync()