sporq/kmk_firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
49ac7c2e40f0222be63d1102b0584e0c15b085c2
kmk_firmware/kmk/keys.py
Jasper Chan 49ac7c2e40 Move key definitions into a dict
2021-05-18 17:30:17 -07:00

656 lines
22 KiB
Python
Raw Blame History

from micropython import const
import kmk.handlers.stock as handlers
from kmk.consts import UnicodeMode
from kmk.key_validators import (
key_seq_sleep_validator,
tap_dance_key_validator,
unicode_mode_key_validator,
)
from kmk.types import AttrDict, UnicodeModeKeyMeta
FIRST_KMK_INTERNAL_KEY = const(1000)
NEXT_AVAILABLE_KEY = 1000
KEY_SIMPLE = const(0)
KEY_MODIFIER = const(1)
KEY_CONSUMER = const(2)
KEY_SHIFTED = const(3)
KEY_ARGUMENTED = const(4)
class KeyAttrDict(AttrDict):
def __getattr__(self, key):
try:
return super(KeyAttrDict, self).__getattr__(key)
except:
pass
for names, args in key_map.items():
maker = key_makers[args[1]]
if len(args) > 2:
kwargs = args[2]
else:
kwargs = {}
if key in names:
if isinstance(args[0], int):
maker(code=args[0], names=names, **kwargs)
elif isinstance(args[0], str):
maker(args[0], names=names, **kwargs)
else:
maker(names=names, **kwargs)
return self.__getattr__(key)
else:
raise ValueError("Invalid key")
# Global state, will be filled in througout this file, and
# anywhere the user creates custom keys
KC = KeyAttrDict()
class Key:
def __init__(
self,
code,
has_modifiers=None,
no_press=False,
no_release=False,
on_press=handlers.default_pressed,
on_release=handlers.default_released,
meta=object(),
):
self.code = code
self.has_modifiers = has_modifiers
# cast to bool() in case we get a None value
self.no_press = bool(no_press)
self.no_release = bool(no_press)
self._pre_press_handlers = []
self._post_press_handlers = []
self._pre_release_handlers = []
self._post_release_handlers = []
self._handle_press = on_press
self._handle_release = on_release
self.meta = meta
def __call__(self, no_press=None, no_release=None):
if no_press is None and no_release is None:
return self
return Key(
code=self.code,
has_modifiers=self.has_modifiers,
no_press=no_press,
no_release=no_release,
)
def __repr__(self):
return 'Key(code={}, has_modifiers={})'.format(self.code, self.has_modifiers)
def on_press(self, state, coord_int, coord_raw):
for fn in self._pre_press_handlers:
if not fn(self, state, KC, coord_int, coord_raw):
return None
ret = self._handle_press(self, state, KC, coord_int, coord_raw)
for fn in self._post_press_handlers:
fn(self, state, KC, coord_int, coord_raw)
return ret
def on_release(self, state, coord_int, coord_raw):
for fn in self._pre_release_handlers:
if not fn(self, state, KC, coord_int, coord_raw):
return None
ret = self._handle_release(self, state, KC, coord_int, coord_raw)
for fn in self._post_release_handlers:
fn(self, state, KC, coord_int, coord_raw)
return ret
def clone(self):
'''
Return a shallow clone of the current key without any pre/post press/release
handlers attached. Almost exclusively useful for creating non-colliding keys
to use such handlers.
'''
return type(self)(
code=self.code,
has_modifiers=self.has_modifiers,
no_press=self.no_press,
no_release=self.no_release,
on_press=self._handle_press,
on_release=self._handle_release,
meta=self.meta,
)
def before_press_handler(self, fn):
'''
Attach a callback to be run prior to the on_press handler for this key.
Receives the following:
- self (this Key instance)
- state (the current InternalState)
- KC (the global KC lookup table, for convenience)
- coord_int (an internal integer representation of the matrix coordinate
for the pressed key - this is likely not useful to end users, but is
provided for consistency with the internal handlers)
- coord_raw (an X,Y tuple of the matrix coordinate - also likely not useful)
If return value of the provided callback is evaluated to False, press
processing is cancelled. Exceptions are _not_ caught, and will likely
crash KMK if not handled within your function.
These handlers are run in attachment order: handlers provided by earlier
calls of this method will be executed before those provided by later calls.
'''
self._pre_press_handlers.append(fn)
return self
def after_press_handler(self, fn):
'''
Attach a callback to be run after the on_release handler for this key.
Receives the following:
- self (this Key instance)
- state (the current InternalState)
- KC (the global KC lookup table, for convenience)
- coord_int (an internal integer representation of the matrix coordinate
for the pressed key - this is likely not useful to end users, but is
provided for consistency with the internal handlers)
- coord_raw (an X,Y tuple of the matrix coordinate - also likely not useful)
The return value of the provided callback is discarded. Exceptions are _not_
caught, and will likely crash KMK if not handled within your function.
These handlers are run in attachment order: handlers provided by earlier
calls of this method will be executed before those provided by later calls.
'''
self._post_press_handlers.append(fn)
return self
def before_release_handler(self, fn):
'''
Attach a callback to be run prior to the on_release handler for this
key. Receives the following:
- self (this Key instance)
- state (the current InternalState)
- KC (the global KC lookup table, for convenience)
- coord_int (an internal integer representation of the matrix coordinate
for the pressed key - this is likely not useful to end users, but is
provided for consistency with the internal handlers)
- coord_raw (an X,Y tuple of the matrix coordinate - also likely not useful)
If return value of the provided callback evaluates to False, the release
processing is cancelled. Exceptions are _not_ caught, and will likely crash
KMK if not handled within your function.
These handlers are run in attachment order: handlers provided by earlier
calls of this method will be executed before those provided by later calls.
'''
self._pre_release_handlers.append(fn)
return self
def after_release_handler(self, fn):
'''
Attach a callback to be run after the on_release handler for this key.
Receives the following:
- self (this Key instance)
- state (the current InternalState)
- KC (the global KC lookup table, for convenience)
- coord_int (an internal integer representation of the matrix coordinate
for the pressed key - this is likely not useful to end users, but is
provided for consistency with the internal handlers)
- coord_raw (an X,Y tuple of the matrix coordinate - also likely not useful)
The return value of the provided callback is discarded. Exceptions are _not_
caught, and will likely crash KMK if not handled within your function.
These handlers are run in attachment order: handlers provided by earlier
calls of this method will be executed before those provided by later calls.
'''
self._post_release_handlers.append(fn)
return self
class ModifierKey(Key):
# FIXME this is atrocious to read. Please, please, please, strike down upon
# this with great vengeance and furious anger.
FAKE_CODE = const(-1)
def __call__(self, modified_code=None, no_press=None, no_release=None):
if modified_code is None and no_press is None and no_release is None:
return self
if modified_code is not None:
if isinstance(modified_code, ModifierKey):
new_keycode = ModifierKey(
ModifierKey.FAKE_CODE,
set() if self.has_modifiers is None else self.has_modifiers,
no_press=no_press,
no_release=no_release,
)
if self.code != ModifierKey.FAKE_CODE:
new_keycode.has_modifiers.add(self.code)
if modified_code.code != ModifierKey.FAKE_CODE:
new_keycode.has_modifiers.add(modified_code.code)
else:
new_keycode = Key(
modified_code.code,
{self.code},
no_press=no_press,
no_release=no_release,
)
if modified_code.has_modifiers:
new_keycode.has_modifiers |= modified_code.has_modifiers
else:
new_keycode = Key(self.code, no_press=no_press, no_release=no_release)
return new_keycode
def __repr__(self):
return 'ModifierKey(code={}, has_modifiers={})'.format(
self.code, self.has_modifiers
)
class ConsumerKey(Key):
pass
def register_key_names(key, names=tuple()): # NOQA
'''
Names are globally unique. If a later key is created with
the same name as an existing entry in `KC`, it will overwrite
the existing entry.
If a name entry is only a single letter, its entry in the KC
object will not be case-sensitive (meaning `names=('A',)` is
sufficient to create a key accessible by both `KC.A` and `KC.a`).
'''
for name in names:
KC[name] = key
if len(name) == 1:
KC[name.upper()] = key
KC[name.lower()] = key
return key
def make_key(code=None, names=tuple(), type=KEY_SIMPLE, **kwargs): # NOQA
'''
Create a new key, aliased by `names` in the KC lookup table.
If a code is not specified, the key is assumed to be a custom
internal key to be handled in a state callback rather than
sent directly to the OS. These codes will autoincrement.
See register_key_names() for details on the assignment.
All **kwargs are passed to the Key constructor
'''
global NEXT_AVAILABLE_KEY
if type == KEY_SIMPLE:
constructor = Key
elif type == KEY_MODIFIER:
constructor = ModifierKey
elif type == KEY_CONSUMER:
constructor = ConsumerKey
else:
raise ValueError('Unrecognized key type')
if code is None:
code = NEXT_AVAILABLE_KEY
NEXT_AVAILABLE_KEY += 1
elif code >= FIRST_KMK_INTERNAL_KEY:
# Try to ensure future auto-generated internal keycodes won't
# be overridden by continuing to +1 the sequence from the provided
# code
NEXT_AVAILABLE_KEY = max(NEXT_AVAILABLE_KEY, code + 1)
key = constructor(code=code, **kwargs)
register_key_names(key, names)
return key
def make_mod_key(*args, **kwargs):
return make_key(*args, **kwargs, type=KEY_MODIFIER)
def make_shifted_key(target_name, names=tuple()): # NOQA
key = KC.LSFT(KC[target_name])
register_key_names(key, names)
return key
def make_consumer_key(*args, **kwargs):
return make_key(*args, **kwargs, type=KEY_CONSUMER)
# Argumented keys are implicitly internal, so auto-gen of code
# is almost certainly the best plan here
def make_argumented_key(
validator=lambda *validator_args, **validator_kwargs: object(),
names=tuple(), # NOQA
*constructor_args,
**constructor_kwargs,
):
global NEXT_AVAILABLE_KEY
def _argumented_key(*user_args, **user_kwargs):
global NEXT_AVAILABLE_KEY
meta = validator(*user_args, **user_kwargs)
if meta:
key = Key(
NEXT_AVAILABLE_KEY, meta=meta, *constructor_args, **constructor_kwargs
)
NEXT_AVAILABLE_KEY += 1
return key
else:
raise ValueError(
'Argumented key validator failed for unknown reasons. '
"This may not be the keymap's fault, as a more specific error "
'should have been raised.'
)
for name in names:
KC[name] = _argumented_key
return _argumented_key
key_makers = {
KEY_SIMPLE: make_key,
KEY_MODIFIER: make_mod_key,
KEY_CONSUMER: make_consumer_key,
KEY_SHIFTED: make_shifted_key,
KEY_ARGUMENTED: make_argumented_key,
}
key_map = {
('LEFT_CONTROL', 'LCTRL', 'LCTL'): (1, KEY_MODIFIER),
('LEFT_SHIFT', 'LSHIFT', 'LSFT'): (2, KEY_MODIFIER),
('LEFT_ALT', 'LALT'): (4, KEY_MODIFIER),
('LEFT_SUPER', 'LGUI', 'LCMD', 'LWIN'): (8, KEY_MODIFIER),
('RIGHT_CONTROL', 'RCTRL', 'RCTL'): (16, KEY_MODIFIER),
('RIGHT_SHIFT', 'RSHIFT', 'RSFT'): (32, KEY_MODIFIER),
('RIGHT_ALT', 'RALT'): (64, KEY_MODIFIER),
('RIGHT_SUPER', 'RGUI', 'RCMD', 'RWIN'): (128, KEY_MODIFIER),
('MEH',): (7, KEY_MODIFIER),
('HYPER', 'HYPR'): (15, KEY_MODIFIER),
('A',): (4, KEY_SIMPLE),
('B',): (5, KEY_SIMPLE),
('C',): (6, KEY_SIMPLE),
('D',): (7, KEY_SIMPLE),
('E',): (8, KEY_SIMPLE),
('F',): (9, KEY_SIMPLE),
('G',): (10, KEY_SIMPLE),
('H',): (11, KEY_SIMPLE),
('I',): (12, KEY_SIMPLE),
('J',): (13, KEY_SIMPLE),
('K',): (14, KEY_SIMPLE),
('L',): (15, KEY_SIMPLE),
('M',): (16, KEY_SIMPLE),
('N',): (17, KEY_SIMPLE),
('O',): (18, KEY_SIMPLE),
('P',): (19, KEY_SIMPLE),
('Q',): (20, KEY_SIMPLE),
('R',): (21, KEY_SIMPLE),
('S',): (22, KEY_SIMPLE),
('T',): (23, KEY_SIMPLE),
('U',): (24, KEY_SIMPLE),
('V',): (25, KEY_SIMPLE),
('W',): (26, KEY_SIMPLE),
('X',): (27, KEY_SIMPLE),
('Y',): (28, KEY_SIMPLE),
('Z',): (29, KEY_SIMPLE),
('1', 'N1'): (30, KEY_SIMPLE),
('2', 'N2'): (31, KEY_SIMPLE),
('3', 'N3'): (32, KEY_SIMPLE),
('4', 'N4'): (33, KEY_SIMPLE),
('5', 'N5'): (34, KEY_SIMPLE),
('6', 'N6'): (35, KEY_SIMPLE),
('7', 'N7'): (36, KEY_SIMPLE),
('8', 'N8'): (37, KEY_SIMPLE),
('9', 'N9'): (38, KEY_SIMPLE),
('0', 'N0'): (39, KEY_SIMPLE),
('ENTER', 'ENT', '\n'): (40, KEY_SIMPLE),
('ESCAPE', 'ESC'): (41, KEY_SIMPLE),
('BACKSPACE', 'BSPC', 'BKSP'): (42, KEY_SIMPLE),
('TAB', '\t'): (43, KEY_SIMPLE),
('SPACE', 'SPC', ' '): (44, KEY_SIMPLE),
('MINUS', 'MINS', '-'): (45, KEY_SIMPLE),
('EQUAL', 'EQL', '='): (46, KEY_SIMPLE),
('LBRACKET', 'LBRC', '['): (47, KEY_SIMPLE),
('RBRACKET', 'RBRC', ']'): (48, KEY_SIMPLE),
('BACKSLASH', 'BSLASH', 'BSLS', '\\'): (49, KEY_SIMPLE),
('SEMICOLON', 'SCOLON', 'SCLN', ';'): (51, KEY_SIMPLE),
('QUOTE', 'QUOT', "'"): (52, KEY_SIMPLE),
('GRAVE', 'GRV', 'ZKHK', '`'): (53, KEY_SIMPLE),
('COMMA', 'COMM', ','): (54, KEY_SIMPLE),
('DOT', '.'): (55, KEY_SIMPLE),
('SLASH', 'SLSH'): (56, KEY_SIMPLE),
('F1',): (58, KEY_SIMPLE),
('F2',): (59, KEY_SIMPLE),
('F3',): (60, KEY_SIMPLE),
('F4',): (61, KEY_SIMPLE),
('F5',): (62, KEY_SIMPLE),
('F6',): (63, KEY_SIMPLE),
('F7',): (64, KEY_SIMPLE),
('F8',): (65, KEY_SIMPLE),
('F9',): (66, KEY_SIMPLE),
('F10',): (67, KEY_SIMPLE),
('F11',): (68, KEY_SIMPLE),
('F12',): (69, KEY_SIMPLE),
('F13',): (104, KEY_SIMPLE),
('F14',): (105, KEY_SIMPLE),
('F15',): (106, KEY_SIMPLE),
('F16',): (107, KEY_SIMPLE),
('F17',): (108, KEY_SIMPLE),
('F18',): (109, KEY_SIMPLE),
('F19',): (110, KEY_SIMPLE),
('F20',): (111, KEY_SIMPLE),
('F21',): (112, KEY_SIMPLE),
('F22',): (113, KEY_SIMPLE),
('F23',): (114, KEY_SIMPLE),
('F24',): (115, KEY_SIMPLE),
('CAPS_LOCK', 'CAPSLOCK', 'CLCK', 'CAPS'): (57, KEY_SIMPLE),
('PRINT_SCREEN', 'PSCREEN', 'PSCR'): (70, KEY_SIMPLE),
('SCROLL_LOCK', 'SCROLLLOCK', 'SLCK'): (71, KEY_SIMPLE),
('PAUSE', 'PAUS', 'BRK'): (72, KEY_SIMPLE),
('INSERT', 'INS'): (73, KEY_SIMPLE),
('HOME',): (74, KEY_SIMPLE),
('PGUP',): (75, KEY_SIMPLE),
('DELETE', 'DEL'): (76, KEY_SIMPLE),
('END',): (77, KEY_SIMPLE),
('PGDOWN', 'PGDN'): (78, KEY_SIMPLE),
('RIGHT', 'RGHT'): (79, KEY_SIMPLE),
('LEFT',): (80, KEY_SIMPLE),
('DOWN',): (81, KEY_SIMPLE),
('UP',): (82, KEY_SIMPLE),
('NUM_LOCK', 'NUMLOCK', 'NLCK'): (83, KEY_SIMPLE),
('KP_SLASH', 'NUMPAD_SLASH', 'PSLS'): (84, KEY_SIMPLE),
('KP_ASTERISK', 'NUMPAD_ASTERISK', 'PAST'): (85, KEY_SIMPLE),
('KP_MINUS', 'NUMPAD_MINUS', 'PMNS'): (86, KEY_SIMPLE),
('KP_PLUS', 'NUMPAD_PLUS', 'PPLS'): (87, KEY_SIMPLE),
('KP_ENTER', 'NUMPAD_ENTER', 'PENT'): (88, KEY_SIMPLE),
('KP_1', 'P1', 'NUMPAD_1'): (89, KEY_SIMPLE),
('KP_2', 'P2', 'NUMPAD_2'): (90, KEY_SIMPLE),
('KP_3', 'P3', 'NUMPAD_3'): (91, KEY_SIMPLE),
('KP_4', 'P4', 'NUMPAD_4'): (92, KEY_SIMPLE),
('KP_5', 'P5', 'NUMPAD_5'): (93, KEY_SIMPLE),
('KP_6', 'P6', 'NUMPAD_6'): (94, KEY_SIMPLE),
('KP_7', 'P7', 'NUMPAD_7'): (95, KEY_SIMPLE),
('KP_8', 'P8', 'NUMPAD_8'): (96, KEY_SIMPLE),
('KP_9', 'P9', 'NUMPAD_9'): (97, KEY_SIMPLE),
('KP_0', 'P0', 'NUMPAD_0'): (98, KEY_SIMPLE),
('KP_DOT', 'PDOT', 'NUMPAD_DOT'): (99, KEY_SIMPLE),
('KP_EQUAL', 'PEQL', 'NUMPAD_EQUAL'): (103, KEY_SIMPLE),
('KP_COMMA', 'PCMM', 'NUMPAD_COMMA'): (133, KEY_SIMPLE),
('KP_EQUAL_AS400', 'NUMPAD_EQUAL_AS400'): (134, KEY_SIMPLE),
('TILDE', 'TILD', '~'): ('GRAVE', KEY_SHIFTED),
('EXCLAIM', 'EXLM', '!'): ('1', KEY_SHIFTED),
('AT', '@'): ('2', KEY_SHIFTED),
('HASH', 'POUND', '#'): ('3', KEY_SHIFTED),
('DOLLAR', 'DLR', '$'): ('4', KEY_SHIFTED),
('PERCENT', 'PERC', '%'): ('5', KEY_SHIFTED),
('CIRCUMFLEX', 'CIRC', '^'): ('6', KEY_SHIFTED),
('AMPERSAND', 'AMPR', '&'): ('7', KEY_SHIFTED),
('ASTERISK', 'ASTR', '*'): ('8', KEY_SHIFTED),
('LEFT_PAREN', 'LPRN', '('): ('9', KEY_SHIFTED),
('RIGHT_PAREN', 'RPRN', ')'): ('0', KEY_SHIFTED),
('UNDERSCORE', 'UNDS', '_'): ('MINUS', KEY_SHIFTED),
('PLUS', '+'): ('EQUAL', KEY_SHIFTED),
('LEFT_CURLY_BRACE', 'LCBR', '{'): ('LBRACKET', KEY_SHIFTED),
('RIGHT_CURLY_BRACE', 'RCBR', '}'): ('RBRACKET', KEY_SHIFTED),
('PIPE', '|'): ('BACKSLASH', KEY_SHIFTED),
('COLON', 'COLN', ':'): ('SEMICOLON', KEY_SHIFTED),
('DOUBLE_QUOTE', 'DQUO', 'DQT', '"'): ('QUOTE', KEY_SHIFTED),
('LEFT_ANGLE_BRACKET', 'LABK', '<'): ('COMMA', KEY_SHIFTED),
('RIGHT_ANGLE_BRACKET', 'RABK', '>'): ('DOT', KEY_SHIFTED),
('QUESTION', 'QUES', '?'): ('SLSH', KEY_SHIFTED),
('NONUS_HASH', 'NUHS'): (50, KEY_SIMPLE),
('NONUS_BSLASH', 'NUBS'): (100, KEY_SIMPLE),
('APP', 'APPLICATION', 'SEL', 'WINMENU'): (101, KEY_SIMPLE),
('INT1', 'RO'): (135, KEY_SIMPLE),
('INT2', 'KANA'): (136, KEY_SIMPLE),
('INT3', 'JYEN'): (137, KEY_SIMPLE),
('INT4', 'HENK'): (138, KEY_SIMPLE),
('INT5', 'MHEN'): (139, KEY_SIMPLE),
('INT6',): (140, KEY_SIMPLE),
('INT7',): (141, KEY_SIMPLE),
('INT8',): (142, KEY_SIMPLE),
('INT9',): (143, KEY_SIMPLE),
('LANG1', 'HAEN'): (144, KEY_SIMPLE),
('LANG2', 'HAEJ'): (145, KEY_SIMPLE),
('LANG3',): (146, KEY_SIMPLE),
('LANG4',): (147, KEY_SIMPLE),
('LANG5',): (148, KEY_SIMPLE),
('LANG6',): (149, KEY_SIMPLE),
('LANG7',): (150, KEY_SIMPLE),
('LANG8',): (151, KEY_SIMPLE),
('LANG9',): (152, KEY_SIMPLE),
('AUDIO_MUTE', 'MUTE'): (226, KEY_CONSUMER),
('AUDIO_VOL_UP', 'VOLU'): (233, KEY_CONSUMER),
('AUDIO_VOL_DOWN', 'VOLD'): (234, KEY_CONSUMER),
('MEDIA_NEXT_TRACK', 'MNXT'): (181, KEY_CONSUMER),
('MEDIA_PREV_TRACK', 'MPRV'): (182, KEY_CONSUMER),
('MEDIA_STOP', 'MSTP'): (183, KEY_CONSUMER),
('MEDIA_PLAY_PAUSE', 'MPLY'): (205, KEY_CONSUMER),
('MEDIA_EJECT', 'EJCT'): (184, KEY_CONSUMER),
('MEDIA_FAST_FORWARD', 'MFFD'): (179, KEY_CONSUMER),
('MEDIA_REWIND', 'MRWD'): (180, KEY_CONSUMER),
('NO',): (
None,
KEY_SIMPLE,
{'on_press': handlers.passthrough, 'on_release': handlers.passthrough},
),
('TRANSPARENT', 'TRNS'): (
None,
KEY_SIMPLE,
{'on_press': handlers.passthrough, 'on_release': handlers.passthrough},
),
('RESET',): (None, KEY_SIMPLE, {'on_press': handlers.reset}),
('BOOTLOADER',): (None, KEY_SIMPLE, {'on_press': handlers.bootloader}),
('DEBUG', 'DBG'): (
None,
KEY_SIMPLE,
{'on_press': handlers.debug_pressed, 'on_release': handlers.passthrough},
),
('GESC',): (
None,
KEY_SIMPLE,
{'on_press': handlers.gesc_pressed, 'on_release': handlers.gesc_released},
),
('BKDL',): (
None,
KEY_SIMPLE,
{'on_press': handlers.bkdl_pressed, 'on_release': handlers.bkdl_released},
),
('GESC', 'GRAVE_ESC'): (
None,
KEY_SIMPLE,
{'on_press': handlers.gesc_pressed, 'on_release': handlers.gesc_released},
),
('MACRO_SLEEP_MS', 'SLEEP_IN_SEQ'): (
None,
KEY_ARGUMENTED,
{'validator': key_seq_sleep_validator, 'on_press': handlers.sleep_pressed},
),
('UC_MODE_NOOP', 'UC_DISABLE'): (
None,
KEY_SIMPLE,
{
'meta': UnicodeModeKeyMeta(UnicodeMode.NOOP),
'on_press': handlers.uc_mode_pressed,
},
),
('UC_MODE_LINUX', 'UC_MODE_IBUS'): (
None,
KEY_SIMPLE,
{
'meta': UnicodeModeKeyMeta(UnicodeMode.IBUS),
'on_press': handlers.uc_mode_pressed,
},
),
('UC_MODE_MACOS', 'UC_MODE_OSX', 'US_MODE_RALT'): (
None,
KEY_SIMPLE,
{
'meta': UnicodeModeKeyMeta(UnicodeMode.RALT),
'on_press': handlers.uc_mode_pressed,
},
),
('UC_MODE_WINC',): (
None,
KEY_SIMPLE,
{
'meta': UnicodeModeKeyMeta(UnicodeMode.WINC),
'on_press': handlers.uc_mode_pressed,
},
),
('UC_MODE',): (
None,
KEY_ARGUMENTED,
{'validator': unicode_mode_key_validator, 'on_press': handlers.uc_mode_pressed},
),
('TAP_DANCE', 'TD'): (
None,
KEY_ARGUMENTED,
{
'validator': tap_dance_key_validator,
'on_press': handlers.td_pressed,
'on_release': handlers.td_released,
},
),
('HID_SWITCH', 'HID'): (None, KEY_SIMPLE, {'on_press': handlers.hid_switch}),
}
Reference in New Issue View Git Blame Copy Permalink