def save_preset(self, *_): """Write changes to presets to disk.""" if not custom_mapping.changed: return try: path = get_preset_path(self.selected_device, self.selected_preset) custom_mapping.save(path) custom_mapping.changed = False # after saving the config, its modification date will be the # newest, so populate_presets will automatically select the # right one again. self.populate_presets() except PermissionError as error: error = str(error) self.show_status(CTX_ERROR, 'Permission denied!', error) logger.error(error) for _, character in custom_mapping: if is_this_a_macro(character): continue if system_mapping.get(character) is None: self.show_status(CTX_MAPPING, f'Unknown mapping "{character}"') break else: # no broken mappings found self.show_status(CTX_MAPPING, None) # checking macros is probably a bit more expensive, do that if # the regular mappings are allright self.check_macro_syntax()
def populate_presets(self): """Show the available presets for the selected device. This will destroy unsaved changes in the custom_mapping. """ device = self.selected_device presets = get_presets(device) if len(presets) == 0: new_preset = get_available_preset_name(self.selected_device) custom_mapping.empty() path = get_preset_path(self.selected_device, new_preset) custom_mapping.save(path) presets = [new_preset] else: logger.debug('"%s" presets: "%s"', device, '", "'.join(presets)) preset_selection = self.get('preset_selection') with HandlerDisabled(preset_selection, self.on_select_preset): # otherwise the handler is called with None for each preset preset_selection.remove_all() for preset in presets: preset_selection.append(preset, preset) # and select the newest one (on the top). triggers on_select_preset preset_selection.set_active(0)
def test_xmodmap_file(self): from_keycode = evdev.ecodes.KEY_A to_name = 'qux' to_keycode = 100 event = (EV_KEY, from_keycode, 1) device = 'device 2' preset = 'foo' path = get_preset_path(device, preset) custom_mapping.change(Key(event), to_name) custom_mapping.save(path) system_mapping.clear() config.set_autoload_preset(device, preset) pending_events[device] = [InputEvent(*event)] xmodmap_path = os.path.join(tmp, 'foobar.json') with open(xmodmap_path, 'w') as file: file.write(f'{{"{to_name}":{to_keycode}}}') self.daemon = Daemon() self.daemon.start_injecting(device, path, xmodmap_path) event = uinput_write_history_pipe[0].recv() self.assertEqual(event.type, EV_KEY) self.assertEqual(event.code, to_keycode) self.assertEqual(event.value, 1)
def test_refresh_on_start(self): if os.path.exists(get_config_path('xmodmap.json')): os.remove(get_config_path('xmodmap.json')) ev = (EV_KEY, 9) keycode_to = 100 group_name = '9876 name' # expected key of the group group_key = group_name group = groups.find(name=group_name) # this test only makes sense if this device is unknown yet self.assertIsNone(group) custom_mapping.change(Key(*ev, 1), 'a') system_mapping.clear() system_mapping._set('a', keycode_to) # make the daemon load the file instead with open(get_config_path('xmodmap.json'), 'w') as file: json.dump(system_mapping._mapping, file, indent=4) system_mapping.clear() preset = 'foo' custom_mapping.save(get_preset_path(group_name, preset)) config.set_autoload_preset(group_key, preset) push_events(group_key, [new_event(*ev, 1)]) self.daemon = Daemon() # make sure the devices are populated groups.refresh() # the daemon is supposed to find this device by calling refresh fixtures[self.new_fixture_path] = { 'capabilities': { evdev.ecodes.EV_KEY: [ev[1]] }, 'phys': '9876 phys', 'info': evdev.device.DeviceInfo(4, 5, 6, 7), 'name': group_name } self.daemon.set_config_dir(get_config_path()) self.daemon.start_injecting(group_key, preset) # test if the injector called groups.refresh successfully group = groups.find(key=group_key) self.assertEqual(group.name, group_name) self.assertEqual(group.key, group_key) time.sleep(0.1) self.assertTrue(uinput_write_history_pipe[0].poll()) event = uinput_write_history_pipe[0].recv() self.assertEqual(event.t, (EV_KEY, keycode_to, 1)) self.daemon.stop_injecting(group_key) self.assertEqual(self.daemon.get_state(group_key), STOPPED)
def save_preset(self): """Write changes to presets to disk.""" logger.info('Updating configs for "%s", "%s"', self.selected_device, self.selected_preset) path = get_preset_path(self.selected_device, self.selected_preset) custom_mapping.save(path) custom_mapping.changed = False self.unhighlight_all_rows()
def on_create_preset_clicked(self, _): """Create a new preset and select it.""" if custom_mapping.changed and unsaved_changes_dialog() == GO_BACK: return try: new_preset = get_available_preset_name(self.selected_device) custom_mapping.empty() path = get_preset_path(self.selected_device, new_preset) custom_mapping.save(path) self.get('preset_selection').append(new_preset, new_preset) self.get('preset_selection').set_active_id(new_preset) except PermissionError as error: error = str(error) self.show_status(CTX_ERROR, 'Error: Permission denied!', error) logger.error(error)
def test_xmodmap_file(self): from_keycode = evdev.ecodes.KEY_A to_name = 'qux' to_keycode = 100 event = (EV_KEY, from_keycode, 1) device = 'device 2' preset = 'foo' config_dir = os.path.join(tmp, 'foo') path = os.path.join(config_dir, 'presets', device, f'{preset}.json') custom_mapping.change(Key(event), to_name) custom_mapping.save(path) system_mapping.clear() push_events(device, [ new_event(*event) ]) # an existing config file is needed otherwise set_config_dir refuses # to use the directory config_path = os.path.join(config_dir, 'config.json') config.path = config_path config.save_config() xmodmap_path = os.path.join(config_dir, 'xmodmap.json') with open(xmodmap_path, 'w') as file: file.write(f'{{"{to_name}":{to_keycode}}}') self.daemon = Daemon() self.daemon.set_config_dir(config_dir) self.daemon.start_injecting(device, preset) time.sleep(0.1) self.assertTrue(uinput_write_history_pipe[0].poll()) event = uinput_write_history_pipe[0].recv() self.assertEqual(event.type, EV_KEY) self.assertEqual(event.code, to_keycode) self.assertEqual(event.value, 1)
def create_preset(self, copy=False): """Create a new preset and select it.""" self.save_preset() try: if copy: new_preset = get_available_preset_name(self.selected_device, self.selected_preset, copy) else: new_preset = get_available_preset_name(self.selected_device) custom_mapping.empty() path = get_preset_path(self.selected_device, new_preset) custom_mapping.save(path) self.get('preset_selection').append(new_preset, new_preset) self.get('preset_selection').set_active_id(new_preset) except PermissionError as error: error = str(error) self.show_status(CTX_ERROR, 'Permission denied!', error) logger.error(error)
def test_stop_injecting(self): keycode_from = 16 keycode_to = 90 self.change_empty_row(Key(EV_KEY, keycode_from, 1), 't') system_mapping.clear() system_mapping._set('t', keycode_to) # not all of those events should be processed, since that takes some # time due to time.sleep in the fakes and the injection is stopped. pending_events['device 2'] = [InputEvent(1, keycode_from, 1)] * 100 custom_mapping.save(get_preset_path('device 2', 'foo preset')) self.window.selected_device = 'device 2' self.window.selected_preset = 'foo preset' self.window.on_apply_preset_clicked(None) pipe = uinput_write_history_pipe[0] # block until the first event is available, indicating that # the injector is ready write_history = [pipe.recv()] # stop self.window.on_apply_system_layout_clicked(None) # try to receive a few of the events time.sleep(0.2) while pipe.poll(): write_history.append(pipe.recv()) len_before = len(write_history) self.assertLess(len(write_history), 50) # since the injector should not be running anymore, no more events # should be received after waiting even more time time.sleep(0.2) while pipe.poll(): write_history.append(pipe.recv()) self.assertEqual(len(write_history), len_before)
def test_start_injecting(self): keycode_from = 9 keycode_to = 200 self.change_empty_row(Key(EV_KEY, keycode_from, 1), 'a') system_mapping.clear() system_mapping._set('a', keycode_to) pending_events['device 2'] = [ InputEvent(evdev.events.EV_KEY, keycode_from, 1), InputEvent(evdev.events.EV_KEY, keycode_from, 0) ] custom_mapping.save(get_preset_path('device 2', 'foo preset')) # use only the manipulated system_mapping os.remove(os.path.join(tmp, XMODMAP_FILENAME)) self.window.selected_device = 'device 2' self.window.selected_preset = 'foo preset' self.window.on_apply_preset_clicked(None) # the integration tests will cause the injection to be started as # processes, as intended. Luckily, recv will block until the events # are handled and pushed. # Note, that pushing events to pending_events won't work anymore # from here on because the injector processes memory cannot be # modified from here. event = uinput_write_history_pipe[0].recv() self.assertEqual(event.type, evdev.events.EV_KEY) self.assertEqual(event.code, keycode_to) self.assertEqual(event.value, 1) event = uinput_write_history_pipe[0].recv() self.assertEqual(event.type, evdev.events.EV_KEY) self.assertEqual(event.code, keycode_to) self.assertEqual(event.value, 0)
def test_refresh_devices_on_start(self): ev = (EV_KEY, 9) keycode_to = 100 device = '9876 name' # this test only makes sense if this device is unknown yet self.assertIsNone(get_devices().get(device)) custom_mapping.change(Key(*ev, 1), 'a') system_mapping.clear() system_mapping._set('a', keycode_to) preset = 'foo' custom_mapping.save(get_preset_path(device, preset)) config.set_autoload_preset(device, preset) pending_events[device] = [InputEvent(*ev, 1)] self.daemon = Daemon() preset_path = get_preset_path(device, preset) # make sure the devices are populated get_devices() fixtures[self.new_fixture] = { 'capabilities': { evdev.ecodes.EV_KEY: [ev[1]] }, 'phys': '9876 phys', 'info': 'abcd', 'name': device } self.daemon.start_injecting(device, preset_path) # test if the injector called refresh_devices successfully self.assertIsNotNone(get_devices().get(device)) event = uinput_write_history_pipe[0].recv() self.assertEqual(event.type, EV_KEY) self.assertEqual(event.code, keycode_to) self.assertEqual(event.value, 1) self.daemon.stop_injecting(device) self.assertFalse(self.daemon.is_injecting(device))
def test_daemon(self): # remove the existing system mapping to force our own into it if os.path.exists(get_config_path('xmodmap.json')): os.remove(get_config_path('xmodmap.json')) ev_1 = (EV_KEY, 9) ev_2 = (EV_ABS, 12) keycode_to_1 = 100 keycode_to_2 = 101 group = groups.find(name='Bar Device') # unrelated group that shouldn't be affected at all group2 = groups.find(name='gamepad') custom_mapping.change(Key(*ev_1, 1), 'a') custom_mapping.change(Key(*ev_2, -1), 'b') system_mapping.clear() # since this is in the same memory as the daemon, there is no need # to save it to disk system_mapping._set('a', keycode_to_1) system_mapping._set('b', keycode_to_2) preset = 'foo' custom_mapping.save(group.get_preset_path(preset)) config.set_autoload_preset(group.key, preset) """injection 1""" # should forward the event unchanged push_events(group.key, [new_event(EV_KEY, 13, 1)]) self.daemon = Daemon() self.daemon.set_config_dir(get_config_path()) self.assertFalse(uinput_write_history_pipe[0].poll()) self.daemon.start_injecting(group.key, preset) self.assertEqual(self.daemon.get_state(group.key), STARTING) self.assertEqual(self.daemon.get_state(group2.key), UNKNOWN) event = uinput_write_history_pipe[0].recv() self.assertEqual(self.daemon.get_state(group.key), RUNNING) self.assertEqual(event.type, EV_KEY) self.assertEqual(event.code, 13) self.assertEqual(event.value, 1) self.daemon.stop_injecting(group.key) self.assertEqual(self.daemon.get_state(group.key), STOPPED) time.sleep(0.1) try: self.assertFalse(uinput_write_history_pipe[0].poll()) except AssertionError: print('Unexpected', uinput_write_history_pipe[0].recv()) # possibly a duplicate write! raise """injection 2""" # -1234 will be normalized to -1 by the injector push_events(group.key, [new_event(*ev_2, -1234)]) self.daemon.start_injecting(group.key, preset) time.sleep(0.1) self.assertTrue(uinput_write_history_pipe[0].poll()) # the written key is a key-down event, not the original # event value of -1234 event = uinput_write_history_pipe[0].recv() self.assertEqual(event.type, EV_KEY) self.assertEqual(event.code, keycode_to_2) self.assertEqual(event.value, 1)
def test_daemon(self): ev_1 = (EV_KEY, 9) ev_2 = (EV_ABS, 12) keycode_to_1 = 100 keycode_to_2 = 101 device = 'device 2' custom_mapping.change(Key(*ev_1, 1), 'a') custom_mapping.change(Key(*ev_2, -1), 'b') system_mapping.clear() system_mapping._set('a', keycode_to_1) system_mapping._set('b', keycode_to_2) preset = 'foo' custom_mapping.save(get_preset_path(device, preset)) config.set_autoload_preset(device, preset) """injection 1""" # should forward the event unchanged pending_events[device] = [InputEvent(EV_KEY, 13, 1)] self.daemon = Daemon() preset_path = get_preset_path(device, preset) self.assertFalse(uinput_write_history_pipe[0].poll()) self.daemon.start_injecting(device, preset_path) self.assertTrue(self.daemon.is_injecting(device)) self.assertFalse(self.daemon.is_injecting('device 1')) event = uinput_write_history_pipe[0].recv() self.assertEqual(event.type, EV_KEY) self.assertEqual(event.code, 13) self.assertEqual(event.value, 1) self.daemon.stop_injecting(device) self.assertFalse(self.daemon.is_injecting(device)) time.sleep(0.2) try: self.assertFalse(uinput_write_history_pipe[0].poll()) except AssertionError: print(uinput_write_history_pipe[0].recv()) raise """injection 2""" # -1234 will be normalized to -1 by the injector pending_events[device] = [InputEvent(*ev_2, -1234)] path = get_preset_path(device, preset) self.daemon.start_injecting(device, path) # the written key is a key-down event, not the original # event value of -5678 event = uinput_write_history_pipe[0].recv() self.assertEqual(event.type, EV_KEY) self.assertEqual(event.code, keycode_to_2) self.assertEqual(event.value, 1)
def create_preset(group_name, name='new preset'): name = get_available_preset_name(group_name, name) custom_mapping.empty() custom_mapping.save(get_preset_path(group_name, name))