drashna/qmk_firmware
1
0
Fork 0
Code Activity Actions

Normalise Unicode keycodes (#18898)

Browse source 
* `UC_MOD`/`UC_RMOD` -> `UC_NEXT`/`UC_PREV`

* `UNICODE_MODE_*` -> `QK_UNICODE_MODE_*`

* `UC_MAC` -> `UNICODE_MODE_MACOS`

* `UC_LNX` -> `UNICODE_MODE_LINUX`

* `UC_WIN` -> `UNICODE_MODE_WINDOWS`

* `UC_BSD` -> `UNICODE_MODE_BSD`

* `UC_WINC` -> `UNICODE_MODE_WINCOMPOSE`

* `UC_EMACS` -> `UNICODE_MODE_EMACS`

* `UC__COUNT` -> `UNICODE_MODE_COUNT`

* `UC_M_MA` -> `UC_MAC`

* `UC_M_LN` -> `UC_LINX`

* `UC_M_WI` -> `UC_WIN`

* `UC_M_BS` -> `UC_BSD`

* `UC_M_WC` -> `UC_WINC`

* `UC_M_EM` -> `UC_EMAC`

* Docs

* Update quantum/unicode/unicode.h
This commit is contained in:
Ryan 2022-11-01 08:15:12 +11:00 • committed by GitHub
parent 743524df32
commit 5974d989fe
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
132 changed files with 303 additions and 292 deletions
Download patch file Download diff file Expand all files Collapse all files

28
quantum/process_keycode/process_unicode_common.c
View file

@ -31,29 +31,29 @@ bool process_unicode_common(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) {
bool shifted = get_mods() & MOD_MASK_SHIFT;
switch (keycode) {
case UNICODE_MODE_FORWARD:
case QK_UNICODE_MODE_NEXT:
cycle_unicode_input_mode(shifted ? -1 : +1);
break;
case UNICODE_MODE_REVERSE:
case QK_UNICODE_MODE_PREVIOUS:
cycle_unicode_input_mode(shifted ? +1 : -1);
break;
case UNICODE_MODE_MAC:
set_unicode_input_mode(UC_MAC);
case QK_UNICODE_MODE_MACOS:
set_unicode_input_mode(UNICODE_MODE_MACOS);
break;
case UNICODE_MODE_LNX:
set_unicode_input_mode(UC_LNX);
case QK_UNICODE_MODE_LINUX:
set_unicode_input_mode(UNICODE_MODE_LINUX);
break;
case UNICODE_MODE_WIN:
set_unicode_input_mode(UC_WIN);
case QK_UNICODE_MODE_WINDOWS:
set_unicode_input_mode(UNICODE_MODE_WINDOWS);
break;
case UNICODE_MODE_BSD:
set_unicode_input_mode(UC_BSD);
case QK_UNICODE_MODE_BSD:
set_unicode_input_mode(UNICODE_MODE_BSD);
break;
case UNICODE_MODE_WINC:
set_unicode_input_mode(UC_WINC);
case QK_UNICODE_MODE_WINCOMPOSE:
set_unicode_input_mode(UNICODE_MODE_WINCOMPOSE);
break;
case UNICODE_MODE_EMACS:
set_unicode_input_mode(UC_EMACS);
case QK_UNICODE_MODE_EMACS:
set_unicode_input_mode(UNICODE_MODE_EMACS);
break;
}
}

32
quantum/quantum_keycodes.h
View file

@ -378,13 +378,13 @@ enum quantum_keycodes {
QK_CLEAR_EEPROM, // 5CDF
// Unicode
UNICODE_MODE_FORWARD, // 5CE0
UNICODE_MODE_REVERSE, // 5CE1
UNICODE_MODE_MAC, // 5CE2
UNICODE_MODE_LNX, // 5CE3
UNICODE_MODE_WIN, // 5CE4
UNICODE_MODE_BSD, // 5CE5
UNICODE_MODE_WINC, // 5CE6
QK_UNICODE_MODE_NEXT, // 5CE0
QK_UNICODE_MODE_PREVIOUS, // 5CE1
QK_UNICODE_MODE_MACOS, // 5CE2
QK_UNICODE_MODE_LINUX, // 5CE3
QK_UNICODE_MODE_WINDOWS, // 5CE4
QK_UNICODE_MODE_BSD, // 5CE5
QK_UNICODE_MODE_WINCOMPOSE, // 5CE6
// Haptic
HPT_ON, // 5CE7
@ -609,7 +609,7 @@ enum quantum_keycodes {
MAGIC_UNSWAP_ESCAPE_CAPSLOCK,
MAGIC_TOGGLE_ESCAPE_CAPSLOCK,
UNICODE_MODE_EMACS,
QK_UNICODE_MODE_EMACS,
QK_AUTOCORRECT_ON,
QK_AUTOCORRECT_OFF,
@ -834,15 +834,15 @@ enum quantum_keycodes {
#define X(i) (QK_UNICODEMAP | (i))
#define XP(i, j) (QK_UNICODEMAP_PAIR | ((i)&0x7F) | (((j)&0x7F) << 7)) // 127 max i and j
#define UC_MOD UNICODE_MODE_FORWARD
#define UC_RMOD UNICODE_MODE_REVERSE
#define UC_NEXT QK_UNICODE_MODE_NEXT
#define UC_PREV QK_UNICODE_MODE_PREVIOUS
#define UC_M_MA UNICODE_MODE_MAC
#define UC_M_LN UNICODE_MODE_LNX
#define UC_M_WI UNICODE_MODE_WIN
#define UC_M_BS UNICODE_MODE_BSD
#define UC_M_WC UNICODE_MODE_WINC
#define UC_M_EM UNICODE_MODE_EMACS
#define UC_MAC QK_UNICODE_MODE_MACOS
#define UC_LINX QK_UNICODE_MODE_LINUX
#define UC_WIN QK_UNICODE_MODE_WINDOWS
#define UC_BSD QK_UNICODE_MODE_BSD
#define UC_WINC QK_UNICODE_MODE_WINCOMPOSE
#define UC_EMAC QK_UNICODE_MODE_EMACS
// Auto Shift
#define AS_UP QK_AUTO_SHIFT_UP

9
quantum/quantum_keycodes_legacy.h
View file

@ -29,6 +29,15 @@
#define CMB_OFF QK_COMBO_OFF
#define CMB_TOG QK_COMBO_TOGGLE
#define UC_MOD QK_UNICODE_MODE_NEXT
#define UC_RMOD QK_UNICODE_MODE_PREVIOUS
#define UC_M_MA QK_UNICODE_MODE_MACOS
#define UC_M_LN QK_UNICODE_MODE_LINUX
#define UC_M_WI QK_UNICODE_MODE_WINDOWS
#define UC_M_BS QK_UNICODE_MODE_BSD
#define UC_M_WC QK_UNICODE_MODE_WINCOMPOSE
#define UC_M_EM QK_UNICODE_MODE_EMACS
#define PROGRAMMABLE_BUTTON_1 QK_PROGRAMMABLE_BUTTON_1
#define PROGRAMMABLE_BUTTON_2 QK_PROGRAMMABLE_BUTTON_2
#define PROGRAMMABLE_BUTTON_3 QK_PROGRAMMABLE_BUTTON_3

54
quantum/unicode/unicode.c
View file

@ -46,7 +46,7 @@
#endif
// Comma-delimited, ordered list of input modes selected for use (e.g. in cycle)
// Example: #define UNICODE_SELECTED_MODES UC_WINC, UC_LNX
// Example: #define UNICODE_SELECTED_MODES UNICODE_MODE_WINCOMPOSE, UNICODE_MODE_LINUX
#ifndef UNICODE_SELECTED_MODES
# define UNICODE_SELECTED_MODES -1
#endif
@ -108,32 +108,32 @@ static float song_emacs[][2] = UNICODE_SONG_EMACS;
static void unicode_play_song(uint8_t mode) {
switch (mode) {
# ifdef UNICODE_SONG_MAC
case UC_MAC:
case UNICODE_MODE_MACOS:
PLAY_SONG(song_mac);
break;
# endif
# ifdef UNICODE_SONG_LNX
case UC_LNX:
case UNICODE_MODE_LINUX:
PLAY_SONG(song_lnx);
break;
# endif
# ifdef UNICODE_SONG_WIN
case UC_WIN:
case UNICODE_MODE_WINDOWS:
PLAY_SONG(song_win);
break;
# endif
# ifdef UNICODE_SONG_BSD
case UC_BSD:
case UNICODE_MODE_BSD:
PLAY_SONG(song_bsd);
break;
# endif
# ifdef UNICODE_SONG_WINC
case UC_WINC:
case UNICODE_MODE_WINCOMPOSE:
PLAY_SONG(song_winc);
break;
# endif
# ifdef UNICODE_SONG_EMACS
case UC_EMACS:
case UNICODE_MODE_EMACS:
PLAY_SONG(song_emacs);
break;
# endif
@ -209,7 +209,7 @@ __attribute__((weak)) void unicode_input_start(void) {
// Need to do this before we mess around with the mods, or else
// UNICODE_KEY_LNX (which is usually Ctrl-Shift-U) might not work
// correctly in the shifted case.
if (unicode_config.input_mode == UC_LNX && unicode_saved_led_state.caps_lock) {
if (unicode_config.input_mode == UNICODE_MODE_LINUX && unicode_saved_led_state.caps_lock) {
tap_code(KC_CAPS_LOCK);
}
@ -218,13 +218,13 @@ __attribute__((weak)) void unicode_input_start(void) {
clear_weak_mods();
switch (unicode_config.input_mode) {
case UC_MAC:
case UNICODE_MODE_MACOS:
register_code(UNICODE_KEY_MAC);
break;
case UC_LNX:
case UNICODE_MODE_LINUX:
tap_code16(UNICODE_KEY_LNX);
break;
case UC_WIN:
case UNICODE_MODE_WINDOWS:
// For increased reliability, use numpad keys for inputting digits
if (!unicode_saved_led_state.num_lock) {
tap_code(KC_NUM_LOCK);
@ -233,11 +233,11 @@ __attribute__((weak)) void unicode_input_start(void) {
wait_ms(UNICODE_TYPE_DELAY);
tap_code(KC_KP_PLUS);
break;
case UC_WINC:
case UNICODE_MODE_WINCOMPOSE:
tap_code(UNICODE_KEY_WINC);
tap_code(KC_U);
break;
case UC_EMACS:
case UNICODE_MODE_EMACS:
// The usual way to type unicode in emacs is C-x-8 <RET> then the unicode number in hex
tap_code16(LCTL(KC_X));
tap_code16(KC_8);
@ -250,25 +250,25 @@ __attribute__((weak)) void unicode_input_start(void) {
__attribute__((weak)) void unicode_input_finish(void) {
switch (unicode_config.input_mode) {
case UC_MAC:
case UNICODE_MODE_MACOS:
unregister_code(UNICODE_KEY_MAC);
break;
case UC_LNX:
case UNICODE_MODE_LINUX:
tap_code(KC_SPACE);
if (unicode_saved_led_state.caps_lock) {
tap_code(KC_CAPS_LOCK);
}
break;
case UC_WIN:
case UNICODE_MODE_WINDOWS:
unregister_code(KC_LEFT_ALT);
if (!unicode_saved_led_state.num_lock) {
tap_code(KC_NUM_LOCK);
}
break;
case UC_WINC:
case UNICODE_MODE_WINCOMPOSE:
tap_code(KC_ENTER);
break;
case UC_EMACS:
case UNICODE_MODE_EMACS:
tap_code16(KC_ENTER);
break;
}
@ -278,25 +278,25 @@ __attribute__((weak)) void unicode_input_finish(void) {
__attribute__((weak)) void unicode_input_cancel(void) {
switch (unicode_config.input_mode) {
case UC_MAC:
case UNICODE_MODE_MACOS:
unregister_code(UNICODE_KEY_MAC);
break;
case UC_LNX:
case UNICODE_MODE_LINUX:
tap_code(KC_ESCAPE);
if (unicode_saved_led_state.caps_lock) {
tap_code(KC_CAPS_LOCK);
}
break;
case UC_WINC:
case UNICODE_MODE_WINCOMPOSE:
tap_code(KC_ESCAPE);
break;
case UC_WIN:
case UNICODE_MODE_WINDOWS:
unregister_code(KC_LEFT_ALT);
if (!unicode_saved_led_state.num_lock) {
tap_code(KC_NUM_LOCK);
}
break;
case UC_EMACS:
case UNICODE_MODE_EMACS:
tap_code16(LCTL(KC_G)); // C-g cancels
break;
}
@ -307,7 +307,7 @@ __attribute__((weak)) void unicode_input_cancel(void) {
// clang-format off
static void send_nibble_wrapper(uint8_t digit) {
if (unicode_config.input_mode == UC_WIN) {
if (unicode_config.input_mode == UNICODE_MODE_WINDOWS) {
uint8_t kc = digit < 10
? KC_KP_1 + (10 + digit - 1) % 10
: KC_A + (digit - 10);
@ -328,7 +328,7 @@ void register_hex(uint16_t hex) {
void register_hex32(uint32_t hex) {
bool first_digit = true;
bool needs_leading_zero = (unicode_config.input_mode == UC_WINC);
bool needs_leading_zero = (unicode_config.input_mode == UNICODE_MODE_WINCOMPOSE);
for (int i = 7; i >= 0; i--) {
// Work out the digit we're going to transmit
uint8_t digit = ((hex >> (i * 4)) & 0xF);
@ -352,13 +352,13 @@ void register_hex32(uint32_t hex) {
}
void register_unicode(uint32_t code_point) {
if (code_point > 0x10FFFF || (code_point > 0xFFFF && unicode_config.input_mode == UC_WIN)) {
if (code_point > 0x10FFFF || (code_point > 0xFFFF && unicode_config.input_mode == UNICODE_MODE_WINDOWS)) {
// Code point out of range, do nothing
return;
}
unicode_input_start();
if (code_point > 0xFFFF && unicode_config.input_mode == UC_MAC) {
if (code_point > 0xFFFF && unicode_config.input_mode == UNICODE_MODE_MACOS) {
// Convert code point to UTF-16 surrogate pair on macOS
code_point -= 0x10000;
uint32_t lo = code_point & 0x3FF, hi = (code_point & 0xFFC00) >> 10;

15
quantum/unicode/unicode.h
View file

@ -30,13 +30,14 @@ typedef union {
extern unicode_config_t unicode_config;
enum unicode_input_modes {
UC_MAC, // macOS using Unicode Hex Input
UC_LNX, // Linux using IBus
UC_WIN, // Windows using EnableHexNumpad
UC_BSD, // BSD (not implemented)
UC_WINC, // Windows using WinCompose (https://github.com/samhocevar/wincompose)
UC_EMACS, // Emacs is an operating system in search of a good text editor
UC__COUNT // Number of available input modes (always leave at the end)
UNICODE_MODE_MACOS, // macOS using Unicode Hex Input
UNICODE_MODE_LINUX, // Linux using IBus
UNICODE_MODE_WINDOWS, // Windows using EnableHexNumpad
UNICODE_MODE_BSD, // BSD (not implemented)
UNICODE_MODE_WINCOMPOSE, // Windows using WinCompose (https://github.com/samhocevar/wincompose)
UNICODE_MODE_EMACS, // Emacs is an operating system in search of a good text editor
UNICODE_MODE_COUNT // Number of available input modes (always leave at the end)
};
void unicode_input_mode_init(void);