sporq/kmk_firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

state to keyboard and hid switching

Browse Source
This commit is contained in:
Kyle Brown
2020-11-13 02:01:26 -08:00
parent 8839c1c7ec
commit 1bde64392e
4 changed files with 91 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
kmk/handlers/sequences.py
View File

@@ -13,21 +13,21 @@ def get_wide_ordinal(char):
return 0x10000 + (ord(char[0]) - 0xD800) * 0x400 + (ord(char[1]) - 0xDC00) return 0x10000 + (ord(char[0]) - 0xD800) * 0x400 + (ord(char[1]) - 0xDC00)
def sequence_press_handler(key, state, KC, *args, **kwargs): def sequence_press_handler(key, keyboard, KC, *args, **kwargs):
oldkeys_pressed = state.keys_pressed oldkeys_pressed = keyboard.keys_pressed
state.keys_pressed = set() keyboard.keys_pressed = set()
for ikey in key.meta.seq: for ikey in key.meta.seq:
if not getattr(ikey, 'no_press', None): if not getattr(ikey, 'no_press', None):
state.process_key(ikey, True) keyboard.process_key(ikey, True)
state._send_hid() keyboard._send_hid()
if not getattr(ikey, 'no_release', None): if not getattr(ikey, 'no_release', None):
state.process_key(ikey, False) keyboard.process_key(ikey, False)
state._send_hid() keyboard._send_hid()
state.keys_pressed = oldkeys_pressed keyboard.keys_pressed = oldkeys_pressed
return state return keyboard
def simple_key_sequence(seq): def simple_key_sequence(seq):
@@ -110,38 +110,38 @@ def unicode_codepoint_sequence(codepoints):
kc_macros = [simple_key_sequence(kc_seq) for kc_seq in kc_seqs] kc_macros = [simple_key_sequence(kc_seq) for kc_seq in kc_seqs]
def _unicode_sequence(key, state, *args, **kwargs): def _unicode_sequence(key, keyboard, *args, **kwargs):
if state.unicode_mode == UnicodeMode.IBUS: if keyboard.unicode_mode == UnicodeMode.IBUS:
state.process_key( keyboard.process_key(
simple_key_sequence(_ibus_unicode_sequence(kc_macros, state)), True simple_key_sequence(_ibus_unicode_sequence(kc_macros, keyboard)), True
) )
elif state.unicode_mode == UnicodeMode.RALT: elif keyboard.unicode_mode == UnicodeMode.RALT:
state.process_key( keyboard.process_key(
simple_key_sequence(_ralt_unicode_sequence(kc_macros, state)), True simple_key_sequence(_ralt_unicode_sequence(kc_macros, keyboard)), True
) )
elif state.unicode_mode == UnicodeMode.WINC: elif keyboard.unicode_mode == UnicodeMode.WINC:
state.process_key( keyboard.process_key(
simple_key_sequence(_winc_unicode_sequence(kc_macros, state)), True simple_key_sequence(_winc_unicode_sequence(kc_macros, keyboard)), True
) )
return make_key(on_press=_unicode_sequence) return make_key(on_press=_unicode_sequence)
def _ralt_unicode_sequence(kc_macros, state): def _ralt_unicode_sequence(kc_macros, keyboard):
for kc_macro in kc_macros: for kc_macro in kc_macros:
yield RALT_DOWN_NO_RELEASE yield RALT_DOWN_NO_RELEASE
yield kc_macro yield kc_macro
yield RALT_UP_NO_PRESS yield RALT_UP_NO_PRESS
def _ibus_unicode_sequence(kc_macros, state): def _ibus_unicode_sequence(kc_macros, keyboard):
for kc_macro in kc_macros: for kc_macro in kc_macros:
yield IBUS_KEY_COMBO yield IBUS_KEY_COMBO
yield kc_macro yield kc_macro
yield ENTER_KEY yield ENTER_KEY
def _winc_unicode_sequence(kc_macros, state): def _winc_unicode_sequence(kc_macros, keyboard):
''' '''
Send unicode sequence using WinCompose: Send unicode sequence using WinCompose:

119
kmk/handlers/stock.py
View File

@@ -1,30 +1,32 @@
from kmk.kmktime import sleep_ms from kmk.kmktime import sleep_ms
def passthrough(key, state, *args, **kwargs): def passthrough(key, keyboard, *args, **kwargs):
return state return keyboard
def default_pressed(key, state, KC, coord_int=None, coord_raw=None, *args, **kwargs): def default_pressed(key, keyboard, KC, coord_int=None, coord_raw=None, *args, **kwargs):
state.hid_pending = True keyboard.hid_pending = True
if coord_int is not None: if coord_int is not None:
state._coordkeys_pressed[coord_int] = key keyboard._coordkeys_pressed[coord_int] = key
state.keys_pressed.add(key) keyboard.keys_pressed.add(key)
return state return keyboard
def default_released(key, state, KC, coord_int=None, coord_raw=None, *args, **kwargs): def default_released(
state.hid_pending = True key, keyboard, KC, coord_int=None, coord_raw=None, *args, **kwargs # NOQA
state.keys_pressed.discard(key) ):
keyboard.hid_pending = True
keyboard.keys_pressed.discard(key)
if coord_int is not None: if coord_int is not None:
state.keys_pressed.discard(state._coordkeys_pressed.get(coord_int, None)) keyboard.keys_pressed.discard(keyboard._coordkeys_pressed.get(coord_int, None))
state._coordkeys_pressed[coord_int] = None keyboard._coordkeys_pressed[coord_int] = None
return state return keyboard
def reset(*args, **kwargs): def reset(*args, **kwargs):
@@ -40,79 +42,88 @@ def bootloader(*args, **kwargs):
microcontroller.reset() microcontroller.reset()
def debug_pressed(key, state, KC, *args, **kwargs): def debug_pressed(key, keyboard, KC, *args, **kwargs):
if state.debug_enabled: if keyboard.debug_enabled:
print('DebugDisable()') print('DebugDisable()')
else: else:
print('DebugEnable()') print('DebugEnable()')
state.debug_enabled = not state.debug_enabled keyboard.debug_enabled = not keyboard.debug_enabled
return state return keyboard
def gesc_pressed(key, state, KC, *args, **kwargs): def gesc_pressed(key, keyboard, KC, *args, **kwargs):
GESC_TRIGGERS = {KC.LSHIFT, KC.RSHIFT, KC.LGUI, KC.RGUI} GESC_TRIGGERS = {KC.LSHIFT, KC.RSHIFT, KC.LGUI, KC.RGUI}
if GESC_TRIGGERS.intersection(state.keys_pressed): if GESC_TRIGGERS.intersection(keyboard.keys_pressed):
# First, release GUI if already pressed # First, release GUI if already pressed
state._send_hid() keyboard._send_hid()
# if Shift is held, KC_GRAVE will become KC_TILDE on OS level # if Shift is held, KC_GRAVE will become KC_TILDE on OS level
state.keys_pressed.add(KC.GRAVE) keyboard.keys_pressed.add(KC.GRAVE)
state.hid_pending = True keyboard.hid_pending = True
return state return keyboard
# else return KC_ESC # else return KC_ESC
state.keys_pressed.add(KC.ESCAPE) keyboard.keys_pressed.add(KC.ESCAPE)
state.hid_pending = True keyboard.hid_pending = True
return state return keyboard
def gesc_released(key, state, KC, *args, **kwargs): def gesc_released(key, keyboard, KC, *args, **kwargs):
state.keys_pressed.discard(KC.ESCAPE) keyboard.keys_pressed.discard(KC.ESCAPE)
state.keys_pressed.discard(KC.GRAVE) keyboard.keys_pressed.discard(KC.GRAVE)
state.hid_pending = True keyboard.hid_pending = True
return state return keyboard
def bkdl_pressed(key, state, KC, *args, **kwargs): def bkdl_pressed(key, keyboard, KC, *args, **kwargs):
BKDL_TRIGGERS = {KC.LGUI, KC.RGUI} BKDL_TRIGGERS = {KC.LGUI, KC.RGUI}
if BKDL_TRIGGERS.intersection(state.keys_pressed): if BKDL_TRIGGERS.intersection(keyboard.keys_pressed):
state._send_hid() keyboard._send_hid()
state.keys_pressed.add(KC.DEL) keyboard.keys_pressed.add(KC.DEL)
state.hid_pending = True keyboard.hid_pending = True
return state return keyboard
# else return KC_ESC # else return KC_ESC
state.keys_pressed.add(KC.BKSP) keyboard.keys_pressed.add(KC.BKSP)
state.hid_pending = True keyboard.hid_pending = True
return state return keyboard
def bkdl_released(key, state, KC, *args, **kwargs): def bkdl_released(key, keyboard, KC, *args, **kwargs):
state.keys_pressed.discard(KC.BKSP) keyboard.keys_pressed.discard(KC.BKSP)
state.keys_pressed.discard(KC.DEL) keyboard.keys_pressed.discard(KC.DEL)
state.hid_pending = True keyboard.hid_pending = True
return state return keyboard
def sleep_pressed(key, state, KC, *args, **kwargs): def sleep_pressed(key, keyboard, KC, *args, **kwargs):
sleep_ms(key.meta.ms) sleep_ms(key.meta.ms)
return state return keyboard
def uc_mode_pressed(key, state, *args, **kwargs): def uc_mode_pressed(key, keyboard, *args, **kwargs):
state.unicode_mode = key.meta.mode keyboard.unicode_mode = key.meta.mode
return state return keyboard
def td_pressed(key, state, *args, **kwargs): def td_pressed(key, keyboard, *args, **kwargs):
return state._process_tap_dance(key, True) return keyboard._process_tap_dance(key, True)
def td_released(key, state, *args, **kwargs): def td_released(key, keyboard, *args, **kwargs):
return state._process_tap_dance(key, False) return keyboard._process_tap_dance(key, False)
def hid_switch(key, keyboard, *args, **kwargs):
keyboard.hid_type, keyboard.secondary_hid_type = (
keyboard.secondary_hid_type,
keyboard.hid_type,
)
keyboard._init_hid()
return keyboard

1
kmk/keys.py
View File

@@ -649,3 +649,4 @@ make_argumented_key(
on_press=handlers.td_pressed, on_press=handlers.td_pressed,
on_release=handlers.td_released, on_release=handlers.td_released,
) )
make_key(names=('HID_SWITCH', 'HID'), on_press=handlers.hid_switch)

4
kmk/kmk_keyboard.py
View File

@@ -39,6 +39,7 @@ class KMKKeyboard:
keys_pressed = set() keys_pressed = set()
_coordkeys_pressed = {} _coordkeys_pressed = {}
hid_type = HIDModes.USB hid_type = HIDModes.USB
secondary_hid_type = None
_hid_helper = None _hid_helper = None
hid_pending = False hid_pending = False
state_layer_key = None state_layer_key = None
@@ -429,8 +430,9 @@ class KMKKeyboard:
if self.debug_enabled: if self.debug_enabled:
print('Failed to run post hid function in extension: ', err, ext) print('Failed to run post hid function in extension: ', err, ext)
def go(self, hid_type=HIDModes.USB, **kwargs): def go(self, hid_type=HIDModes.USB, secondary_hid_type=None, **kwargs):
self.hid_type = hid_type self.hid_type = hid_type
self.secondary_hid_type = secondary_hid_type
self._init_sanity_check() self._init_sanity_check()
self._init_coord_mapping() self._init_coord_mapping()