summaryrefslogtreecommitdiff
path: root/quantum/process_keycode
diff options
context:
space:
mode:
Diffstat (limited to 'quantum/process_keycode')
-rw-r--r--quantum/process_keycode/process_ucis.c2
-rw-r--r--quantum/process_keycode/process_ucis.h5
-rw-r--r--quantum/process_keycode/process_unicode.c2
-rw-r--r--quantum/process_keycode/process_unicode.h5
-rw-r--r--quantum/process_keycode/process_unicode_common.c200
-rw-r--r--quantum/process_keycode/process_unicode_common.h66
-rw-r--r--quantum/process_keycode/process_unicodemap.c5
-rw-r--r--quantum/process_keycode/process_unicodemap.h4
8 files changed, 190 insertions, 99 deletions
diff --git a/quantum/process_keycode/process_ucis.c b/quantum/process_keycode/process_ucis.c
index 8deb24a867..5de2e41fc3 100644
--- a/quantum/process_keycode/process_ucis.c
+++ b/quantum/process_keycode/process_ucis.c
@@ -95,8 +95,6 @@ void register_ucis(const char *hex) {
bool process_ucis (uint16_t keycode, keyrecord_t *record) {
uint8_t i;
- unicode_input_mode_init();
-
if (!qk_ucis_state.in_progress)
return true;
diff --git a/quantum/process_keycode/process_ucis.h b/quantum/process_keycode/process_ucis.h
index d4aa34cde7..b114d839ab 100644
--- a/quantum/process_keycode/process_ucis.h
+++ b/quantum/process_keycode/process_ucis.h
@@ -14,8 +14,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#ifndef PROCESS_UCIS_H
-#define PROCESS_UCIS_H
+#pragma once
#include "quantum.h"
#include "process_unicode_common.h"
@@ -48,5 +47,3 @@ void qk_ucis_symbol_fallback (void);
void qk_ucis_success(uint8_t symbol_index);
void register_ucis(const char *hex);
bool process_ucis (uint16_t keycode, keyrecord_t *record);
-
-#endif
diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index f39c4a36e1..19beb84520 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -20,11 +20,9 @@
bool process_unicode(uint16_t keycode, keyrecord_t *record) {
if (keycode > QK_UNICODE && record->event.pressed) {
uint16_t unicode = keycode & 0x7FFF;
- unicode_input_mode_init();
unicode_input_start();
register_hex(unicode);
unicode_input_finish();
}
return true;
}
-
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index c525b74f03..0913e99107 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -13,12 +13,9 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#ifndef PROCESS_UNICODE_H
-#define PROCESS_UNICODE_H
+#pragma once
#include "quantum.h"
#include "process_unicode_common.h"
bool process_unicode(uint16_t keycode, keyrecord_t *record);
-
-#endif
diff --git a/quantum/process_keycode/process_unicode_common.c b/quantum/process_keycode/process_unicode_common.c
index 4285d20a19..3286f45b5d 100644
--- a/quantum/process_keycode/process_unicode_common.c
+++ b/quantum/process_keycode/process_unicode_common.c
@@ -16,98 +16,111 @@
#include "process_unicode_common.h"
#include "eeprom.h"
-#include <string.h>
#include <ctype.h>
+#include <string.h>
-static uint8_t input_mode;
-uint8_t mods;
+unicode_config_t unicode_config;
+#if UNICODE_SELECTED_MODES != -1
+static uint8_t selected[] = { UNICODE_SELECTED_MODES };
+static uint8_t selected_count = sizeof selected / sizeof *selected;
+static uint8_t selected_index;
+#endif
-void set_unicode_input_mode(uint8_t os_target) {
- input_mode = os_target;
- eeprom_update_byte(EECONFIG_UNICODEMODE, os_target);
+void unicode_input_mode_init(void) {
+ unicode_config.raw = eeprom_read_byte(EECONFIG_UNICODEMODE);
+#if UNICODE_SELECTED_MODES != -1
+ #if UNICODE_CYCLE_PERSIST
+ // Find input_mode in selected modes
+ uint8_t i;
+ for (i = 0; i < selected_count; i++) {
+ if (selected[i] == unicode_config.input_mode) {
+ selected_index = i;
+ break;
+ }
+ }
+ if (i == selected_count) {
+ // Not found: input_mode isn't selected, change to one that is
+ unicode_config.input_mode = selected[selected_index = 0];
+ }
+ #else
+ // Always change to the first selected input mode
+ unicode_config.input_mode = selected[selected_index = 0];
+ #endif
+#endif
+ dprintf("Unicode input mode init to: %u\n", unicode_config.input_mode);
}
uint8_t get_unicode_input_mode(void) {
- return input_mode;
+ return unicode_config.input_mode;
}
-void unicode_input_mode_init(void) {
- static bool first_flag = false;
- if (!first_flag) {
- input_mode = eeprom_read_byte(EECONFIG_UNICODEMODE);
- first_flag = true;
- }
+void set_unicode_input_mode(uint8_t mode) {
+ unicode_config.input_mode = mode;
+ persist_unicode_input_mode();
+ dprintf("Unicode input mode set to: %u\n", unicode_config.input_mode);
+}
+
+void cycle_unicode_input_mode(uint8_t offset) {
+#if UNICODE_SELECTED_MODES != -1
+ selected_index = (selected_index + offset) % selected_count;
+ unicode_config.input_mode = selected[selected_index];
+ #if UNICODE_CYCLE_PERSIST
+ persist_unicode_input_mode();
+ #endif
+ dprintf("Unicode input mode cycle to: %u\n", unicode_config.input_mode);
+#endif
+}
+
+void persist_unicode_input_mode(void) {
+ eeprom_update_byte(EECONFIG_UNICODEMODE, unicode_config.input_mode);
}
+static uint8_t saved_mods;
+
__attribute__((weak))
-void unicode_input_start (void) {
- // save current mods
- mods = keyboard_report->mods;
-
- // unregister all mods to start from clean state
- if (mods & MOD_BIT(KC_LSFT)) unregister_code(KC_LSFT);
- if (mods & MOD_BIT(KC_RSFT)) unregister_code(KC_RSFT);
- if (mods & MOD_BIT(KC_LCTL)) unregister_code(KC_LCTL);
- if (mods & MOD_BIT(KC_RCTL)) unregister_code(KC_RCTL);
- if (mods & MOD_BIT(KC_LALT)) unregister_code(KC_LALT);
- if (mods & MOD_BIT(KC_RALT)) unregister_code(KC_RALT);
- if (mods & MOD_BIT(KC_LGUI)) unregister_code(KC_LGUI);
- if (mods & MOD_BIT(KC_RGUI)) unregister_code(KC_RGUI);
-
- switch(input_mode) {
+void unicode_input_start(void) {
+ saved_mods = get_mods(); // Save current mods
+ clear_mods(); // Unregister mods to start from a clean state
+
+ switch (unicode_config.input_mode) {
case UC_OSX:
- register_code(KC_LALT);
- break;
- case UC_OSX_RALT:
- register_code(KC_RALT);
+ register_code(UNICODE_OSX_KEY);
break;
case UC_LNX:
register_code(KC_LCTL);
register_code(KC_LSFT);
- register_code(KC_U);
- unregister_code(KC_U);
+ tap_code(KC_U); // TODO: Replace with tap_code16(LCTL(LSFT(KC_U))); and test
unregister_code(KC_LSFT);
unregister_code(KC_LCTL);
break;
case UC_WIN:
register_code(KC_LALT);
- register_code(KC_PPLS);
- unregister_code(KC_PPLS);
+ tap_code(KC_PPLS);
break;
case UC_WINC:
- register_code(KC_RALT);
- unregister_code(KC_RALT);
- register_code(KC_U);
- unregister_code(KC_U);
+ tap_code(UNICODE_WINC_KEY);
+ tap_code(KC_U);
+ break;
}
+
wait_ms(UNICODE_TYPE_DELAY);
}
__attribute__((weak))
-void unicode_input_finish (void) {
- switch(input_mode) {
- case UC_OSX:
- case UC_WIN:
- unregister_code(KC_LALT);
- break;
- case UC_OSX_RALT:
- unregister_code(KC_RALT);
- break;
- case UC_LNX:
- register_code(KC_SPC);
- unregister_code(KC_SPC);
- break;
+void unicode_input_finish(void) {
+ switch (unicode_config.input_mode) {
+ case UC_OSX:
+ unregister_code(UNICODE_OSX_KEY);
+ break;
+ case UC_LNX:
+ tap_code(KC_SPC);
+ break;
+ case UC_WIN:
+ unregister_code(KC_LALT);
+ break;
}
- // reregister previously set mods
- if (mods & MOD_BIT(KC_LSFT)) register_code(KC_LSFT);
- if (mods & MOD_BIT(KC_RSFT)) register_code(KC_RSFT);
- if (mods & MOD_BIT(KC_LCTL)) register_code(KC_LCTL);
- if (mods & MOD_BIT(KC_RCTL)) register_code(KC_RCTL);
- if (mods & MOD_BIT(KC_LALT)) register_code(KC_LALT);
- if (mods & MOD_BIT(KC_RALT)) register_code(KC_RALT);
- if (mods & MOD_BIT(KC_LGUI)) register_code(KC_LGUI);
- if (mods & MOD_BIT(KC_RGUI)) register_code(KC_RGUI);
+ set_mods(saved_mods); // Reregister previously set mods
}
__attribute__((weak))
@@ -124,13 +137,12 @@ uint16_t hex_to_keycode(uint8_t hex) {
void register_hex(uint16_t hex) {
for(int i = 3; i >= 0; i--) {
uint8_t digit = ((hex >> (i*4)) & 0xF);
- register_code(hex_to_keycode(digit));
- unregister_code(hex_to_keycode(digit));
+ tap_code(hex_to_keycode(digit));
}
}
void send_unicode_hex_string(const char *str) {
- if (!str) { return; } // Safety net
+ if (!str) { return; }
while (*str) {
// Find the next code point (token) in the string
@@ -153,3 +165,61 @@ void send_unicode_hex_string(const char *str) {
str += n; // Move to the first ' ' (or '\0') after the current token
}
}
+
+bool process_unicode_common(uint16_t keycode, keyrecord_t *record) {
+ if (record->event.pressed) {
+ switch (keycode) {
+ case UNICODE_MODE_FORWARD:
+ cycle_unicode_input_mode(+1);
+ break;
+ case UNICODE_MODE_REVERSE:
+ cycle_unicode_input_mode(-1);
+ break;
+
+ case UNICODE_MODE_OSX:
+ set_unicode_input_mode(UC_OSX);
+#if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_OSX)
+ static float song_osx[][2] = UNICODE_SONG_OSX;
+ PLAY_SONG(song_osx);
+#endif
+ break;
+ case UNICODE_MODE_LNX:
+ set_unicode_input_mode(UC_LNX);
+#if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_LNX)
+ static float song_lnx[][2] = UNICODE_SONG_LNX;
+ PLAY_SONG(song_lnx);
+#endif
+ break;
+ case UNICODE_MODE_WIN:
+ set_unicode_input_mode(UC_WIN);
+#if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_WIN)
+ static float song_win[][2] = UNICODE_SONG_WIN;
+ PLAY_SONG(song_win);
+#endif
+ break;
+ case UNICODE_MODE_BSD:
+ set_unicode_input_mode(UC_BSD);
+#if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_BSD)
+ static float song_bsd[][2] = UNICODE_SONG_BSD;
+ PLAY_SONG(song_bsd);
+#endif
+ break;
+ case UNICODE_MODE_WINC:
+ set_unicode_input_mode(UC_WINC);
+#if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_WINC)
+ static float song_winc[][2] = UNICODE_SONG_WINC;
+ PLAY_SONG(song_winc);
+#endif
+ break;
+ }
+ }
+#if defined(UNICODE_ENABLE)
+ return process_unicode(keycode, record);
+#elif defined(UNICODEMAP_ENABLE)
+ return process_unicode_map(keycode, record);
+#elif defined(UCIS_ENABLE)
+ return process_ucis(keycode, record);
+#else
+ return true;
+#endif
+}
diff --git a/quantum/process_keycode/process_unicode_common.h b/quantum/process_keycode/process_unicode_common.h
index e78e1cec6c..e608ab76be 100644
--- a/quantum/process_keycode/process_unicode_common.h
+++ b/quantum/process_keycode/process_unicode_common.h
@@ -14,35 +14,71 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#ifndef PROCESS_UNICODE_COMMON_H
-#define PROCESS_UNICODE_COMMON_H
+#pragma once
#include "quantum.h"
+#if defined(UNICODE_ENABLE) + defined(UNICODEMAP_ENABLE) + defined(UCIS_ENABLE) > 1
+ #error "Cannot enable more than one Unicode method (UNICODE, UNICODEMAP, UCIS) at the same time"
+#endif
+
+// Keycodes used for starting Unicode input on different platforms
+#ifndef UNICODE_OSX_KEY
+ #define UNICODE_OSX_KEY KC_LALT
+#endif
+#ifndef UNICODE_WINC_KEY
+ #define UNICODE_WINC_KEY KC_RALT
+#endif
+
+// Comma-delimited, ordered list of input modes selected for use (e.g. in cycle)
+// Example: #define UNICODE_SELECTED_MODES UC_WINC, UC_LNX
+#ifndef UNICODE_SELECTED_MODES
+ #define UNICODE_SELECTED_MODES -1
+#endif
+
+// Whether input mode changes in cycle should be written to EEPROM
+#ifndef UNICODE_CYCLE_PERSIST
+ #define UNICODE_CYCLE_PERSIST true
+#endif
+
+// Delay between starting Unicode input and sending a sequence, in ms
#ifndef UNICODE_TYPE_DELAY
-#define UNICODE_TYPE_DELAY 10
+ #define UNICODE_TYPE_DELAY 10
#endif
-__attribute__ ((unused))
-static uint8_t input_mode;
+enum unicode_input_modes {
+ UC_OSX, // Mac OS X 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__COUNT // Number of available input modes (always leave at the end)
+};
+
+typedef union {
+ uint32_t raw;
+ struct {
+ uint8_t input_mode : 8;
+ };
+} unicode_config_t;
+
+extern unicode_config_t unicode_config;
-void set_unicode_input_mode(uint8_t os_target);
-uint8_t get_unicode_input_mode(void);
void unicode_input_mode_init(void);
+uint8_t get_unicode_input_mode(void);
+void set_unicode_input_mode(uint8_t mode);
+void cycle_unicode_input_mode(uint8_t offset);
+void persist_unicode_input_mode(void);
+
void unicode_input_start(void);
void unicode_input_finish(void);
+
void register_hex(uint16_t hex);
void send_unicode_hex_string(const char *str);
-#define UC_OSX 0 // Mac OS X
-#define UC_LNX 1 // Linux
-#define UC_WIN 2 // Windows 'HexNumpad'
-#define UC_BSD 3 // BSD (not implemented)
-#define UC_WINC 4 // WinCompose https://github.com/samhocevar/wincompose
-#define UC_OSX_RALT 5 // Mac OS X using Right Alt key for Unicode Compose
+bool process_unicode_common(uint16_t keycode, keyrecord_t *record);
#define UC_BSPC UC(0x0008)
-
#define UC_SPC UC(0x0020)
#define UC_EXLM UC(0x0021)
@@ -147,5 +183,3 @@ void send_unicode_hex_string(const char *str);
#define UC_RCBR UC(0x007D)
#define UC_TILD UC(0x007E)
#define UC_DEL UC(0x007F)
-
-#endif
diff --git a/quantum/process_keycode/process_unicodemap.c b/quantum/process_keycode/process_unicodemap.c
index ab5717ba3a..75f35112b1 100644
--- a/quantum/process_keycode/process_unicodemap.c
+++ b/quantum/process_keycode/process_unicodemap.c
@@ -45,13 +45,12 @@ __attribute__((weak))
void unicode_map_input_error() {}
bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
- unicode_input_mode_init();
uint8_t input_mode = get_unicode_input_mode();
if ((keycode & QK_UNICODE_MAP) == QK_UNICODE_MAP && record->event.pressed) {
const uint32_t* map = unicode_map;
uint16_t index = keycode - QK_UNICODE_MAP;
uint32_t code = pgm_read_dword(&map[index]);
- if (code > 0xFFFF && code <= 0x10ffff && (input_mode == UC_OSX || input_mode == UC_OSX_RALT)) {
+ if (code > 0xFFFF && code <= 0x10ffff && input_mode == UC_OSX) {
// Convert to UTF-16 surrogate pair
code -= 0x10000;
uint32_t lo = code & 0x3ff;
@@ -60,7 +59,7 @@ bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
register_hex32(hi + 0xd800);
register_hex32(lo + 0xdc00);
unicode_input_finish();
- } else if ((code > 0x10ffff && (input_mode == UC_OSX || input_mode == UC_OSX_RALT)) || (code > 0xFFFFF && input_mode == UC_LNX)) {
+ } else if ((code > 0x10ffff && input_mode == UC_OSX) || (code > 0xFFFFF && input_mode == UC_LNX)) {
// when character is out of range supported by the OS
unicode_map_input_error();
} else {
diff --git a/quantum/process_keycode/process_unicodemap.h b/quantum/process_keycode/process_unicodemap.h
index 929c88c0b6..f6d64bb86b 100644
--- a/quantum/process_keycode/process_unicodemap.h
+++ b/quantum/process_keycode/process_unicodemap.h
@@ -14,12 +14,10 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#ifndef PROCESS_UNICODEMAP_H
-#define PROCESS_UNICODEMAP_H
+#pragma once
#include "quantum.h"
#include "process_unicode_common.h"
void unicode_map_input_error(void);
bool process_unicode_map(uint16_t keycode, keyrecord_t *record);
-#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-02 14:51:00 +0000