Archives/input-remapper
2
0
Fork 0
mirror of https://github.com/sezanzeb/input-remapper synced 2024-11-13 19:10:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

add event type to mapping key

Browse Source
This commit is contained in:
sezanzeb 2020-12-02 19:33:31 +01:00
parent 496c23185f
commit 4b5c9e3143
14 changed files with 180 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
keymapper/config.py
View File

@ -41,8 +41,13 @@ INITIAL_CONFIG = {
'keystroke_sleep_ms': 10
},
'gamepad': {
'non_linearity': 4,
'pointer_speed': 80
'joystick': {
'non_linearity': 4,
'pointer_speed': 80,
},
'triggers': {
'button_threshold': 0.5
},
}
}
@ -52,10 +57,15 @@ class _Config:
self._config = {}
self.load_config()
def _resolve(self, path, func):
def _resolve(self, path, func, config=None):
"""Call func for the given config value."""
chunks = path.split('.')
child = self._config
if config is None:
child = self._config
else:
child = config
while True:
chunk = chunks.pop(0)
parent = child
@ -97,19 +107,27 @@ class _Config:
self._resolve(path, do)
def get(self, path, default=None):
"""Get a config value.
def get(self, path, log_unknown=True):
"""Get a config value. If not set, return the default
Parameters
----------
path : string
For example 'macros.keystroke_sleep_ms'
default : any
If the configured value is not available or None, return this
instead
log_unknown : bool
If True, write an error.
"""
resolved = self._resolve(path, lambda parent, child, chunk: child)
return resolved if resolved is not None else default
def do(parent, child, chunk):
return child
resolved = self._resolve(path, do)
if resolved is None:
resolved = self._resolve(path, do, INITIAL_CONFIG)
if resolved is None and log_unknown:
logger.error('Unknown config key "%s"', path)
return resolved
def set_autoload_preset(self, device, preset):
"""Set a preset to be automatically applied on start.
@ -118,7 +136,7 @@ class _Config:
----------
device : string
preset : string or None
if None, don't autoload something for this device
if None, don't autoload something for this device.
"""
if preset is not None:
self.set(f'autoload.{device}', preset)
@ -131,7 +149,7 @@ class _Config:
def is_autoloaded(self, device, preset):
"""Should this preset be loaded automatically?"""
return self.get(f'autoload.{device}') == preset
return self.get(f'autoload.{device}', '') == preset
def load_config(self):
"""Load the config from the file system."""
@ -139,7 +157,9 @@ class _Config:
if not os.path.exists(CONFIG_PATH):
# treated like an empty config
logger.debug('Config file "%s" doesn\'t exist', CONFIG_PATH)
logger.debug('Config "%s" doesn\'t exist yet', CONFIG_PATH)
self.clear_config()
self.save_config()
return
with open(CONFIG_PATH, 'r') as file:

4
keymapper/dev/ev_abs_mapper.py
View File

@ -57,8 +57,8 @@ async def ev_abs_mapper(abs_state, input_device, keymapper_device):
max_value = input_device.absinfo(EV_ABS).max
max_speed = ((max_value ** 2) * 2) ** 0.5
pointer_speed = config.get('gamepad.pointer_speed', 80)
non_linearity = config.get('gamepad.non_linearity', 4)
pointer_speed = config.get('gamepad.joystick.pointer_speed')
non_linearity = config.get('gamepad.joystick.non_linearity')
while True:
start = time.time()

20
keymapper/dev/injector.py
View File

@ -119,6 +119,13 @@ class KeycodeInjector:
self._process = multiprocessing.Process(target=self._start_injecting)
self._process.start()
def map_ev_to_abs(self, capabilities):
"""Check if joystick movements can and should be mapped."""
# mapping buttons only works without ABS events in the capabilities,
# possibly due to some intentional constraints in the os. So always
# do this without the option to configure, if it is possible.
return evdev.ecodes.ABS_X in capabilities.get(EV_ABS, [])
def _prepare_device(self, path):
"""Try to grab the device, return if not needed/possible.
@ -135,12 +142,13 @@ class KeycodeInjector:
needed = False
if capabilities.get(EV_KEY) is not None:
for keycode, _ in self.mapping:
if keycode - KEYCODE_OFFSET in capabilities[EV_KEY]:
for (ev_type, keycode), _ in self.mapping:
# TEST ev_type
if keycode - KEYCODE_OFFSET in capabilities.get(ev_type, []):
needed = True
break
map_ev_abs = evdev.ecodes.ABS_X in capabilities.get(EV_ABS, [])
map_ev_abs = self.map_ev_to_abs(capabilities)
if map_ev_abs:
needed = True
@ -194,10 +202,10 @@ class KeycodeInjector:
if len(self.mapping) > 0 and capabilities.get(ecodes.EV_KEY) is None:
capabilities[ecodes.EV_KEY] = []
for _, character in self.mapping:
for (ev_type, _), character in self.mapping:
keycode = system_mapping.get(character)
if keycode is not None:
capabilities[ecodes.EV_KEY].append(keycode - KEYCODE_OFFSET)
capabilities[ev_type].append(keycode - KEYCODE_OFFSET)
if map_ev_abs:
del capabilities[ecodes.EV_ABS]
@ -320,7 +328,7 @@ class KeycodeInjector:
# Parse all macros beforehand
logger.debug('Parsing macros')
macros = {}
for keycode, output in self.mapping:
for (ev_type, keycode), output in self.mapping:
keycode -= KEYCODE_OFFSET
if '(' in output and ')' in output and len(output) >= 4:

2
keymapper/dev/macros.py
View File

@ -114,7 +114,7 @@ class _Macro:
def add_keycode_pause(self):
"""To add a pause between keystrokes."""
sleeptime = config.get('macros.keystroke_sleep_ms', 10) / 1000
sleeptime = config.get('macros.keystroke_sleep_ms') / 1000
async def sleep():
await asyncio.sleep(sleeptime)

1
keymapper/getdevices.py
View File

@ -83,6 +83,7 @@ class _GetDevices(threading.Thread):
# https://www.kernel.org/doc/html/latest/input/event-codes.html
capabilities = device.capabilities().keys()
if EV_KEY not in capabilities and EV_ABS not in capabilities:
# or gamepads, because they can be mapped like a keyboard
continue
usb = device.phys.split('/')[0]

10
keymapper/gtk/row.py
View File

@ -27,6 +27,8 @@ gi.require_version('Gtk', '3.0')
gi.require_version('GLib', '2.0')
from gi.repository import Gtk, GLib
from evdev.ecodes import EV_KEY
from keymapper.state import custom_mapping
from keymapper.logger import logger
@ -76,7 +78,7 @@ class Row(Gtk.ListBoxRow):
return
# keycode is already set by some other row
if custom_mapping.get_character(new_keycode) is not None:
if custom_mapping.get_character(EV_KEY, new_keycode) is not None:
msg = f'Keycode {new_keycode} is already mapped'
logger.info(msg)
self.window.get('status_bar').push(CTX_KEYCODE, msg)
@ -98,7 +100,7 @@ class Row(Gtk.ListBoxRow):
return
# else, the keycode has changed, the character is set, all good
custom_mapping.change(new_keycode, character, previous_keycode)
custom_mapping.change(EV_KEY, new_keycode, character, previous_keycode)
def highlight(self):
"""Mark this row as changed."""
@ -116,7 +118,7 @@ class Row(Gtk.ListBoxRow):
self.highlight()
if keycode is not None:
custom_mapping.change(
custom_mapping.change(EV_KEY,
previous_keycode=None,
new_keycode=keycode,
character=character
@ -178,7 +180,7 @@ class Row(Gtk.ListBoxRow):
"""Destroy the row and remove it from the config."""
keycode = self.get_keycode()
if keycode is not None:
custom_mapping.clear(keycode)
custom_mapping.clear(EV_KEY, keycode)
self.character_input.set_text('')
self.keycode_input.set_label('')
self.delete_callback(self)

2
keymapper/gtk/window.py
View File

@ -374,7 +374,7 @@ class Window:
custom_mapping.load(self.selected_device, self.selected_preset)
key_list = self.get('key_list')
for keycode, output in custom_mapping:
for (_, keycode), output in custom_mapping:
single_key_mapping = Row(
window=self,
delete_callback=self.on_row_removed,

53
keymapper/mapping.py
View File

@ -25,6 +25,7 @@
import os
import json
import copy
import evdev
from keymapper.logger import logger
from keymapper.paths import get_config_path, touch
@ -50,16 +51,18 @@ class Mapping:
def __len__(self):
return len(self._mapping)
def change(self, new_keycode, character, previous_keycode=None):
def change(self, ev_type, new_keycode, character, previous_keycode=None):
"""Replace the mapping of a keycode with a different one.
Return True on success.
Parameters
----------
ev_type : int
one of evdev.events. The original event
new_keycode : int
The source keycode, what the mouse would report without any
modification.
modification. xkb keycode.
character : string or string[]
A single character known to xkb, Examples: KP_1, Shift_L, a, B.
Can also be an array, which is used for reading the xkbmap output
@ -67,7 +70,7 @@ class Mapping:
previous_keycode : int or None
If None, will not remove any previous mapping. If you recently
used 10 for new_keycode and want to overwrite that with 11,
provide 5 here.
provide 5 here. xkb keycode.
"""
try:
new_keycode = int(new_keycode)
@ -78,25 +81,28 @@ class Mapping:
return False
if new_keycode and character:
self._mapping[new_keycode] = character
self._mapping[(ev_type, new_keycode)] = character
if new_keycode != previous_keycode:
# clear previous mapping of that code, because the line
# representing that one will now represent a different one.
self.clear(previous_keycode)
self.clear(ev_type, previous_keycode)
self.changed = True
return True
return False
def clear(self, keycode):
def clear(self, ev_type, keycode):
"""Remove a keycode from the mapping.
Parameters
----------
keycode : int
the xkb keycode
ev_type : int
one of evdev.events
"""
if self._mapping.get(keycode) is not None:
del self._mapping[keycode]
if self._mapping.get((ev_type, keycode)) is not None:
del self._mapping[(ev_type, keycode)]
self.changed = True
def empty(self):
@ -119,13 +125,23 @@ class Mapping:
logger.error('Invalid preset config at "%s"', path)
return
for keycode, character in preset_dict['mapping'].items():
for key, character in preset_dict['mapping'].items():
if ',' not in key:
logger.error('Found invalid key: "%s"', key)
continue
ev_type, keycode = key.split(',')
try:
keycode = int(keycode)
except ValueError:
logger.error('Found non-int keycode: %s', keycode)
logger.error('Found non-int keycode: "%s"', keycode)
continue
self._mapping[keycode] = character
try:
ev_type = int(ev_type)
except ValueError:
logger.error('Found non-int ev_type: "%s"', ev_type)
continue
self._mapping[(ev_type, keycode)] = character
# add any metadata of the mapping
for key in preset_dict:
@ -152,18 +168,27 @@ class Mapping:
with open(path, 'w') as file:
# make sure to keep the option to add metadata if ever needed,
# so put the mapping into a special key
preset_dict = {'mapping': self._mapping}
json_ready_mapping = {}
# tuple keys are not possible in json
for key, value in self._mapping.items():
new_key = f'{key[0]},{key[1]}'
json_ready_mapping[new_key] = value
preset_dict = {'mapping': json_ready_mapping}
preset_dict.update(self.config)
json.dump(preset_dict, file, indent=4)
file.write('\n')
self.changed = False
def get_character(self, keycode):
def get_character(self, ev_type, keycode):
"""Read the character that is mapped to this keycode.
Parameters
----------
keycode : int
ev_type : int
one of evdev.events. codes may be the same for various
event types.
"""
return self._mapping.get(keycode)
return self._mapping.get((ev_type, keycode))

8
tests/testcases/test_config.py
View File

@ -30,9 +30,15 @@ class TestConfig(unittest.TestCase):
self.assertEqual(len(config.iterate_autoload_presets()), 0)
config.save_config()
def test_get_default(self):
config._config = {}
self.assertEqual(config.get('gamepad.joystick.non_linearity'), 4)
config.set('gamepad.joystick.non_linearity', 3)
self.assertEqual(config.get('gamepad.joystick.non_linearity'), 3)
def test_basic(self):
self.assertEqual(config.get('a'), None)
self.assertEqual(config.get('a', 'foo'), 'foo')
config.set('a', 1)
self.assertEqual(config.get('a'), 1)

5
tests/testcases/test_daemon.py
View File

@ -25,6 +25,7 @@ import unittest
import time
import evdev
from evdev.ecodes import EV_KEY
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
@ -84,8 +85,8 @@ class TestDaemon(unittest.TestCase):
keycode_from_2 = 12
keycode_to_2 = 100
custom_mapping.change(keycode_from_1, 'a')
custom_mapping.change(keycode_from_2, 'b')
custom_mapping.change(EV_KEY, keycode_from_1, 'a')
custom_mapping.change(EV_KEY, keycode_from_2, 'b')
clear_system_mapping()
system_mapping['a'] = keycode_to_1
system_mapping['b'] = keycode_to_2

18
tests/testcases/test_injector.py
View File

@ -76,7 +76,7 @@ class TestInjector(unittest.TestCase):
}
mapping = Mapping()
mapping.change(
mapping.change(EV_KEY,
new_keycode=80,
character='a'
)
@ -99,7 +99,7 @@ class TestInjector(unittest.TestCase):
def test_grab(self):
# path is from the fixtures
custom_mapping.change(10, 'a')
custom_mapping.change(EV_KEY, 10, 'a')
self.injector = KeycodeInjector('device 1', custom_mapping)
path = '/dev/input/event10'
@ -124,7 +124,7 @@ class TestInjector(unittest.TestCase):
def test_skip_unused_device(self):
# skips a device because its capabilities are not used in the mapping
custom_mapping.change(10, 'a')
custom_mapping.change(EV_KEY, 10, 'a')
self.injector = KeycodeInjector('device 1', custom_mapping)
path = '/dev/input/event11'
device, map_ev_abs = self.injector._prepare_device(path)
@ -166,11 +166,9 @@ class TestInjector(unittest.TestCase):
def test_abs_to_rel(self):
# maps gamepad joystick events to mouse events
# TODO enable this somewhere so that map_ev_abs returns true
# in the .json file of the mapping.
config.set('gamepad.non_linearity', 1)
config.set('gamepad.joystick.non_linearity', 1)
pointer_speed = 80
config.set('gamepad.pointer_speed', pointer_speed)
config.set('gamepad.joystick.pointer_speed', pointer_speed)
# same for ABS, 0 for x, 1 for y
rel_x = evdev.ecodes.REL_X
@ -286,11 +284,11 @@ class TestInjector(unittest.TestCase):
self.assertIn(('b', 0), history)
def test_injector(self):
custom_mapping.change(8, 'k(KEY_Q).k(w)')
custom_mapping.change(9, 'a')
custom_mapping.change(EV_KEY, 8, 'k(KEY_Q).k(w)')
custom_mapping.change(EV_KEY, 9, 'a')
# one mapping that is unknown in the system_mapping on purpose
input_b = 10
custom_mapping.change(input_b, 'b')
custom_mapping.change(EV_KEY, input_b, 'b')
clear_system_mapping()
code_a = 100

35
tests/testcases/test_integration.py
View File

@ -24,6 +24,7 @@ import time
import os
import unittest
import evdev
from evdev.events import EV_KEY
import json
from unittest.mock import patch
from importlib.util import spec_from_loader, module_from_spec
@ -156,9 +157,9 @@ class TestIntegration(unittest.TestCase):
def test_select_device(self):
# creates a new empty preset when no preset exists for the device
self.window.on_select_device(FakeDropdown('device 1'))
custom_mapping.change(50, 'q')
custom_mapping.change(51, 'u')
custom_mapping.change(52, 'x')
custom_mapping.change(EV_KEY, 50, 'q')
custom_mapping.change(EV_KEY, 51, 'u')
custom_mapping.change(EV_KEY, 52, 'x')
self.assertEqual(len(custom_mapping), 3)
self.window.on_select_device(FakeDropdown('device 2'))
self.assertEqual(len(custom_mapping), 0)
@ -202,7 +203,7 @@ class TestIntegration(unittest.TestCase):
gtk_iteration()
self.assertEqual(len(self.window.get('key_list').get_children()), 2)
self.assertEqual(custom_mapping.get_character(30), 'Shift_L')
self.assertEqual(custom_mapping.get_character(EV_KEY, 30), 'Shift_L')
self.assertEqual(row.get_character(), 'Shift_L')
self.assertEqual(row.get_keycode(), 30)
@ -270,8 +271,8 @@ class TestIntegration(unittest.TestCase):
time.sleep(0.1)
self.assertEqual(len(self.get_rows()), num_rows_target)
self.assertEqual(custom_mapping.get_character(10), 'a')
self.assertEqual(custom_mapping.get_character(11), 'k(b).k(c)')
self.assertEqual(custom_mapping.get_character(EV_KEY, 10), 'a')
self.assertEqual(custom_mapping.get_character(EV_KEY, 11), 'k(b).k(c)')
self.assertTrue(custom_mapping.changed)
self.window.on_save_preset_clicked(None)
@ -293,13 +294,13 @@ class TestIntegration(unittest.TestCase):
row.get_style_context().list_classes()
)
self.assertEqual(custom_mapping.get_character(10), 'c')
self.assertEqual(custom_mapping.get_character(11), 'k(b).k(c)')
self.assertEqual(custom_mapping.get_character(EV_KEY, 10), 'c')
self.assertEqual(custom_mapping.get_character(EV_KEY, 11), 'k(b).k(c)')
self.assertTrue(custom_mapping.changed)
# try to add a duplicate keycode, it should be ignored
self.change_empty_row(11, 'd', success=False)
self.assertEqual(custom_mapping.get_character(11), 'k(b).k(c)')
self.assertEqual(custom_mapping.get_character(EV_KEY, 11), 'k(b).k(c)')
# and the number of rows shouldn't change
self.assertEqual(len(self.get_rows()), num_rows_target)
@ -316,11 +317,11 @@ class TestIntegration(unittest.TestCase):
gtk_iteration()
self.assertEqual(len(self.get_rows()), 3)
self.assertEqual(custom_mapping.get_character(11), 'b')
self.assertEqual(custom_mapping.get_character(EV_KEY, 11), 'b')
def remove(row, code, char, num_rows_after):
if code is not None and char is not None:
self.assertEqual(custom_mapping.get_character(code), char)
self.assertEqual(custom_mapping.get_character(EV_KEY, code), char)
self.assertEqual(row.get_character(), char)
self.assertEqual(row.get_keycode(), code)
row.on_delete_button_clicked()
@ -328,7 +329,7 @@ class TestIntegration(unittest.TestCase):
gtk_iteration()
self.assertIsNone(row.get_keycode())
self.assertIsNone(row.get_character())
self.assertIsNone(custom_mapping.get_character(code))
self.assertIsNone(custom_mapping.get_character(EV_KEY, code))
self.assertEqual(len(self.get_rows()), num_rows_after)
remove(row_1, 10, 'a', 2)
@ -339,17 +340,17 @@ class TestIntegration(unittest.TestCase):
remove(row_3, None, 'c', 1)
def test_rename_and_save(self):
custom_mapping.change(14, 'a', None)
custom_mapping.change(EV_KEY, 14, 'a', None)
self.assertEqual(self.window.selected_preset, 'new preset')
self.window.on_save_preset_clicked(None)
self.assertEqual(custom_mapping.get_character(14), 'a')
self.assertEqual(custom_mapping.get_character(EV_KEY, 14), 'a')
custom_mapping.change(14, 'b', None)
custom_mapping.change(EV_KEY, 14, 'b', None)
self.window.get('preset_name_input').set_text('asdf')
self.window.on_save_preset_clicked(None)
self.assertEqual(self.window.selected_preset, 'asdf')
self.assertTrue(os.path.exists(f'{CONFIG}/device 1/asdf.json'))
self.assertEqual(custom_mapping.get_character(14), 'b')
self.assertEqual(custom_mapping.get_character(EV_KEY, 14), 'b')
def test_select_device_and_preset(self):
# created on start because the first device is selected and some empty
@ -379,7 +380,7 @@ class TestIntegration(unittest.TestCase):
gtk_iteration()
self.assertEqual(self.window.selected_preset, 'new preset')
self.assertFalse(os.path.exists(f'{CONFIG}/device 1/abc 123.json'))
custom_mapping.change(10, '1', None)
custom_mapping.change(EV_KEY, 10, '1', None)
self.window.on_save_preset_clicked(None)
gtk_iteration()
self.assertEqual(self.window.selected_preset, 'abc 123')

6
tests/testcases/test_macros.py
View File

@ -57,7 +57,7 @@ class TestMacros(unittest.TestCase):
repeats = 20
macro = f'r({repeats}, k(k))'
self.loop.run_until_complete(parse(macro, self.handler).run())
keystroke_sleep = config.get('macros.keystroke_sleep_ms', 10)
keystroke_sleep = config.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)
@ -68,7 +68,7 @@ class TestMacros(unittest.TestCase):
macro = 'r(3, k(m).w(100))'
self.loop.run_until_complete(parse(macro, self.handler).run())
keystroke_time = 6 * config.get('macros.keystroke_sleep_ms', 10)
keystroke_time = 6 * config.get('macros.keystroke_sleep_ms')
total_time = keystroke_time + 300
total_time /= 1000
@ -97,7 +97,7 @@ class TestMacros(unittest.TestCase):
self.loop.run_until_complete(parse(macro, self.handler).run())
num_pauses = 8 + 6 + 4
keystroke_time = num_pauses * config.get('macros.keystroke_sleep_ms', 10)
keystroke_time = num_pauses * config.get('macros.keystroke_sleep_ms')
wait_time = 220
total_time = (keystroke_time + wait_time) / 1000

84
tests/testcases/test_mapping.py
View File

@ -20,6 +20,7 @@
import unittest
from evdev.events import EV_KEY
from keymapper.mapping import Mapping
from keymapper.state import populate_system_mapping
@ -31,6 +32,7 @@ class TestMapping(unittest.TestCase):
self.assertFalse(self.mapping.changed)
def test_populate_system_mapping(self):
# not actually a mapping object, just a dict
mapping = populate_system_mapping()
self.assertGreater(len(mapping), 100)
# xkb keycode 10 is typically mapped to '1'
@ -41,20 +43,20 @@ class TestMapping(unittest.TestCase):
def test_clone(self):
mapping1 = Mapping()
mapping1.change(1, 'a')
mapping1.change(EV_KEY, 1, 'a')
mapping2 = mapping1.clone()
mapping1.change(2, 'b')
mapping1.change(EV_KEY, 2, 'b')
self.assertEqual(mapping1.get_character(1), 'a')
self.assertEqual(mapping1.get_character(2), 'b')
self.assertEqual(mapping1.get_character(EV_KEY, 1), 'a')
self.assertEqual(mapping1.get_character(EV_KEY, 2), 'b')
self.assertEqual(mapping2.get_character(1), 'a')
self.assertIsNone(mapping2.get_character(2))
self.assertEqual(mapping2.get_character(EV_KEY, 1), 'a')
self.assertIsNone(mapping2.get_character(EV_KEY, 2))
def test_save_load(self):
self.mapping.change(10, '1')
self.mapping.change(11, '2')
self.mapping.change(12, '3')
self.mapping.change(EV_KEY, 10, '1')
self.mapping.change(EV_KEY, 11, '2')
self.mapping.change(EV_KEY, 12, '3')
self.mapping.config['foo'] = 'bar'
self.mapping.save('device 1', 'test')
@ -63,77 +65,77 @@ class TestMapping(unittest.TestCase):
loaded.load('device 1', 'test')
self.assertEqual(len(loaded), 3)
self.assertEqual(loaded.get_character(10), '1')
self.assertEqual(loaded.get_character(11), '2')
self.assertEqual(loaded.get_character(12), '3')
self.assertEqual(loaded.get_character(EV_KEY, 10), '1')
self.assertEqual(loaded.get_character(EV_KEY, 11), '2')
self.assertEqual(loaded.get_character(EV_KEY, 12), '3')
self.assertEqual(loaded.config['foo'], 'bar')
def test_change(self):
# 1 is not assigned yet, ignore it
self.mapping.change(2, 'a', 1)
self.mapping.change(EV_KEY, 2, 'a', 1)
self.assertTrue(self.mapping.changed)
self.assertIsNone(self.mapping.get_character(1))
self.assertEqual(self.mapping.get_character(2), 'a')
self.assertIsNone(self.mapping.get_character(EV_KEY, 1))
self.assertEqual(self.mapping.get_character(EV_KEY, 2), 'a')
self.assertEqual(len(self.mapping), 1)
# change 2 to 3 and change a to b
self.mapping.change(3, 'b', 2)
self.assertIsNone(self.mapping.get_character(2))
self.assertEqual(self.mapping.get_character(3), 'b')
self.mapping.change(EV_KEY, 3, 'b', 2)
self.assertIsNone(self.mapping.get_character(EV_KEY, 2))
self.assertEqual(self.mapping.get_character(EV_KEY, 3), 'b')
self.assertEqual(len(self.mapping), 1)
# add 4
self.mapping.change(4, 'c', None)
self.assertEqual(self.mapping.get_character(3), 'b')
self.assertEqual(self.mapping.get_character(4), 'c')
self.mapping.change(EV_KEY, 4, 'c', None)
self.assertEqual(self.mapping.get_character(EV_KEY, 3), 'b')
self.assertEqual(self.mapping.get_character(EV_KEY, 4), 'c')
self.assertEqual(len(self.mapping), 2)
# change the mapping of 4 to d
self.mapping.change(4, 'd', None)
self.assertEqual(self.mapping.get_character(4), 'd')
self.mapping.change(EV_KEY, 4, 'd', None)
self.assertEqual(self.mapping.get_character(EV_KEY, 4), 'd')
self.assertEqual(len(self.mapping), 2)
# this also works in the same way
self.mapping.change(4, 'e', 4)
self.assertEqual(self.mapping.get_character(4), 'e')
self.mapping.change(EV_KEY, 4, 'e', 4)
self.assertEqual(self.mapping.get_character(EV_KEY, 4), 'e')
self.assertEqual(len(self.mapping), 2)
# and this
self.mapping.change('4', 'f', '4')
self.assertEqual(self.mapping.get_character(4), 'f')
self.mapping.change(EV_KEY, '4', 'f', '4')
self.assertEqual(self.mapping.get_character(EV_KEY, 4), 'f')
self.assertEqual(len(self.mapping), 2)
# non-int keycodes are ignored
self.mapping.change('b', 'c', 'a')
self.mapping.change(EV_KEY, 'b', 'c', 'a')
self.assertEqual(len(self.mapping), 2)
def test_clear(self):
# does nothing
self.mapping.clear(40)
self.mapping.clear(EV_KEY, 40)
self.assertFalse(self.mapping.changed)
self.assertEqual(len(self.mapping), 0)
self.mapping._mapping[40] = 'b'
self.mapping._mapping[(EV_KEY, 40)] = 'b'
self.assertEqual(len(self.mapping), 1)
self.mapping.clear(40)
self.mapping.clear(EV_KEY, 40)
self.assertEqual(len(self.mapping), 0)
self.assertTrue(self.mapping.changed)
self.mapping.change(10, 'KP_1', None)
self.mapping.change(EV_KEY, 10, 'KP_1', None)
self.assertTrue(self.mapping.changed)
self.mapping.change(20, 'KP_2', None)
self.mapping.change(30, 'KP_3', None)
self.mapping.change(EV_KEY, 20, 'KP_2', None)
self.mapping.change(EV_KEY, 30, 'KP_3', None)
self.assertEqual(len(self.mapping), 3)
self.mapping.clear(20)
self.mapping.clear(EV_KEY, 20)
self.assertEqual(len(self.mapping), 2)
self.assertEqual(self.mapping.get_character(10), 'KP_1')
self.assertIsNone(self.mapping.get_character(20))
self.assertEqual(self.mapping.get_character(30), 'KP_3')
self.assertEqual(self.mapping.get_character(EV_KEY, 10), 'KP_1')
self.assertIsNone(self.mapping.get_character(EV_KEY, 20))
self.assertEqual(self.mapping.get_character(EV_KEY, 30), 'KP_3')
def test_empty(self):
self.mapping.change(10, '1')
self.mapping.change(11, '2')
self.mapping.change(12, '3')
self.mapping.change(EV_KEY, 10, '1')
self.mapping.change(EV_KEY, 11, '2')
self.mapping.change(EV_KEY, 12, '3')
self.assertEqual(len(self.mapping), 3)
self.mapping.empty()
self.assertEqual(len(self.mapping), 0)