def test_handle_keycode_macro(self): history = [] code_a = 100 code_b = 101 system_mapping.clear() system_mapping._set('a', code_a) system_mapping._set('b', code_b) macro_mapping = { ((EV_KEY, 1, 1), ): parse('k(a)', self.mapping), ((EV_KEY, 2, 1), ): parse('r(5, k(b))', self.mapping) } macro_mapping[((EV_KEY, 1, 1), )].set_handler(lambda *args: history.append(args)) macro_mapping[((EV_KEY, 2, 1), )].set_handler(lambda *args: history.append(args)) handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 1), None) handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 2, 1), None) loop = asyncio.get_event_loop() sleeptime = config.get('macros.keystroke_sleep_ms', 10) * 12 # let the mainloop run for some time so that the macro does its stuff loop.run_until_complete(asyncio.sleep(sleeptime / 1000 + 0.1)) # 6 keycodes written, with down and up events self.assertEqual(len(history), 12) self.assertIn((code_a, 1), history) self.assertIn((code_a, 0), history) self.assertIn((code_b, 1), history) self.assertIn((code_b, 0), history)
def test_4(self): macro = parse(' r(2,\nk(\nr ).k(minus\n )).k(m) ', self.mapping) macro.set_handler(self.handler) r = system_mapping.get('r') minus = system_mapping.get('minus') m = system_mapping.get('m') self.assertSetEqual(macro.get_capabilities(), {r, minus, m}) self.loop.run_until_complete(macro.run()) self.assertListEqual(self.result, [ (r, 1), (r, 0), (minus, 1), (minus, 0), (r, 1), (r, 0), (minus, 1), (minus, 0), (m, 1), (m, 0), ]) self.assertEqual(len(macro.child_macros), 1) self.assertEqual(len(macro.child_macros[0].child_macros), 0)
def test_modify_capabilities(self): class FakeDevice: def capabilities(self, absinfo=True): assert absinfo is False return { evdev.ecodes.EV_SYN: [1, 2, 3], evdev.ecodes.EV_FF: [1, 2, 3], evdev.ecodes.EV_ABS: [1, 2, 3] } mapping = Mapping() mapping.change(Key(EV_KEY, 80, 1), 'a') mapping.change(Key(EV_KEY, 81, 1), DISABLE_NAME) macro_code = 'r(2, m(sHiFt_l, r(2, k(1).k(2))))' macro = parse(macro_code, mapping) mapping.change(Key(EV_KEY, 60, 111), macro_code) # going to be ignored, because EV_REL cannot be mapped, that's # mouse movements. mapping.change(Key(EV_REL, 1234, 3), 'b') a = system_mapping.get('a') shift_l = system_mapping.get('ShIfT_L') one = system_mapping.get(1) two = system_mapping.get('2') btn_left = system_mapping.get('BtN_lEfT') self.injector = KeycodeInjector('foo', mapping) fake_device = FakeDevice() capabilities_1 = self.injector._modify_capabilities({60: macro}, fake_device, abs_to_rel=False) self.assertIn(EV_KEY, capabilities_1) keys = capabilities_1[EV_KEY] self.assertIn(a, keys) self.assertIn(one, keys) self.assertIn(two, keys) self.assertIn(shift_l, keys) self.assertNotIn(DISABLE_CODE, keys) # abs_to_rel is false, so mouse capabilities are not needed self.assertNotIn(btn_left, keys) self.assertNotIn(evdev.ecodes.EV_SYN, capabilities_1) self.assertNotIn(evdev.ecodes.EV_FF, capabilities_1) self.assertNotIn(evdev.ecodes.EV_REL, capabilities_1) self.assertNotIn(evdev.ecodes.EV_ABS, capabilities_1) # abs_to_rel makes sure that BTN_LEFT is present capabilities_2 = self.injector._modify_capabilities({60: macro}, fake_device, abs_to_rel=True) keys = capabilities_2[EV_KEY] self.assertIn(a, keys) self.assertIn(one, keys) self.assertIn(two, keys) self.assertIn(shift_l, keys) self.assertIn(btn_left, keys)
def test_hold(self): history = [] code_a = 100 code_b = 101 code_c = 102 system_mapping.clear() system_mapping._set('a', code_a) system_mapping._set('b', code_b) system_mapping._set('c', code_c) macro_mapping = { ((EV_KEY, 1, 1), ): parse('k(a).h(k(b)).k(c)', self.mapping) } def handler(*args): history.append(args) macro_mapping[((EV_KEY, 1, 1), )].set_handler(handler) """start macro""" handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 1), None) loop = asyncio.get_event_loop() # let the mainloop run for some time so that the macro does its stuff sleeptime = 500 keystroke_sleep = config.get('macros.keystroke_sleep_ms', 10) loop.run_until_complete(asyncio.sleep(sleeptime / 1000)) self.assertTrue(active_macros[(EV_KEY, 1)].holding) self.assertTrue(active_macros[(EV_KEY, 1)].running) """stop macro""" handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 0), None) loop.run_until_complete(asyncio.sleep(keystroke_sleep * 10 / 1000)) events = calculate_event_number(sleeptime, 1, 1) self.assertGreater(len(history), events * 0.9) self.assertLess(len(history), events * 1.1) self.assertIn((code_a, 1), history) self.assertIn((code_a, 0), history) self.assertIn((code_b, 1), history) self.assertIn((code_b, 0), history) self.assertIn((code_c, 1), history) self.assertIn((code_c, 0), history) self.assertGreater(history.count((code_b, 1)), 1) self.assertGreater(history.count((code_b, 0)), 1) # it's stopped and won't write stuff anymore count_before = len(history) loop.run_until_complete(asyncio.sleep(0.2)) count_after = len(history) self.assertEqual(count_before, count_after) self.assertFalse(active_macros[(EV_KEY, 1)].holding) self.assertFalse(active_macros[(EV_KEY, 1)].running)
def test_5(self): start = time.time() macro = parse('w(200).r(2,m(w,\nr(2,\tk(BtN_LeFt))).w(10).k(k))', self.mapping) macro.set_handler(self.handler) self.assertEqual(len(macro.child_macros), 1) self.assertEqual(len(macro.child_macros[0].child_macros), 1) w = system_mapping.get('w') left = system_mapping.get('bTn_lEfT') k = system_mapping.get('k') self.assertSetEqual(macro.get_capabilities(), {w, left, k}) self.loop.run_until_complete(macro.run()) num_pauses = 8 + 6 + 4 keystroke_time = num_pauses * self.mapping.get( 'macros.keystroke_sleep_ms') wait_time = 220 total_time = (keystroke_time + wait_time) / 1000 self.assertLess(time.time() - start, total_time * 1.1) self.assertGreater(time.time() - start, total_time * 0.9) expected = [(w, 1)] expected += [(left, 1), (left, 0)] * 2 expected += [(w, 0)] expected += [(k, 1), (k, 0)] expected *= 2 self.assertListEqual(self.result, expected)
def test_0(self): macro = parse('k(1)', self.mapping) macro.set_handler(self.handler) one_code = system_mapping.get('1') self.assertSetEqual(macro.get_capabilities(), {one_code}) self.loop.run_until_complete(macro.run()) self.assertListEqual(self.result, [(one_code, 1), (one_code, 0)]) self.assertEqual(len(macro.child_macros), 0)
def test_two_d_pad_macros(self): # executing two macros that stop automatically at the same time code_1 = 61 code_2 = 62 system_mapping.clear() system_mapping._set('1', code_1) system_mapping._set('2', code_2) # try two concurrent macros with D-Pad events because they are # more difficult to manage, since their only difference is their # value, and one of them is negative. down_1 = (EV_ABS, ABS_HAT0X, 1) down_2 = (EV_ABS, ABS_HAT0X, -1) repeats = 10 macro_mapping = { (down_1, ): parse(f'r({repeats}, k(1))', self.mapping), (down_2, ): parse(f'r({repeats}, k(2))', self.mapping) } history = [] def handler(*args): history.append(args) macro_mapping[(down_1, )].set_handler(handler) macro_mapping[(down_2, )].set_handler(handler) handle_keycode({}, macro_mapping, InputEvent(*down_1), None) handle_keycode({}, macro_mapping, InputEvent(*down_2), None) loop = asyncio.get_event_loop() sleeptime = config.get('macros.keystroke_sleep_ms') / 1000 loop.run_until_complete(asyncio.sleep(1.1 * repeats * 2 * sleeptime)) self.assertEqual(len(history), repeats * 4) self.assertEqual(history.count((code_1, 1)), 10) self.assertEqual(history.count((code_1, 0)), 10) self.assertEqual(history.count((code_2, 1)), 10) self.assertEqual(history.count((code_2, 0)), 10)
def test_keystroke_sleep_config(self): # global config as fallback config.set('macros.keystroke_sleep_ms', 100) start = time.time() macro = parse('k(a).k(b)', self.mapping) self.loop.run_until_complete(macro.run()) delta = time.time() - start # is currently over 400, k(b) adds another sleep afterwards # that doesn't do anything self.assertGreater(delta, 0.300) # now set the value in the mapping, which is prioritized self.mapping.set('macros.keystroke_sleep_ms', 50) start = time.time() macro = parse('k(a).k(b)', self.mapping) self.loop.run_until_complete(macro.run()) delta = time.time() - start self.assertGreater(delta, 0.150) self.assertLess(delta, 0.300)
def test_hold_3(self): # test irregular input patterns code_a = 100 code_b = 101 code_c = 102 system_mapping.clear() system_mapping._set('a', code_a) system_mapping._set('b', code_b) system_mapping._set('c', code_c) macro_mapping = { ((EV_KEY, 1, 1), ): parse('k(a).h(k(b)).k(c)', self.mapping), } history = [] def handler(*args): history.append(args) macro_mapping[((EV_KEY, 1, 1), )].set_handler(handler) handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 1), None) loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.sleep(0.1)) for _ in range(5): self.assertTrue(active_macros[(EV_KEY, 1)].holding) self.assertTrue(active_macros[(EV_KEY, 1)].running) handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 1), None) loop.run_until_complete(asyncio.sleep(0.05)) # duplicate key down events don't do anything self.assertEqual(history.count((code_a, 1)), 1) self.assertEqual(history.count((code_a, 0)), 1) self.assertEqual(history.count((code_c, 1)), 0) self.assertEqual(history.count((code_c, 0)), 0) # stop handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 0), None) loop.run_until_complete(asyncio.sleep(0.1)) self.assertEqual(history.count((code_a, 1)), 1) self.assertEqual(history.count((code_a, 0)), 1) self.assertEqual(history.count((code_c, 1)), 1) self.assertEqual(history.count((code_c, 0)), 1) self.assertFalse(active_macros[(EV_KEY, 1)].holding) self.assertFalse(active_macros[(EV_KEY, 1)].running) # it's stopped and won't write stuff anymore count_before = len(history) loop.run_until_complete(asyncio.sleep(0.1)) count_after = len(history) self.assertEqual(count_before, count_after)
def check_macro_syntax(self): """Check if the programmed macros are allright.""" for key, output in custom_mapping: if not is_this_a_macro(output): continue error = parse(output, custom_mapping, return_errors=True) if error is None: continue position = to_string(key) msg = f'Syntax error at {position}, hover for info' self.show_status(CTX_ERROR, msg, error)
def test_1(self): macro = parse('k(1).k(a).k(3)', self.mapping) macro.set_handler(self.handler) self.assertSetEqual( macro.get_capabilities(), { system_mapping.get('1'), system_mapping.get('a'), system_mapping.get('3') }) self.loop.run_until_complete(macro.run()) self.assertListEqual(self.result, [ (system_mapping.get('1'), 1), (system_mapping.get('1'), 0), (system_mapping.get('a'), 1), (system_mapping.get('a'), 0), (system_mapping.get('3'), 1), (system_mapping.get('3'), 0), ]) self.assertEqual(len(macro.child_macros), 0)
def test_2(self): start = time.time() repeats = 20 macro = parse(f'r({repeats}, k(k)).r(1, k(k))', self.mapping) macro.set_handler(self.handler) k_code = system_mapping.get('k') self.assertSetEqual(macro.get_capabilities(), {k_code}) self.loop.run_until_complete(macro.run()) keystroke_sleep = self.mapping.get('macros.keystroke_sleep_ms') sleep_time = 2 * repeats * keystroke_sleep / 1000 self.assertGreater(time.time() - start, sleep_time * 0.9) self.assertLess(time.time() - start, sleep_time * 1.1) self.assertListEqual(self.result, [(k_code, 1), (k_code, 0)] * (repeats + 1)) self.assertEqual(len(macro.child_macros), 2) self.assertEqual(len(macro.child_macros[0].child_macros), 0)
def test_hold(self): macro = parse('k(1).h(k(a)).k(3)', self.mapping) macro.set_handler(self.handler) self.assertSetEqual( macro.get_capabilities(), { system_mapping.get('1'), system_mapping.get('a'), system_mapping.get('3') }) macro.press_key() asyncio.ensure_future(macro.run()) self.loop.run_until_complete(asyncio.sleep(0.2)) macro.release_key() self.loop.run_until_complete(asyncio.sleep(0.05)) self.assertEqual(self.result[0], (system_mapping.get('1'), 1)) self.assertEqual(self.result[-1], (system_mapping.get('3'), 0)) code_a = system_mapping.get('a') self.assertGreater(self.result.count((code_a, 1)), 2) self.assertEqual(len(macro.child_macros), 1)
def test_3(self): start = time.time() macro = parse('r(3, k(m).w(100))', self.mapping) macro.set_handler(self.handler) m_code = system_mapping.get('m') self.assertSetEqual(macro.get_capabilities(), {m_code}) self.loop.run_until_complete(macro.run()) keystroke_time = 6 * self.mapping.get('macros.keystroke_sleep_ms') total_time = keystroke_time + 300 total_time /= 1000 self.assertGreater(time.time() - start, total_time * 0.9) self.assertLess(time.time() - start, total_time * 1.1) self.assertListEqual(self.result, [ (m_code, 1), (m_code, 0), (m_code, 1), (m_code, 0), (m_code, 1), (m_code, 0), ]) self.assertEqual(len(macro.child_macros), 1) self.assertEqual(len(macro.child_macros[0].child_macros), 0)
def test_hold_two(self): # holding two macros at the same time, # the first one is triggered by a combination history = [] code_1 = 100 code_2 = 101 code_3 = 102 code_a = 103 code_b = 104 code_c = 105 system_mapping.clear() system_mapping._set('1', code_1) system_mapping._set('2', code_2) system_mapping._set('3', code_3) system_mapping._set('a', code_a) system_mapping._set('b', code_b) system_mapping._set('c', code_c) key_0 = (EV_KEY, 10) key_1 = (EV_KEY, 11) key_2 = (EV_ABS, ABS_HAT0X) down_0 = (*key_0, 1) down_1 = (*key_1, 1) down_2 = (*key_2, -1) up_0 = (*key_0, 0) up_1 = (*key_1, 0) up_2 = (*key_2, 0) macro_mapping = { (down_0, down_1): parse('k(1).h(k(2)).k(3)', self.mapping), (down_2, ): parse('k(a).h(k(b)).k(c)', self.mapping) } def handler(*args): history.append(args) macro_mapping[(down_0, down_1)].set_handler(handler) macro_mapping[(down_2, )].set_handler(handler) loop = asyncio.get_event_loop() macros_uinput = UInput() keys_uinput = UInput() # key up won't do anything handle_keycode({}, macro_mapping, InputEvent(*up_0), macros_uinput) handle_keycode({}, macro_mapping, InputEvent(*up_1), macros_uinput) handle_keycode({}, macro_mapping, InputEvent(*up_2), macros_uinput) loop.run_until_complete(asyncio.sleep(0.1)) self.assertEqual(len(active_macros), 0) """start macros""" handle_keycode({}, macro_mapping, InputEvent(*down_0), keys_uinput) self.assertEqual(keys_uinput.write_count, 1) handle_keycode({}, macro_mapping, InputEvent(*down_1), keys_uinput) handle_keycode({}, macro_mapping, InputEvent(*down_2), keys_uinput) self.assertEqual(keys_uinput.write_count, 1) # let the mainloop run for some time so that the macro does its stuff sleeptime = 500 keystroke_sleep = config.get('macros.keystroke_sleep_ms', 10) loop.run_until_complete(asyncio.sleep(sleeptime / 1000)) self.assertEqual(len(active_macros), 2) self.assertTrue(active_macros[key_1].holding) self.assertTrue(active_macros[key_1].running) self.assertTrue(active_macros[key_2].holding) self.assertTrue(active_macros[key_2].running) """stop macros""" # releasing the last key of a combination releases the whole macro handle_keycode({}, macro_mapping, InputEvent(*up_1), None) handle_keycode({}, macro_mapping, InputEvent(*up_2), None) loop.run_until_complete(asyncio.sleep(keystroke_sleep * 10 / 1000)) self.assertFalse(active_macros[key_1].holding) self.assertFalse(active_macros[key_1].running) self.assertFalse(active_macros[key_2].holding) self.assertFalse(active_macros[key_2].running) events = calculate_event_number(sleeptime, 1, 1) * 2 self.assertGreater(len(history), events * 0.9) self.assertLess(len(history), events * 1.1) self.assertIn((code_a, 1), history) self.assertIn((code_a, 0), history) self.assertIn((code_b, 1), history) self.assertIn((code_b, 0), history) self.assertIn((code_c, 1), history) self.assertIn((code_c, 0), history) self.assertIn((code_1, 1), history) self.assertIn((code_1, 0), history) self.assertIn((code_2, 1), history) self.assertIn((code_2, 0), history) self.assertIn((code_3, 1), history) self.assertIn((code_3, 0), history) self.assertGreater(history.count((code_b, 1)), 1) self.assertGreater(history.count((code_b, 0)), 1) self.assertGreater(history.count((code_2, 1)), 1) self.assertGreater(history.count((code_2, 0)), 1) # it's stopped and won't write stuff anymore count_before = len(history) loop.run_until_complete(asyncio.sleep(0.2)) count_after = len(history) self.assertEqual(count_before, count_after)
def test_hold_2(self): # test irregular input patterns code_a = 100 code_b = 101 code_c = 102 code_d = 103 system_mapping.clear() system_mapping._set('a', code_a) system_mapping._set('b', code_b) system_mapping._set('c', code_c) system_mapping._set('d', code_d) macro_mapping = { ((EV_KEY, 1, 1), ): parse('h(k(b))', self.mapping), ((EV_KEY, 2, 1), ): parse('k(c).r(1, r(1, r(1, h(k(a))))).k(d)', self.mapping), ((EV_KEY, 3, 1), ): parse('h(k(b))', self.mapping) } history = [] def handler(*args): history.append(args) macro_mapping[((EV_KEY, 1, 1), )].set_handler(handler) macro_mapping[((EV_KEY, 2, 1), )].set_handler(handler) macro_mapping[((EV_KEY, 3, 1), )].set_handler(handler) """start macro 2""" handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 2, 1), None) loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.sleep(0.1)) # starting code_c written self.assertEqual(history.count((code_c, 1)), 1) self.assertEqual(history.count((code_c, 0)), 1) # spam garbage events for _ in range(5): handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 1), None) handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 3, 1), None) loop.run_until_complete(asyncio.sleep(0.05)) self.assertTrue(active_macros[(EV_KEY, 1)].holding) self.assertTrue(active_macros[(EV_KEY, 1)].running) self.assertTrue(active_macros[(EV_KEY, 2)].holding) self.assertTrue(active_macros[(EV_KEY, 2)].running) self.assertTrue(active_macros[(EV_KEY, 3)].holding) self.assertTrue(active_macros[(EV_KEY, 3)].running) # there should only be one code_c in the events, because no key # up event was ever done so the hold just continued self.assertEqual(history.count((code_c, 1)), 1) self.assertEqual(history.count((code_c, 0)), 1) # without an key up event on 2, it won't write code_d self.assertNotIn((code_d, 1), history) self.assertNotIn((code_d, 0), history) # stop macro 2 handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 2, 0), None) loop.run_until_complete(asyncio.sleep(0.1)) # it stopped and didn't restart, so the count stays at 1 self.assertEqual(history.count((code_c, 1)), 1) self.assertEqual(history.count((code_c, 0)), 1) # and the trailing d was written self.assertEqual(history.count((code_d, 1)), 1) self.assertEqual(history.count((code_d, 0)), 1) # it's stopped and won't write stuff anymore count_before = history.count((code_a, 1)) self.assertGreater(count_before, 1) loop.run_until_complete(asyncio.sleep(0.1)) count_after = history.count((code_a, 1)) self.assertEqual(count_before, count_after) """restart macro 2""" history = [] handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 2, 1), None) loop.run_until_complete(asyncio.sleep(0.1)) self.assertEqual(history.count((code_c, 1)), 1) self.assertEqual(history.count((code_c, 0)), 1) # spam garbage events again, this time key-up events on all other # macros for _ in range(5): handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 0), None) handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 3, 0), None) loop.run_until_complete(asyncio.sleep(0.05)) self.assertFalse(active_macros[(EV_KEY, 1)].holding) self.assertFalse(active_macros[(EV_KEY, 1)].running) self.assertTrue(active_macros[(EV_KEY, 2)].holding) self.assertTrue(active_macros[(EV_KEY, 2)].running) self.assertFalse(active_macros[(EV_KEY, 3)].holding) self.assertFalse(active_macros[(EV_KEY, 3)].running) # stop macro 2 handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 2, 0), None) loop.run_until_complete(asyncio.sleep(0.1)) # was started only once self.assertEqual(history.count((code_c, 1)), 1) self.assertEqual(history.count((code_c, 0)), 1) # and the trailing d was also written only once self.assertEqual(history.count((code_d, 1)), 1) self.assertEqual(history.count((code_d, 0)), 1) # stop all macros handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 0), None) handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 3, 0), None) loop.run_until_complete(asyncio.sleep(0.1)) # it's stopped and won't write stuff anymore count_before = len(history) loop.run_until_complete(asyncio.sleep(0.1)) count_after = len(history) self.assertEqual(count_before, count_after) self.assertFalse(active_macros[(EV_KEY, 1)].holding) self.assertFalse(active_macros[(EV_KEY, 1)].running) self.assertFalse(active_macros[(EV_KEY, 2)].holding) self.assertFalse(active_macros[(EV_KEY, 2)].running) self.assertFalse(active_macros[(EV_KEY, 3)].holding) self.assertFalse(active_macros[(EV_KEY, 3)].running)
def _start_injecting(self): """The injection worker that keeps injecting until terminated. Stuff is non-blocking by using asyncio in order to do multiple things somewhat concurrently. Use this function as starting point in a process. It creates the loops needed to read and map events and keeps running them. """ # create a new event loop, because somehow running an infinite loop # that sleeps on iterations (ev_abs_mapper) in one process causes # another injection process to screw up reading from the grabbed # device. loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) numlock_state = is_numlock_on() loop = asyncio.get_event_loop() coroutines = [] logger.info('Starting injecting the mapping for "%s"', self.device) paths = get_devices()[self.device]['paths'] # Watch over each one of the potentially multiple devices per hardware for path in paths: source, abs_to_rel = self._prepare_device(path) if source is None: continue # each device needs own macro instances to add a custom handler logger.debug('Parsing macros for %s', path) macros = {} for key, output in self.mapping: if is_this_a_macro(output): macro = parse(output, self.mapping) if macro is None: continue for permutation in key.get_permutations(): macros[permutation.keys] = macro if len(macros) == 0: logger.debug('No macros configured') # certain capabilities can have side effects apparently. with an # EV_ABS capability, EV_REL won't move the mouse pointer anymore. # so don't merge all InputDevices into one UInput device. uinput = evdev.UInput(name=f'{DEV_NAME} {self.device}', phys=DEV_NAME, events=self._modify_capabilities( macros, source, abs_to_rel)) logger.spam('Injected capabilities for "%s": %s', path, uinput.capabilities(verbose=True)) def handler(*args, uinput=uinput): # this ensures that the right uinput is used for macro_write, # because this is within a loop self._macro_write(*args, uinput) for macro in macros.values(): macro.set_handler(handler) # actual reading of events coroutines.append( self._event_consumer(macros, source, uinput, abs_to_rel)) # mouse movement injection based on the results of the # event consumer if abs_to_rel: self.abs_state[0] = 0 self.abs_state[1] = 0 coroutines.append( ev_abs_mapper(self.abs_state, source, uinput, self.mapping)) if len(coroutines) == 0: logger.error('Did not grab any device') return coroutines.append(self._msg_listener(loop)) # set the numlock state to what it was before injecting, because # grabbing devices screws this up set_numlock(numlock_state) try: loop.run_until_complete(asyncio.gather(*coroutines)) except RuntimeError: # stopped event loop most likely pass except OSError as error: logger.error(str(error)) if len(coroutines) > 0: logger.debug('asyncio coroutines ended')
def test_return_errors(self): error = parse('k(1).h(k(a)).k(3)', self.mapping, return_errors=True) self.assertIsNone(error) error = parse('k(1))', self.mapping, return_errors=True) self.assertIn('bracket', error) error = parse('k((1)', self.mapping, return_errors=True) self.assertIn('bracket', error) error = parse('k((1).k)', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('r(a, k(1))', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('k()', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('k(1)', self.mapping, return_errors=True) self.assertIsNone(error) error = parse('k(1, 1)', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('h(1, 1)', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('h(h(h(1, 1)))', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('r(1)', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('r(1, 1)', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('r(k(1), 1)', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('r(1, k(1))', self.mapping, return_errors=True) self.assertIsNone(error)
def test_fails(self): self.assertIsNone(parse('r(1, a)', self.mapping)) self.assertIsNone(parse('r(a, k(b))', self.mapping)) self.assertIsNone(parse('m(a, b)', self.mapping))
def test_6(self): # does nothing without .run macro = parse('k(a).r(3, k(b))', self.mapping) macro.set_handler(self.handler) self.assertIsInstance(macro, _Macro) self.assertListEqual(self.result, [])