Normalise Unicode keycodes (#18898)

* `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

5 files changed, 74 insertions, 64 deletions

diff --git a/quantum/process_keycode/process_unicode_common.c b/quantum/process_keycode/process_unicode_common.c
index bd5fc560f3..a0b9010027 100644
--- a/quantum/process_keycode/process_unicode_common.c
+++ b/quantum/process_keycode/process_unicode_common.c
@@ -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;
         }
     }
diff --git a/quantum/quantum_keycodes.h b/quantum/quantum_keycodes.h
index 6c9a262484..2f9e211cc1 100644
--- a/quantum/quantum_keycodes.h
+++ b/quantum/quantum_keycodes.h
@@ -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
diff --git a/quantum/quantum_keycodes_legacy.h b/quantum/quantum_keycodes_legacy.h
index 3baf37d378..68771baece 100644
--- a/quantum/quantum_keycodes_legacy.h
+++ b/quantum/quantum_keycodes_legacy.h
@@ -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
diff --git a/quantum/unicode/unicode.c b/quantum/unicode/unicode.c
index e2bfd68a3a..35cb62e700 100644
--- a/quantum/unicode/unicode.c
+++ b/quantum/unicode/unicode.c
@@ -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;
diff --git a/quantum/unicode/unicode.h b/quantum/unicode/unicode.h
index b3e43799ff..6f1e35d554 100644
--- a/quantum/unicode/unicode.h
+++ b/quantum/unicode/unicode.h
@@ -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);