7b92596937
WinCompose requires the `enter` key to be typed at the end of a special unicode character. In order to help print emojis and emoticons in a windows environment, I have added the enter key to the Windows compose unicode sequence method. I have tested this with my local keyboard.
156 lines
4.5 KiB
Python
156 lines
4.5 KiB
Python
import gc
|
|
|
|
from kmk.consts import UnicodeMode
|
|
from kmk.handlers.stock import passthrough
|
|
from kmk.keys import KC, make_key
|
|
from kmk.types import AttrDict, KeySequenceMeta
|
|
|
|
|
|
def get_wide_ordinal(char):
|
|
if len(char) != 2:
|
|
return ord(char)
|
|
|
|
return 0x10000 + (ord(char[0]) - 0xD800) * 0x400 + (ord(char[1]) - 0xDC00)
|
|
|
|
|
|
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):
|
|
keyboard.process_key(ikey, True)
|
|
keyboard._send_hid()
|
|
if not getattr(ikey, 'no_release', None):
|
|
keyboard.process_key(ikey, False)
|
|
keyboard._send_hid()
|
|
|
|
keyboard.keys_pressed = oldkeys_pressed
|
|
|
|
return keyboard
|
|
|
|
|
|
def simple_key_sequence(seq):
|
|
return make_key(
|
|
meta=KeySequenceMeta(seq),
|
|
on_press=sequence_press_handler,
|
|
on_release=passthrough,
|
|
)
|
|
|
|
|
|
def send_string(message):
|
|
seq = []
|
|
|
|
for char in message:
|
|
kc = getattr(KC, char.upper())
|
|
|
|
if char.isupper():
|
|
kc = KC.LSHIFT(kc)
|
|
|
|
seq.append(kc)
|
|
|
|
return simple_key_sequence(seq)
|
|
|
|
|
|
IBUS_KEY_COMBO = simple_key_sequence((KC.LCTRL(KC.LSHIFT(KC.U)),))
|
|
RALT_KEY = simple_key_sequence((KC.RALT,))
|
|
U_KEY = simple_key_sequence((KC.U,))
|
|
ENTER_KEY = simple_key_sequence((KC.ENTER,))
|
|
RALT_DOWN_NO_RELEASE = simple_key_sequence((KC.RALT(no_release=True),))
|
|
RALT_UP_NO_PRESS = simple_key_sequence((KC.RALT(no_press=True),))
|
|
|
|
|
|
def compile_unicode_string_sequences(string_table):
|
|
'''
|
|
Destructively convert ("compile") unicode strings into key sequences. This
|
|
will, for RAM saving reasons, empty the input dictionary and trigger
|
|
garbage collection.
|
|
'''
|
|
target = AttrDict()
|
|
|
|
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):
|
|
'''
|
|
Allows sending things like (╯°□°）╯︵ ┻━┻ directly, without
|
|
manual conversion to Unicode codepoints.
|
|
'''
|
|
return unicode_codepoint_sequence([hex(get_wide_ordinal(s))[2:] for s in unistring])
|
|
|
|
|
|
def generate_codepoint_keysym_seq(codepoint, expected_length=4):
|
|
# To make MacOS and Windows happy, always try to send
|
|
# sequences that are of length 4 at a minimum
|
|
# On Linux systems, we can happily send longer strings.
|
|
# They will almost certainly break on MacOS and Windows,
|
|
# but this is a documentation problem more than anything.
|
|
# 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
|
|
seq = [KC.N0 for _ in range(max(len(codepoint), expected_length))]
|
|
|
|
for idx, codepoint_fragment in enumerate(reversed(codepoint)):
|
|
seq[-(idx + 1)] = KC.__getattr__(codepoint_fragment.upper())
|
|
|
|
return seq
|
|
|
|
|
|
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, keyboard, *args, **kwargs):
|
|
if keyboard.unicode_mode == UnicodeMode.IBUS:
|
|
keyboard.process_key(
|
|
simple_key_sequence(_ibus_unicode_sequence(kc_macros, keyboard)), True
|
|
)
|
|
elif keyboard.unicode_mode == UnicodeMode.RALT:
|
|
keyboard.process_key(
|
|
simple_key_sequence(_ralt_unicode_sequence(kc_macros, keyboard)), 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, 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, keyboard):
|
|
for kc_macro in kc_macros:
|
|
yield IBUS_KEY_COMBO
|
|
yield kc_macro
|
|
yield ENTER_KEY
|
|
|
|
|
|
def _winc_unicode_sequence(kc_macros, keyboard):
|
|
'''
|
|
Send unicode sequence using WinCompose:
|
|
|
|
http://wincompose.info/
|
|
https://github.com/SamHocevar/wincompose
|
|
'''
|
|
for kc_macro in kc_macros:
|
|
yield RALT_KEY
|
|
yield U_KEY
|
|
yield kc_macro
|
|
yield ENTER_KEY
|