feat(extensions): most of the extensions implementation, by kdb424
This commit is contained in:
Kyle Brown
Josh Klar
@@ -1,124 +0,0 @@
|
||||
from kmk.kmktime import ticks_diff, ticks_ms
|
||||
|
||||
|
||||
def df_pressed(key, state, *args, **kwargs):
|
||||
'''
|
||||
Switches the default layer
|
||||
'''
|
||||
state._active_layers[-1] = key.meta.layer
|
||||
return state
|
||||
|
||||
|
||||
def mo_pressed(key, state, *args, **kwargs):
|
||||
'''
|
||||
Momentarily activates layer, switches off when you let go
|
||||
'''
|
||||
state._active_layers.insert(0, key.meta.layer)
|
||||
return state
|
||||
|
||||
|
||||
def mo_released(key, state, KC, *args, **kwargs):
|
||||
# remove the first instance of the target layer
|
||||
# from the active list
|
||||
# under almost all normal use cases, this will
|
||||
# disable the layer (but preserve it if it was triggered
|
||||
# as a default layer, etc.)
|
||||
# this also resolves an issue where using DF() on a layer
|
||||
# triggered by MO() and then defaulting to the MO()'s layer
|
||||
# would result in no layers active
|
||||
try:
|
||||
del_idx = state._active_layers.index(key.meta.layer)
|
||||
del state._active_layers[del_idx]
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
return state
|
||||
|
||||
|
||||
def lm_pressed(key, state, *args, **kwargs):
|
||||
'''
|
||||
As MO(layer) but with mod active
|
||||
'''
|
||||
state._hid_pending = True
|
||||
# Sets the timer start and acts like MO otherwise
|
||||
state._start_time['lm'] = ticks_ms()
|
||||
state._keys_pressed.add(key.meta.kc)
|
||||
return mo_pressed(key, state, *args, **kwargs)
|
||||
|
||||
|
||||
def lm_released(key, state, *args, **kwargs):
|
||||
'''
|
||||
As MO(layer) but with mod active
|
||||
'''
|
||||
state._hid_pending = True
|
||||
state._keys_pressed.discard(key.meta.kc)
|
||||
state._start_time['lm'] = None
|
||||
return mo_released(key, state, *args, **kwargs)
|
||||
|
||||
|
||||
def lt_pressed(key, state, *args, **kwargs):
|
||||
# Sets the timer start and acts like MO otherwise
|
||||
state._start_time['lt'] = ticks_ms()
|
||||
return mo_pressed(key, state, *args, **kwargs)
|
||||
|
||||
|
||||
def lt_released(key, state, *args, **kwargs):
|
||||
# On keyup, check timer, and press key if needed.
|
||||
if state._start_time['lt'] and (
|
||||
ticks_diff(ticks_ms(), state._start_time['lt']) < state.tap_time
|
||||
):
|
||||
state._hid_pending = True
|
||||
state._tap_key(key.meta.kc)
|
||||
|
||||
mo_released(key, state, *args, **kwargs)
|
||||
state._start_time['lt'] = None
|
||||
return state
|
||||
|
||||
|
||||
def tg_pressed(key, state, *args, **kwargs):
|
||||
'''
|
||||
Toggles the layer (enables it if not active, and vise versa)
|
||||
'''
|
||||
# See mo_released for implementation details around this
|
||||
try:
|
||||
del_idx = state._active_layers.index(key.meta.layer)
|
||||
del state._active_layers[del_idx]
|
||||
except ValueError:
|
||||
state._active_layers.insert(0, key.meta.layer)
|
||||
|
||||
return state
|
||||
|
||||
|
||||
def to_pressed(key, state, *args, **kwargs):
|
||||
'''
|
||||
Activates layer and deactivates all other layers
|
||||
'''
|
||||
state._active_layers.clear()
|
||||
state._active_layers.insert(0, key.meta.layer)
|
||||
|
||||
return state
|
||||
|
||||
|
||||
def tt_pressed(key, state, *args, **kwargs):
|
||||
'''
|
||||
Momentarily activates layer if held, toggles it if tapped repeatedly
|
||||
'''
|
||||
# TODO Make this work with tap dance to function more correctly, but technically works.
|
||||
if state._start_time['tt'] is None:
|
||||
# Sets the timer start and acts like MO otherwise
|
||||
state._start_time['tt'] = ticks_ms()
|
||||
return mo_pressed(key, state, *args, **kwargs)
|
||||
elif ticks_diff(ticks_ms(), state._start_time['tt']) < state.tap_time:
|
||||
state._start_time['tt'] = None
|
||||
return tg_pressed(key, state, *args, **kwargs)
|
||||
|
||||
|
||||
def tt_released(key, state, *args, **kwargs):
|
||||
tap_timed_out = ticks_diff(ticks_ms(), state._start_time['tt']) >= state.tap_time
|
||||
if state._start_time['tt'] is None or tap_timed_out:
|
||||
# On first press, works like MO. On second press, does nothing unless let up within
|
||||
# time window, then acts like TG.
|
||||
state._start_time['tt'] = None
|
||||
return mo_released(key, state, *args, **kwargs)
|
||||
|
||||
return state
|
||||
@@ -1,23 +0,0 @@
|
||||
from kmk.kmktime import ticks_diff, ticks_ms
|
||||
|
||||
|
||||
def mt_pressed(key, state, *args, **kwargs):
|
||||
# Sets the timer start and acts like a modifier otherwise
|
||||
state._keys_pressed.add(key.meta.mods)
|
||||
|
||||
state._start_time['mod_tap'] = ticks_ms()
|
||||
return state
|
||||
|
||||
|
||||
def mt_released(key, state, *args, **kwargs):
|
||||
# On keyup, check timer, and press key if needed.
|
||||
state._keys_pressed.discard(key.meta.mods)
|
||||
timer_name = 'mod_tap'
|
||||
if state._start_time[timer_name] and (
|
||||
ticks_diff(ticks_ms(), state._start_time[timer_name]) < state.tap_time
|
||||
):
|
||||
state._hid_pending = True
|
||||
state._tap_key(key.meta.kc)
|
||||
|
||||
state._start_time[timer_name] = None
|
||||
return state
|
||||
@@ -1,3 +1,5 @@
|
||||
import gc
|
||||
|
||||
from kmk.consts import UnicodeMode
|
||||
from kmk.handlers.stock import passthrough
|
||||
from kmk.keys import KC, make_key
|
||||
@@ -11,21 +13,21 @@ def get_wide_ordinal(char):
|
||||
return 0x10000 + (ord(char[0]) - 0xD800) * 0x400 + (ord(char[1]) - 0xDC00)
|
||||
|
||||
|
||||
def sequence_press_handler(key, state, KC, *args, **kwargs):
|
||||
old_keys_pressed = state._keys_pressed
|
||||
state._keys_pressed = set()
|
||||
def sequence_press_handler(key, keyboard, KC, *args, **kwargs):
|
||||
oldkeys_pressed = keyboard.keys_pressed
|
||||
keyboard.keys_pressed = set()
|
||||
|
||||
for ikey in key.meta.seq:
|
||||
if not getattr(ikey, 'no_press', None):
|
||||
state._process_key(ikey, True)
|
||||
state._send_hid()
|
||||
keyboard.process_key(ikey, True)
|
||||
keyboard._send_hid()
|
||||
if not getattr(ikey, 'no_release', None):
|
||||
state._process_key(ikey, False)
|
||||
state._send_hid()
|
||||
keyboard.process_key(ikey, False)
|
||||
keyboard._send_hid()
|
||||
|
||||
state._keys_pressed = old_keys_pressed
|
||||
keyboard.keys_pressed = oldkeys_pressed
|
||||
|
||||
return state
|
||||
return keyboard
|
||||
|
||||
|
||||
def simple_key_sequence(seq):
|
||||
@@ -59,10 +61,23 @@ RALT_UP_NO_PRESS = simple_key_sequence((KC.RALT(no_press=True),))
|
||||
|
||||
|
||||
def compile_unicode_string_sequences(string_table):
|
||||
for k, v in string_table.items():
|
||||
string_table[k] = unicode_string_sequence(v)
|
||||
'''
|
||||
Destructively convert ("compile") unicode strings into key sequences. This
|
||||
will, for RAM saving reasons, empty the input dictionary and trigger
|
||||
garbage collection.
|
||||
'''
|
||||
target = AttrDict()
|
||||
|
||||
return AttrDict(string_table)
|
||||
for k, v in string_table.items():
|
||||
target[k] = unicode_string_sequence(v)
|
||||
|
||||
# now loop through and kill the input dictionary to save RAM
|
||||
for k in target.keys():
|
||||
del string_table[k]
|
||||
|
||||
gc.collect()
|
||||
|
||||
return target
|
||||
|
||||
|
||||
def unicode_string_sequence(unistring):
|
||||
@@ -82,9 +97,6 @@ def generate_codepoint_keysym_seq(codepoint, expected_length=4):
|
||||
# Not sure how to send emojis on Mac/Windows like that,
|
||||
# though, since (for example) the Canadian flag is assembled
|
||||
# from two five-character codepoints, 1f1e8 and 1f1e6
|
||||
#
|
||||
# As a bonus, this function can be pretty useful for
|
||||
# leader dictionary keys as strings.
|
||||
seq = [KC.N0 for _ in range(max(len(codepoint), expected_length))]
|
||||
|
||||
for idx, codepoint_fragment in enumerate(reversed(codepoint)):
|
||||
@@ -93,47 +105,43 @@ def generate_codepoint_keysym_seq(codepoint, expected_length=4):
|
||||
return seq
|
||||
|
||||
|
||||
def generate_leader_dictionary_seq(string):
|
||||
return tuple(generate_codepoint_keysym_seq(string, 1))
|
||||
|
||||
|
||||
def unicode_codepoint_sequence(codepoints):
|
||||
kc_seqs = (generate_codepoint_keysym_seq(codepoint) for codepoint in codepoints)
|
||||
|
||||
kc_macros = [simple_key_sequence(kc_seq) for kc_seq in kc_seqs]
|
||||
|
||||
def _unicode_sequence(key, state, *args, **kwargs):
|
||||
if state.unicode_mode == UnicodeMode.IBUS:
|
||||
state._process_key(
|
||||
simple_key_sequence(_ibus_unicode_sequence(kc_macros, state)), True
|
||||
def _unicode_sequence(key, keyboard, *args, **kwargs):
|
||||
if keyboard.unicode_mode == UnicodeMode.IBUS:
|
||||
keyboard.process_key(
|
||||
simple_key_sequence(_ibus_unicode_sequence(kc_macros, keyboard)), True
|
||||
)
|
||||
elif state.unicode_mode == UnicodeMode.RALT:
|
||||
state._process_key(
|
||||
simple_key_sequence(_ralt_unicode_sequence(kc_macros, state)), True
|
||||
elif keyboard.unicode_mode == UnicodeMode.RALT:
|
||||
keyboard.process_key(
|
||||
simple_key_sequence(_ralt_unicode_sequence(kc_macros, keyboard)), True
|
||||
)
|
||||
elif state.unicode_mode == UnicodeMode.WINC:
|
||||
state._process_key(
|
||||
simple_key_sequence(_winc_unicode_sequence(kc_macros, state)), True
|
||||
elif keyboard.unicode_mode == UnicodeMode.WINC:
|
||||
keyboard.process_key(
|
||||
simple_key_sequence(_winc_unicode_sequence(kc_macros, keyboard)), True
|
||||
)
|
||||
|
||||
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:
|
||||
yield RALT_DOWN_NO_RELEASE
|
||||
yield kc_macro
|
||||
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:
|
||||
yield IBUS_KEY_COMBO
|
||||
yield kc_macro
|
||||
yield ENTER_KEY
|
||||
|
||||
|
||||
def _winc_unicode_sequence(kc_macros, state):
|
||||
def _winc_unicode_sequence(kc_macros, keyboard):
|
||||
'''
|
||||
Send unicode sequence using WinCompose:
|
||||
|
||||
|
||||
@@ -1,213 +1,129 @@
|
||||
from kmk.kmktime import sleep_ms
|
||||
|
||||
|
||||
def passthrough(key, state, *args, **kwargs):
|
||||
return state
|
||||
def passthrough(key, keyboard, *args, **kwargs):
|
||||
return keyboard
|
||||
|
||||
|
||||
def default_pressed(key, state, KC, coord_int=None, coord_raw=None):
|
||||
state._hid_pending = True
|
||||
def default_pressed(key, keyboard, KC, coord_int=None, coord_raw=None, *args, **kwargs):
|
||||
keyboard.hid_pending = True
|
||||
|
||||
if coord_int is not None:
|
||||
state._coord_keys_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):
|
||||
state._hid_pending = True
|
||||
state._keys_pressed.discard(key)
|
||||
def default_released(
|
||||
key, keyboard, KC, coord_int=None, coord_raw=None, *args, **kwargs # NOQA
|
||||
):
|
||||
keyboard.hid_pending = True
|
||||
keyboard.keys_pressed.discard(key)
|
||||
|
||||
if coord_int is not None:
|
||||
state._keys_pressed.discard(state._coord_keys_pressed.get(coord_int, None))
|
||||
state._coord_keys_pressed[coord_int] = None
|
||||
keyboard.keys_pressed.discard(keyboard._coordkeys_pressed.get(coord_int, None))
|
||||
keyboard._coordkeys_pressed[coord_int] = None
|
||||
|
||||
return state
|
||||
return keyboard
|
||||
|
||||
|
||||
def reset(*args, **kwargs):
|
||||
try:
|
||||
import machine
|
||||
import microcontroller
|
||||
|
||||
machine.reset()
|
||||
|
||||
except ImportError:
|
||||
import microcontroller
|
||||
|
||||
microcontroller.reset()
|
||||
microcontroller.reset()
|
||||
|
||||
|
||||
def bootloader(*args, **kwargs):
|
||||
try:
|
||||
import machine
|
||||
import microcontroller
|
||||
|
||||
machine.bootloader()
|
||||
|
||||
except ImportError:
|
||||
import microcontroller
|
||||
|
||||
microcontroller.on_next_reset(microcontroller.RunMode.BOOTLOADER)
|
||||
microcontroller.reset()
|
||||
microcontroller.on_next_reset(microcontroller.RunMode.BOOTLOADER)
|
||||
microcontroller.reset()
|
||||
|
||||
|
||||
def debug_pressed(key, state, KC, *args, **kwargs):
|
||||
if state.debug_enabled:
|
||||
def debug_pressed(key, keyboard, KC, *args, **kwargs):
|
||||
if keyboard.debug_enabled:
|
||||
print('DebugDisable()')
|
||||
else:
|
||||
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}
|
||||
|
||||
if GESC_TRIGGERS.intersection(state._keys_pressed):
|
||||
if GESC_TRIGGERS.intersection(keyboard.keys_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
|
||||
state._keys_pressed.add(KC.GRAVE)
|
||||
state._hid_pending = True
|
||||
return state
|
||||
keyboard.keys_pressed.add(KC.GRAVE)
|
||||
keyboard.hid_pending = True
|
||||
return keyboard
|
||||
|
||||
# else return KC_ESC
|
||||
state._keys_pressed.add(KC.ESCAPE)
|
||||
state._hid_pending = True
|
||||
keyboard.keys_pressed.add(KC.ESCAPE)
|
||||
keyboard.hid_pending = True
|
||||
|
||||
return state
|
||||
return keyboard
|
||||
|
||||
|
||||
def gesc_released(key, state, KC, *args, **kwargs):
|
||||
state._keys_pressed.discard(KC.ESCAPE)
|
||||
state._keys_pressed.discard(KC.GRAVE)
|
||||
state._hid_pending = True
|
||||
return state
|
||||
def gesc_released(key, keyboard, KC, *args, **kwargs):
|
||||
keyboard.keys_pressed.discard(KC.ESCAPE)
|
||||
keyboard.keys_pressed.discard(KC.GRAVE)
|
||||
keyboard.hid_pending = True
|
||||
return keyboard
|
||||
|
||||
|
||||
def bkdl_pressed(key, state, KC, *args, **kwargs):
|
||||
def bkdl_pressed(key, keyboard, KC, *args, **kwargs):
|
||||
BKDL_TRIGGERS = {KC.LGUI, KC.RGUI}
|
||||
|
||||
if BKDL_TRIGGERS.intersection(state._keys_pressed):
|
||||
state._send_hid()
|
||||
state._keys_pressed.add(KC.DEL)
|
||||
state._hid_pending = True
|
||||
return state
|
||||
if BKDL_TRIGGERS.intersection(keyboard.keys_pressed):
|
||||
keyboard._send_hid()
|
||||
keyboard.keys_pressed.add(KC.DEL)
|
||||
keyboard.hid_pending = True
|
||||
return keyboard
|
||||
|
||||
# else return KC_ESC
|
||||
state._keys_pressed.add(KC.BKSP)
|
||||
state._hid_pending = True
|
||||
keyboard.keys_pressed.add(KC.BKSP)
|
||||
keyboard.hid_pending = True
|
||||
|
||||
return state
|
||||
return keyboard
|
||||
|
||||
|
||||
def bkdl_released(key, state, KC, *args, **kwargs):
|
||||
state._keys_pressed.discard(KC.BKSP)
|
||||
state._keys_pressed.discard(KC.DEL)
|
||||
state._hid_pending = True
|
||||
return state
|
||||
def bkdl_released(key, keyboard, KC, *args, **kwargs):
|
||||
keyboard.keys_pressed.discard(KC.BKSP)
|
||||
keyboard.keys_pressed.discard(KC.DEL)
|
||||
keyboard.hid_pending = True
|
||||
return keyboard
|
||||
|
||||
|
||||
def sleep_pressed(key, state, KC, *args, **kwargs):
|
||||
def sleep_pressed(key, keyboard, KC, *args, **kwargs):
|
||||
sleep_ms(key.meta.ms)
|
||||
return state
|
||||
return keyboard
|
||||
|
||||
|
||||
def uc_mode_pressed(key, state, *args, **kwargs):
|
||||
state.unicode_mode = key.meta.mode
|
||||
def uc_mode_pressed(key, keyboard, *args, **kwargs):
|
||||
keyboard.unicode_mode = key.meta.mode
|
||||
|
||||
return state
|
||||
return keyboard
|
||||
|
||||
|
||||
def td_pressed(key, state, *args, **kwargs):
|
||||
return state._process_tap_dance(key, True)
|
||||
def td_pressed(key, keyboard, *args, **kwargs):
|
||||
return keyboard._process_tap_dance(key, True)
|
||||
|
||||
|
||||
def td_released(key, state, *args, **kwargs):
|
||||
return state._process_tap_dance(key, False)
|
||||
def td_released(key, keyboard, *args, **kwargs):
|
||||
return keyboard._process_tap_dance(key, False)
|
||||
|
||||
|
||||
def rgb_tog(key, state, *args, **kwargs):
|
||||
if state.pixels.animation_mode == 'static_standby':
|
||||
state.pixels.animation_mode = 'static'
|
||||
state.pixels.enabled = not state.pixels.enabled
|
||||
return state
|
||||
|
||||
|
||||
def rgb_hui(key, state, *args, **kwargs):
|
||||
state.pixels.increase_hue()
|
||||
return state
|
||||
|
||||
|
||||
def rgb_hud(key, state, *args, **kwargs):
|
||||
state.pixels.decrease_hue()
|
||||
return state
|
||||
|
||||
|
||||
def rgb_sai(key, state, *args, **kwargs):
|
||||
state.pixels.increase_sat()
|
||||
return state
|
||||
|
||||
|
||||
def rgb_sad(key, state, *args, **kwargs):
|
||||
state.pixels.decrease_sat()
|
||||
return state
|
||||
|
||||
|
||||
def rgb_vai(key, state, *args, **kwargs):
|
||||
state.pixels.increase_val()
|
||||
return state
|
||||
|
||||
|
||||
def rgb_vad(key, state, *args, **kwargs):
|
||||
state.pixels.decrease_val()
|
||||
return state
|
||||
|
||||
|
||||
def rgb_ani(key, state, *args, **kwargs):
|
||||
state.pixels.increase_ani()
|
||||
return state
|
||||
|
||||
|
||||
def rgb_and(key, state, *args, **kwargs):
|
||||
state.pixels.decrease_ani()
|
||||
return state
|
||||
|
||||
|
||||
def rgb_mode_static(key, state, *args, **kwargs):
|
||||
state.pixels.effect_init = True
|
||||
state.pixels.animation_mode = 'static'
|
||||
return state
|
||||
|
||||
|
||||
def rgb_mode_breathe(key, state, *args, **kwargs):
|
||||
state.pixels.effect_init = True
|
||||
state.pixels.animation_mode = 'breathing'
|
||||
return state
|
||||
|
||||
|
||||
def rgb_mode_breathe_rainbow(key, state, *args, **kwargs):
|
||||
state.pixels.effect_init = True
|
||||
state.pixels.animation_mode = 'breathing_rainbow'
|
||||
return state
|
||||
|
||||
|
||||
def rgb_mode_rainbow(key, state, *args, **kwargs):
|
||||
state.pixels.effect_init = True
|
||||
state.pixels.animation_mode = 'rainbow'
|
||||
return state
|
||||
|
||||
|
||||
def rgb_mode_swirl(key, state, *args, **kwargs):
|
||||
state.pixels.effect_init = True
|
||||
state.pixels.animation_mode = 'swirl'
|
||||
return state
|
||||
|
||||
|
||||
def rgb_mode_knight(key, state, *args, **kwargs):
|
||||
state.pixels.effect_init = True
|
||||
state.pixels.animation_mode = 'knight'
|
||||
return state
|
||||
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
|
||||
|
||||
Reference in New Issue
Block a user