def processevents(self, reply):
if reply.category != record.FromServer:
return True # no blocking
if reply.client_swapped:
print("* received swapped protocol data, cowardly ignored")
return True
if not len(reply.data) or ord(str(reply.data[0])) < 2:
print("not an event")
# not an event
return True
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(
data, self.record_dpy.display, None, None)
if self.stop_process:
break
if event.type == X.KeyPress:
# print("data:"+ str(data))
hookevent = self.keypressevent(event)
consume = not self.KeyDown(hookevent)
if not consume:
self.post_key_tap(event)
elif event.type == X.KeyRelease:
hookevent = self.keyreleaseevent(event)
self.KeyUp(hookevent)
def parse_signal(self, signal):
"""Разбор полученных сигналов."""
data = signal.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(data, self.disp.display, None, None)
if event.type == X.KeyPress:
self.events.get(event.detail, self.do_nothing)()
def processevents(self, reply):
if reply.category != record.FromServer:
return
if reply.client_swapped:
print "* received swapped protocol data, cowardly ignored"
return
if not len(reply.data) or ord(reply.data[0]) < 2:
# not an event
return
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(
data, self.record_dpy.display, None, None)
if event.type == X.KeyPress:
hookevent = self.keypressevent(event)
self.KeyDown(hookevent)
elif event.type == X.KeyRelease:
hookevent = self.keyreleaseevent(event)
self.KeyUp(hookevent)
elif event.type == X.ButtonPress:
hookevent = self.buttonpressevent(event)
self.MouseAllButtonsDown(hookevent)
elif event.type == X.ButtonRelease:
hookevent = self.buttonreleaseevent(event)
self.MouseAllButtonsUp(hookevent)
elif event.type == X.MotionNotify:
# use mouse moves to record mouse position, since press and release events
# do not give mouse position info (event.root_x and event.root_y have
# bogus info).
self.mousemoveevent(event)
def record_callback(reply):
if reply.category != record.FromServer:
return
if reply.client_swapped:
print("* received swapped protocol data, cowardly ignored")
return
if not len(reply.data) or reply.data[0] < 0x02:
# not an event
return
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(
data, record_dpy.display, None, None)
if event.type in [X.KeyPress, X.KeyRelease]:
pr = event.type == X.KeyPress and "Press" or "Release"
keysym = local_dpy.keycode_to_keysym(event.detail, 0)
if not keysym:
print("KeyCode {} {}".format(pr, event.detail))
else:
print("KeyStr {} {}".format(pr, lookup_keysym(keysym)))
sys.stdout.flush()
elif event.type == X.ButtonPress:
print("MouseButton Press {}".format(event.detail))
sys.stdout.flush()
elif event.type == X.ButtonRelease:
print("MouseButton Release {}".format(event.detail))
sys.stdout.flush()
def record_callback(reply):
if reply.category != record.FromServer:
return
if reply.client_swapped:
print("* received swapped protocol data, cowardly ignored")
return
if not len(reply.data) or reply.data[0] < 2:
# not an event
return
line = ''
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(
data, record_dpy.display, None, None)
if event.type == X.KeyPress:
keysym = local_dpy.keycode_to_keysym(event.detail, 0)
if not keysym:
print(f"KeyCode {event.detail}")
else:
if lookup_keysym(keysym) == 'Return':
sys.stdout.write('\n')
else:
line += lookup_keysym(keysym)
sys.stdout.write(line)
sys.stdout.flush()
def _record_callback(self, reply):
if reply.category != record.FromServer:
return
if reply.client_swapped:
return
if not len(reply.data) or ord(reply.data[0]) < 2:
# not an event
return
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(
data, record_dpy.display, None, None)
if event.type in [X.KeyPress, X.KeyRelease]:
pr = event.type == X.KeyPress and "Press" or "Release"
logger.debug("Event detail = %s", event.detail)
keysym = local_dpy.keycode_to_keysym(event.detail, 0)
if not keysym:
logger.debug("Recorded %s", event.detail)
self._record_key_callback(event, event.detail)
else:
logger.debug("Keysym = %s", str(keysym))
s = self._lookup_keysym(keysym)
logger.debug("Recorded %s", s)
self._record_key_callback(event, s)
def key_press(self, reply):
# FIXME:
# This is not the most efficient way to detect the
# use of sudo/gksudo but it works.
if not self.nosudo:
sudo_is_running = subprocess.call(['ps', '-C', 'sudo'],
stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
if not sudo_is_running:
return
if reply.category != record.FromServer:
return
if reply.client_swapped:
self.logger.warning(
"* received swapped protocol data, cowardly ignored"
)
return
if not len(reply.data) or ord(reply.data[0]) < 2:
# not an event
return
data = reply.data
key = []
while len(data):
event, data = rq.EventField(None).parse_binary_value(data,
self.record_dpy.display, None, None)
if event.type in [X.KeyPress, X.KeyRelease]:
if self.mode == MODE_NORMAL:
key.append(self.key_normal_mode(event))
if self.mode == MODE_RAW:
key.append(self.key_raw_mode(event))
if any(key):
self.update_text(''.join(k for k in key if k))
def handler(self, reply):
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(
data, self.display.display, None, None
)
if event.type in (X.KeyPress, X.KeyRelease):
keysym = self.display.keycode_to_keysym(event.detail, 0)
if keysym in self.active_keys:
self.active_keys[keysym] = (
True if event.type == X.KeyPress else False
)
elif keysym in self.modifying_keys:
self.modifying_keys[keysym] = (
True if event.type == X.KeyPress else False
)
if all(self.active_keys.values()):
self.coordinates.add(event.root_x, event.root_y)
if (event.type, event.detail) == (X.ButtonRelease, X.Button1):
snap_window(self, event.root_x, event.root_y)
elif event.type == X.KeyPress:
keysym = self.display.keycode_to_keysym(event.detail, 0)
shift_window(self, keysym)
else:
self.coordinates.clear()
def record_callback(reply):
if reply.category != record.FromServer:
return
if reply.client_swapped:
print("* received swapped protocol data, cowardly ignored")
return
if not len(reply.data) or reply.data[0] < 2:
# not an event
return
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(data, record_dpy.display, None, None)
if event.type in [X.KeyPress, X.KeyRelease]:
pr = event.type == X.KeyPress and "Press" or "Release"
keysym = local_dpy.keycode_to_keysym(event.detail, 0)
if not keysym:
print("KeyCode%s" % pr, event.detail)
else:
print("KeyStr%s" % pr, lookup_keysym(keysym))
if event.type == X.KeyPress and keysym == XK.XK_Escape:
local_dpy.record_disable_context(ctx)
local_dpy.flush()
return
elif event.type == X.ButtonPress:
print("ButtonPress", event.detail)
elif event.type == X.ButtonRelease:
print("ButtonRelease", event.detail)
elif event.type == X.MotionNotify:
print("MotionNotify", event.root_x, event.root_y)
def handler(self, reply):
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(
data, self.recording_connection.display, None, None)
if event.type == X.KeyPress:
format_key_event(event)
class SendEvent(rq.Request):
_request = rq.Struct(
rq.Opcode(25),
rq.Bool('propagate'),
rq.RequestLength(),
rq.Window('destination'),
rq.Card32('event_mask'),
rq.EventField('event'),
)
def record_callback(reply):
if reply.category != record.FromServer:
return
if reply.client_swapped:
print "* received swapped protocol data, cowardly ignored"
return
if not len(reply.data) or ord(reply.data[0]) < 2:
# not an event
return
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(
data, record_dpy.display, None, None)
if event.type in [
X.KeyPress, X.KeyRelease, X.ButtonPress, X.ButtonRelease,
X.MotionNotify
]:
se = {
'type': event.type,
'x': 0,
'y': 0,
'button': 0,
'key': 0,
'pressed': False
}
if event.type in [X.KeyPress, X.KeyRelease]:
pr = event.type == X.KeyPress and "Press" or "Release"
keysym = local_dpy.keycode_to_keysym(event.detail, 0)
se['key'] = event.detail
if not keysym:
print "KeyCode%s" % pr, event.detail
else:
print "KeyStr%s" % pr, lookup_keysym(keysym)
if event.type == X.KeyPress and keysym == XK.XK_Escape:
local_dpy.record_disable_context(ctx)
local_dpy.flush()
return
elif event.type == X.ButtonPress:
print "ButtonPress", event.detail
se['pressed'] = True
se['button'] = event.detail
elif event.type == X.ButtonRelease:
print "ButtonRelease", event.detail
se['button'] = event.detail
elif event.type == X.MotionNotify:
print "MotionNotify", event.root_x, event.root_y
se['x'] = event.root_x
se['y'] = event.root_y
rec.append((time.time(), se))
def handle_event(self, reply):
""" This 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._display.display, None, None)
if event.type == X.KeyPress and event.sequence_number == 0:
key = event.detail
self._queue.put([self._name, key])
def handler(self, reply):
"""Upper level handler of keyboard events."""
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(data, self.display.display, None, None)
if self.escape(event): # Quit if this returns True
self.stop()
else:
self._tap(event)
def handler(self, reply):
""" This 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)
# KEYCODE IS FOUND USERING event.detail
if event.type == X.KeyPress and event.detail == 33:
self.suspendQueue.put(event)
def handlingfunc(self, ur):
idk = ur.data
while len(idk):
aa, bb = rq.EventField(None).parse_binary_value(
idk, self.dLi.display, None, None)
if aa.type in (2, 3) and aa.detail in availableevents:
return self.passto(aa.type, aa.detail)
else:
return
def process_events(self, event):
if event.category != record.FromServer:
return
if event.client_swapped:
return
if not len(event.data) or event.data[0] < 2:
return
data = event.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(
data, self.hook_display.display, None, None)
mods = {
'SHIFT': False,
'ALTGR': False,
'CTRL': False,
'ALT': False,
'META': False
}
if event.state & self.translate.modmask['SHIFT']:
mods['SHIFT'] = True
if event.state & self.translate.modmask['ALTGR']:
mods['ALTGR'] = True
if event.state & self.translate.modmask['CTRL']:
mods['CTRL'] = True
if event.state & self.translate.modmask['ALT']:
mods['ALT'] = True
if event.state & self.translate.modmask['META']:
mods['META'] = True
if event.type == X.MotionNotify:
self.enqueue(
self.hook_callback,
PointerEventMotion(event.root_x, event.root_y, mods))
elif event.type in {X.ButtonPress, X.ButtonRelease}:
button = event.detail
state = (KeyState.PRESSED
if event.type == X.ButtonPress else KeyState.RELEASED)
if button in {1, 2, 3, 8, 9}:
self.enqueue(
self.hook_callback,
PointerEventButton(event.root_x, event.root_y,
self.buttonmap[button], state,
mods))
elif button in {4, 5, 6, 7}:
axis = (PointerAxis.VERTICAL
if button in {4, 5} else PointerAxis.HORIZONTAL)
if button in {4, 6}:
value = -1
else:
value = 1
self.enqueue(
self.hook_callback,
PointerEventAxis(event.root_x, event.root_y, value,
axis, mods))
def key_press_handler(reply):
global current_key_modifiers
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(data, display.display, None, None)
if event.type == X.KeyPress:
mod = modifier_code(event.detail)
current_key_modifiers = event.state | 1 << mod if mod is not None else event.state
elif event.type == X.KeyRelease:
mod = modifier_code(event.detail)
current_key_modifiers = event.state & ~(1 << mod) if mod is not None else event.state
def handler(self, reply):
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(data, display.display, None, None)
if event.type == X.ButtonPress:
self.click(event.root_x, event.root_y, (None, 1, 3, 2, 3, 3, 3)[event.detail], True)
elif event.type == X.ButtonRelease:
self.click(event.root_x, event.root_y, (None, 1, 3, 2, 3, 3, 3)[event.detail], False)
else:
self.move(event.root_x, event.root_y)
def event_handler(self, reply):
data = reply.data
while data:
event, data = rq.EventField(None).parse_binary_value(data, self.disp.display, None, None)
if event.type == X.KeyPress:
self.down(self.keycode_to_string(event.detail, event.state))
elif event.type == X.KeyRelease:
self.up(self.keycode_to_string(event.detail, event.state))
elif event.type == X.ButtonPress:
self.down(self.mouse_to_string(event.detail))
elif event.type == X.ButtonRelease:
self.up(self.mouse_to_string(event.detail))
def handler(reply):
""" This function is called when a xlib event is fired """
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(
data, disp.display, None, None)
# KEYCODE IS FOUND USERING event.detail
global ButtonClicked
ButtonClicked = int(event.detail)
if event.type == X.KeyPress:
if (event.detail == 66) or (event.detail == 77):
self.eventCapture.emit()
def record_callback(reply):
global curPoly
global record_dpy
global local_dpy
global ctx
if reply.category != record.FromServer:
return
if reply.client_swapped:
print("* received swapped protocol data, cowardly ignored")
return
if not len(reply.data) or reply.data[0] < 2:
# not an event
return
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(data, record_dpy.display, None, None)
if event.type in [X.KeyPress, X.KeyRelease]:
keysym = local_dpy.keycode_to_keysym(event.detail, 0)
# if not keysym:
# print("KeyCode%s" % pr, event.detail)
# else:
# print("KeyStr%s" % pr, lookup_keysym(keysym))
if event.type == X.KeyPress and lookup_keysym(keysym) == "n":
curPoly.startPoly()
if event.type == X.KeyRelease and lookup_keysym(keysym) == "n":
curPoly.endPoly()
# if event.type == X.KeyPress and keysym == XK.XK_Escape:
if event.type == X.KeyPress and keysym == XK.XK_grave:
local_dpy.record_disable_context(ctx)
local_dpy.flush()
return
elif event.type == X.ButtonPress:
# print("ButtonPress", event.detail)
if event.detail == 2:
curPoly.startPoly()
if event.detail == 5: # zoom out
curPoly.zoom = max(curPoly.zoom - 1, 1)
if event.detail == 4: # zoom in
curPoly.zoom = min(curPoly.zoom + 1, 32)
elif event.type == X.ButtonRelease:
# print("ButtonRelease", event.detail)
if event.detail == 2:
curPoly.endPoly()
elif event.type == X.MotionNotify:
# print("M``otionNotify", event.root_x, event.root_y)
curPoly.addVert(event.root_x, event.root_y)
def handler(self, reply):
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(data, self.display.display, None, None)
if event.detail in [4, 5, 6, 7]:
if event.type == X.ButtonPress:
self.scroll(event.root_x, event.root_y, *button_code_to_scroll_direction(event.detail))
elif event.type == X.ButtonPress:
self.click(event.root_x, event.root_y, translate_button_code(event.detail), True)
elif event.type == X.ButtonRelease:
self.click(event.root_x, event.root_y, translate_button_code(event.detail), False)
else:
self.move(event.root_x, event.root_y)
def update_keys(self, reply=None):
"""
Update the map self.keys according to user inputs.
It uses either the x11 method or the pygame events
:reply: If the x11 method is used, this is the message returned from x11
"""
with self.keys_lock:
if reply: # Use x11 events
data = reply.data
while len(data):
evt, data = rq.EventField(None).parse_binary_value(
data, self.record_dpy.display, None, None)
if evt.type in [X.KeyPress, X.KeyRelease]:
if evt.detail == X11_F1:
self.keys[0] = evt.type == X.KeyPress
elif evt.detail == X11_F2:
self.keys[1] = evt.type == X.KeyPress
elif evt.detail == X11_F3:
self.keys[2] = evt.type == X.KeyPress
elif evt.detail == X11_F4:
self.keys[3] = evt.type == X.KeyPress
elif evt.detail == X11_F5:
self.keys[4] = evt.type == X.KeyPress
else: # Use pygame events
for evt in self.arbalet.events.get():
if evt.type in [KEYDOWN, KEYUP]:
if evt.key == K_F1:
self.keys[0] = evt.type == KEYDOWN
elif evt.key == K_F2:
self.keys[1] = evt.type == KEYDOWN
elif evt.key == K_F3:
self.keys[2] = evt.type == KEYDOWN
elif evt.key == K_F4:
self.keys[3] = evt.type == KEYDOWN
elif evt.key == K_F5:
self.keys[4] = evt.type == KEYDOWN
elif evt.type == JOYBUTTONDOWN:
self.switch_simulation()
for event in self.arbalet.touch.get():
if event['key'] == 1:
self.keys[0] = event['type'] == 'down'
elif event['key'] == 2:
self.keys[1] = event['type'] == 'down'
elif event['key'] == 3:
self.keys[2] = event['type'] == 'down'
elif event['key'] == 4:
self.keys[3] = event['type'] == 'down'
elif event['key'] == 5:
self.keys[4] = event['type'] == 'down'
def handler(self, reply):
"""Upper level handler of keyboard events."""
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(data, self.display.display, None, None)
if event.type == X.KeyPress:
if self.escape_code(event): # Quit if this returns True
self.stop()
else:
self._key_press(event.detail)
elif event.type == X.KeyRelease:
self._key_release(event.detail)
else:
print('WTF: {0}'.format(event.type))
def get_events(self, reply):
if not len(reply.data) or ord(reply.data[0]) < 2:
return
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(
data, self.record_dpy.display, None, None)
if event.type in [X.KeyPress, X.KeyRelease]:
key_pressed = self.local_dpy.keycode_to_keysym(event.detail, 0)
if self.key_lookup(key_pressed) == "Caps_Lock":
self.app.update("caps")
if self.key_lookup(key_pressed) == "Num_Lock":
self.app.update("num")
if self.key_lookup(key_pressed) == "Scroll_Lock":
self.app.update("scroll")
def callback(reply):
if reply.category != record.FromServer:
return
if reply.client_swapped:
print("* received swapped protocol data, cowardly ignored")
return
if not len(reply.data) or reply.data[0] < 2: # not an event
return
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(
data, record_display.display, None, None)
if event.type == X.KeyPress:
keypress(event)
def _event_handler(self, reply):
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(data, self._display.display, None, None)
keysym = self._display.keycode_to_keysym(event.detail, 0)
if keysym in self._hold_keys.keys():
pressed_callback, released_callback = self._hold_keys[keysym]
if event.type == X.KeyPress:
if pressed_callback:
GLib.idle_add(pressed_callback)
elif event.type == X.KeyRelease:
if released_callback:
GLib.idle_add(released_callback)
def processevents(self, reply):
if reply.category != record.FromServer:
return
if reply.client_swapped:
return
if not len(reply.data) or ord(reply.data[0]) < 2:
# not an event
return
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(data, self.record_dpy.display, None, None)
if event.type == X.KeyPress:
self.keypressevent(event, KeyMonitor.PRESS)
elif event.type == X.KeyRelease:
self.keypressevent(event, KeyMonitor.RELEASE)
def handler(self, reply):
data = reply.data
while len(data):
event, data = rq.EventField(None).parse_binary_value(
data, self.recording_connection.display, None, None)
if event.detail in self.mod_keys_set:
self.modifiers_count += 1 if event.type == X.KeyPress else -1
self.modified_count = 0
continue
if self.modifiers_count:
self.modified_count += 1 if event.type == X.KeyPress else -1
if event.type == X.KeyPress:
self.handle_keypress(event)
