184 lines
6.5 KiB
Python
184 lines
6.5 KiB
Python
'''One layer isn't enough. Adds keys to get to more of them'''
|
|
from micropython import const
|
|
|
|
from kmk.key_validators import layer_key_validator
|
|
from kmk.keys import make_argumented_key
|
|
from kmk.modules.holdtap import ActivationType, HoldTap
|
|
|
|
|
|
class LayerType:
|
|
'''Defines layer types to be passed on as on_press and on_release kwargs where needed'''
|
|
|
|
LT = const(0)
|
|
TT = const(1)
|
|
|
|
|
|
def curry(fn, *args, **kwargs):
|
|
def curried(*fn_args, **fn_kwargs):
|
|
merged_args = args + fn_args
|
|
merged_kwargs = kwargs.copy()
|
|
merged_kwargs.update(fn_kwargs)
|
|
return fn(*merged_args, **merged_kwargs)
|
|
|
|
return curried
|
|
|
|
|
|
class Layers(HoldTap):
|
|
'''Gives access to the keys used to enable the layer system'''
|
|
|
|
def __init__(self):
|
|
# Layers
|
|
super().__init__()
|
|
make_argumented_key(
|
|
validator=layer_key_validator,
|
|
names=('MO',),
|
|
on_press=self._mo_pressed,
|
|
on_release=self._mo_released,
|
|
)
|
|
make_argumented_key(
|
|
validator=layer_key_validator, names=('DF',), on_press=self._df_pressed
|
|
)
|
|
make_argumented_key(
|
|
validator=layer_key_validator,
|
|
names=('LM',),
|
|
on_press=self._lm_pressed,
|
|
on_release=self._lm_released,
|
|
)
|
|
make_argumented_key(
|
|
validator=layer_key_validator,
|
|
names=('LT',),
|
|
on_press=curry(self.ht_pressed, key_type=LayerType.LT),
|
|
on_release=curry(self.ht_released, key_type=LayerType.LT),
|
|
)
|
|
make_argumented_key(
|
|
validator=layer_key_validator, names=('TG',), on_press=self._tg_pressed
|
|
)
|
|
make_argumented_key(
|
|
validator=layer_key_validator, names=('TO',), on_press=self._to_pressed
|
|
)
|
|
make_argumented_key(
|
|
validator=curry(layer_key_validator, prefer_hold=True),
|
|
names=('TT',),
|
|
on_press=curry(self.ht_pressed, key_type=LayerType.TT),
|
|
on_release=curry(self.ht_released, key_type=LayerType.TT),
|
|
)
|
|
|
|
def process_key(self, keyboard, key, is_pressed, int_coord):
|
|
current_key = super().process_key(keyboard, key, is_pressed, int_coord)
|
|
|
|
for key, state in self.key_states.items():
|
|
if key == current_key:
|
|
continue
|
|
|
|
# on interrupt: key must be translated here, because it was asigned
|
|
# before the layer shift happend.
|
|
if state.activated == ActivationType.INTERRUPTED:
|
|
current_key = keyboard._find_key_in_map(int_coord, None, None)
|
|
|
|
return current_key
|
|
|
|
def send_key_buffer(self, keyboard):
|
|
for (int_coord, old_key) in self.key_buffer:
|
|
new_key = keyboard._find_key_in_map(int_coord, None, None)
|
|
|
|
# adding keys late to _coordkeys_pressed isn't pretty,
|
|
# but necessary to mitigate race conditions when multiple
|
|
# keys are pressed during a tap-interrupted hold-tap.
|
|
keyboard._coordkeys_pressed[int_coord] = new_key
|
|
new_key.on_press(keyboard)
|
|
|
|
keyboard._send_hid()
|
|
|
|
self.key_buffer.clear()
|
|
|
|
def _df_pressed(self, key, keyboard, *args, **kwargs):
|
|
'''
|
|
Switches the default layer
|
|
'''
|
|
keyboard.active_layers[-1] = key.meta.layer
|
|
|
|
def _mo_pressed(self, key, keyboard, *args, **kwargs):
|
|
'''
|
|
Momentarily activates layer, switches off when you let go
|
|
'''
|
|
keyboard.active_layers.insert(0, key.meta.layer)
|
|
|
|
@staticmethod
|
|
def _mo_released(key, keyboard, *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 = keyboard.active_layers.index(key.meta.layer)
|
|
del keyboard.active_layers[del_idx]
|
|
except ValueError:
|
|
pass
|
|
|
|
def _lm_pressed(self, key, keyboard, *args, **kwargs):
|
|
'''
|
|
As MO(layer) but with mod active
|
|
'''
|
|
keyboard.hid_pending = True
|
|
# Sets the timer start and acts like MO otherwise
|
|
keyboard.keys_pressed.add(key.meta.kc)
|
|
self._mo_pressed(key, keyboard, *args, **kwargs)
|
|
|
|
def _lm_released(self, key, keyboard, *args, **kwargs):
|
|
'''
|
|
As MO(layer) but with mod active
|
|
'''
|
|
keyboard.hid_pending = True
|
|
keyboard.keys_pressed.discard(key.meta.kc)
|
|
self._mo_released(key, keyboard, *args, **kwargs)
|
|
|
|
def _tg_pressed(self, key, keyboard, *args, **kwargs):
|
|
'''
|
|
Toggles the layer (enables it if not active, and vise versa)
|
|
'''
|
|
# See mo_released for implementation details around this
|
|
try:
|
|
del_idx = keyboard.active_layers.index(key.meta.layer)
|
|
del keyboard.active_layers[del_idx]
|
|
except ValueError:
|
|
keyboard.active_layers.insert(0, key.meta.layer)
|
|
|
|
def _to_pressed(self, key, keyboard, *args, **kwargs):
|
|
'''
|
|
Activates layer and deactivates all other layers
|
|
'''
|
|
keyboard.active_layers.clear()
|
|
keyboard.active_layers.insert(0, key.meta.layer)
|
|
|
|
def ht_activate_hold(self, key, keyboard, *args, **kwargs):
|
|
key_type = kwargs['key_type']
|
|
if key_type == LayerType.LT:
|
|
self._mo_pressed(key, keyboard, *args, **kwargs)
|
|
elif key_type == LayerType.TT:
|
|
self._tg_pressed(key, keyboard, *args, **kwargs)
|
|
|
|
def ht_deactivate_hold(self, key, keyboard, *args, **kwargs):
|
|
key_type = kwargs['key_type']
|
|
if key_type == LayerType.LT:
|
|
self._mo_released(key, keyboard, *args, **kwargs)
|
|
elif key_type == LayerType.TT:
|
|
self._tg_pressed(key, keyboard, *args, **kwargs)
|
|
|
|
def ht_activate_tap(self, key, keyboard, *args, **kwargs):
|
|
key_type = kwargs['key_type']
|
|
if key_type == LayerType.LT:
|
|
keyboard.hid_pending = True
|
|
keyboard.keys_pressed.add(key.meta.kc)
|
|
elif key_type == LayerType.TT:
|
|
self._tg_pressed(key, keyboard, *args, **kwargs)
|
|
|
|
def ht_deactivate_tap(self, key, keyboard, *args, **kwargs):
|
|
key_type = kwargs['key_type']
|
|
if key_type == LayerType.LT:
|
|
keyboard.hid_pending = True
|
|
keyboard.keys_pressed.discard(key.meta.kc)
|