process_unicode_common.c 9.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302
  1. /* Copyright 2017 Jack Humbert
  2. *
  3. * This program is free software: you can redistribute it and/or modify
  4. * it under the terms of the GNU General Public License as published by
  5. * the Free Software Foundation, either version 2 of the License, or
  6. * (at your option) any later version.
  7. *
  8. * This program is distributed in the hope that it will be useful,
  9. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. * GNU General Public License for more details.
  12. *
  13. * You should have received a copy of the GNU General Public License
  14. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  15. */
  16. #include "process_unicode_common.h"
  17. #include "eeprom.h"
  18. #include <ctype.h>
  19. #include <string.h>
  20. unicode_config_t unicode_config;
  21. uint8_t unicode_saved_mods;
  22. #if UNICODE_SELECTED_MODES != -1
  23. static uint8_t selected[] = {UNICODE_SELECTED_MODES};
  24. static uint8_t selected_count = sizeof selected / sizeof *selected;
  25. static uint8_t selected_index;
  26. #endif
  27. void unicode_input_mode_init(void) {
  28. unicode_config.raw = eeprom_read_byte(EECONFIG_UNICODEMODE);
  29. #if UNICODE_SELECTED_MODES != -1
  30. # if UNICODE_CYCLE_PERSIST
  31. // Find input_mode in selected modes
  32. uint8_t i;
  33. for (i = 0; i < selected_count; i++) {
  34. if (selected[i] == unicode_config.input_mode) {
  35. selected_index = i;
  36. break;
  37. }
  38. }
  39. if (i == selected_count) {
  40. // Not found: input_mode isn't selected, change to one that is
  41. unicode_config.input_mode = selected[selected_index = 0];
  42. }
  43. # else
  44. // Always change to the first selected input mode
  45. unicode_config.input_mode = selected[selected_index = 0];
  46. # endif
  47. #endif
  48. dprintf("Unicode input mode init to: %u\n", unicode_config.input_mode);
  49. }
  50. uint8_t get_unicode_input_mode(void) { return unicode_config.input_mode; }
  51. void set_unicode_input_mode(uint8_t mode) {
  52. unicode_config.input_mode = mode;
  53. persist_unicode_input_mode();
  54. dprintf("Unicode input mode set to: %u\n", unicode_config.input_mode);
  55. }
  56. void cycle_unicode_input_mode(uint8_t offset) {
  57. #if UNICODE_SELECTED_MODES != -1
  58. selected_index = (selected_index + offset) % selected_count;
  59. unicode_config.input_mode = selected[selected_index];
  60. # if UNICODE_CYCLE_PERSIST
  61. persist_unicode_input_mode();
  62. # endif
  63. dprintf("Unicode input mode cycle to: %u\n", unicode_config.input_mode);
  64. #endif
  65. }
  66. void persist_unicode_input_mode(void) { eeprom_update_byte(EECONFIG_UNICODEMODE, unicode_config.input_mode); }
  67. __attribute__((weak)) void unicode_input_start(void) {
  68. unicode_saved_mods = get_mods(); // Save current mods
  69. clear_mods(); // Unregister mods to start from a clean state
  70. switch (unicode_config.input_mode) {
  71. case UC_OSX:
  72. register_code(UNICODE_KEY_OSX);
  73. break;
  74. case UC_LNX:
  75. tap_code16(UNICODE_KEY_LNX);
  76. break;
  77. case UC_WIN:
  78. register_code(KC_LALT);
  79. tap_code(KC_PPLS);
  80. break;
  81. case UC_WINC:
  82. tap_code(UNICODE_KEY_WINC);
  83. tap_code(KC_U);
  84. break;
  85. }
  86. wait_ms(UNICODE_TYPE_DELAY);
  87. }
  88. __attribute__((weak)) void unicode_input_finish(void) {
  89. switch (unicode_config.input_mode) {
  90. case UC_OSX:
  91. unregister_code(UNICODE_KEY_OSX);
  92. break;
  93. case UC_LNX:
  94. tap_code(KC_SPC);
  95. break;
  96. case UC_WIN:
  97. unregister_code(KC_LALT);
  98. break;
  99. case UC_WINC:
  100. tap_code(KC_ENTER);
  101. break;
  102. }
  103. set_mods(unicode_saved_mods); // Reregister previously set mods
  104. }
  105. __attribute__((weak)) void unicode_input_cancel(void) {
  106. switch (unicode_config.input_mode) {
  107. case UC_OSX:
  108. unregister_code(UNICODE_KEY_OSX);
  109. break;
  110. case UC_LNX:
  111. case UC_WINC:
  112. tap_code(KC_ESC);
  113. break;
  114. case UC_WIN:
  115. unregister_code(KC_LALT);
  116. break;
  117. }
  118. set_mods(unicode_saved_mods); // Reregister previously set mods
  119. }
  120. __attribute__((weak)) uint16_t hex_to_keycode(uint8_t hex) {
  121. if (hex == 0x0) {
  122. return KC_0;
  123. } else if (hex < 0xA) {
  124. return KC_1 + (hex - 0x1);
  125. } else {
  126. return KC_A + (hex - 0xA);
  127. }
  128. }
  129. void register_hex(uint16_t hex) {
  130. for (int i = 3; i >= 0; i--) {
  131. uint8_t digit = ((hex >> (i * 4)) & 0xF);
  132. tap_code(hex_to_keycode(digit));
  133. }
  134. }
  135. void register_hex32(uint32_t hex) {
  136. bool onzerostart = true;
  137. for (int i = 7; i >= 0; i--) {
  138. if (i <= 3) {
  139. onzerostart = false;
  140. }
  141. uint8_t digit = ((hex >> (i * 4)) & 0xF);
  142. if (digit == 0) {
  143. if (!onzerostart) {
  144. tap_code(hex_to_keycode(digit));
  145. }
  146. } else {
  147. tap_code(hex_to_keycode(digit));
  148. onzerostart = false;
  149. }
  150. }
  151. }
  152. void send_unicode_hex_string(const char *str) {
  153. if (!str) {
  154. return;
  155. }
  156. while (*str) {
  157. // Find the next code point (token) in the string
  158. for (; *str == ' '; str++)
  159. ;
  160. size_t n = strcspn(str, " "); // Length of the current token
  161. char code_point[n + 1];
  162. strncpy(code_point, str, n);
  163. code_point[n] = '\0'; // Make sure it's null-terminated
  164. // Normalize the code point: make all hex digits lowercase
  165. for (char *p = code_point; *p; p++) {
  166. *p = tolower((unsigned char)*p);
  167. }
  168. // Send the code point as a Unicode input string
  169. unicode_input_start();
  170. send_string(code_point);
  171. unicode_input_finish();
  172. str += n; // Move to the first ' ' (or '\0') after the current token
  173. }
  174. }
  175. // Borrowed from https://nullprogram.com/blog/2017/10/06/
  176. const char *decode_utf8(const char *str, int32_t *code_point) {
  177. const char *next;
  178. if (str[0] < 0x80) { // U+0000-007F
  179. *code_point = str[0];
  180. next = str + 1;
  181. } else if ((str[0] & 0xE0) == 0xC0) { // U+0080-07FF
  182. *code_point = ((int32_t)(str[0] & 0x1F) << 6) | ((int32_t)(str[1] & 0x3F) << 0);
  183. next = str + 2;
  184. } else if ((str[0] & 0xF0) == 0xE0) { // U+0800-FFFF
  185. *code_point = ((int32_t)(str[0] & 0x0F) << 12) | ((int32_t)(str[1] & 0x3F) << 6) | ((int32_t)(str[2] & 0x3F) << 0);
  186. next = str + 3;
  187. } else if ((str[0] & 0xF8) == 0xF0 && (str[0] <= 0xF4)) { // U+10000-10FFFF
  188. *code_point = ((int32_t)(str[0] & 0x07) << 18) | ((int32_t)(str[1] & 0x3F) << 12) | ((int32_t)(str[2] & 0x3F) << 6) | ((int32_t)(str[3] & 0x3F) << 0);
  189. next = str + 4;
  190. } else {
  191. *code_point = -1;
  192. next = str + 1;
  193. }
  194. // part of a UTF-16 surrogate pair - invalid
  195. if (*code_point >= 0xD800 && *code_point <= 0xDFFF) {
  196. *code_point = -1;
  197. }
  198. return next;
  199. }
  200. void send_unicode_string(const char *str) {
  201. if (!str) {
  202. return;
  203. }
  204. int32_t code_point = 0;
  205. while (*str) {
  206. str = decode_utf8(str, &code_point);
  207. if (code_point >= 0) {
  208. unicode_input_start();
  209. register_hex32(code_point);
  210. unicode_input_finish();
  211. }
  212. }
  213. }
  214. bool process_unicode_common(uint16_t keycode, keyrecord_t *record) {
  215. if (record->event.pressed) {
  216. switch (keycode) {
  217. case UNICODE_MODE_FORWARD:
  218. cycle_unicode_input_mode(+1);
  219. break;
  220. case UNICODE_MODE_REVERSE:
  221. cycle_unicode_input_mode(-1);
  222. break;
  223. case UNICODE_MODE_OSX:
  224. set_unicode_input_mode(UC_OSX);
  225. #if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_OSX)
  226. static float song_osx[][2] = UNICODE_SONG_OSX;
  227. PLAY_SONG(song_osx);
  228. #endif
  229. break;
  230. case UNICODE_MODE_LNX:
  231. set_unicode_input_mode(UC_LNX);
  232. #if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_LNX)
  233. static float song_lnx[][2] = UNICODE_SONG_LNX;
  234. PLAY_SONG(song_lnx);
  235. #endif
  236. break;
  237. case UNICODE_MODE_WIN:
  238. set_unicode_input_mode(UC_WIN);
  239. #if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_WIN)
  240. static float song_win[][2] = UNICODE_SONG_WIN;
  241. PLAY_SONG(song_win);
  242. #endif
  243. break;
  244. case UNICODE_MODE_BSD:
  245. set_unicode_input_mode(UC_BSD);
  246. #if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_BSD)
  247. static float song_bsd[][2] = UNICODE_SONG_BSD;
  248. PLAY_SONG(song_bsd);
  249. #endif
  250. break;
  251. case UNICODE_MODE_WINC:
  252. set_unicode_input_mode(UC_WINC);
  253. #if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_WINC)
  254. static float song_winc[][2] = UNICODE_SONG_WINC;
  255. PLAY_SONG(song_winc);
  256. #endif
  257. break;
  258. }
  259. }
  260. #if defined(UNICODE_ENABLE)
  261. return process_unicode(keycode, record);
  262. #elif defined(UNICODEMAP_ENABLE)
  263. return process_unicodemap(keycode, record);
  264. #elif defined(UCIS_ENABLE)
  265. return process_ucis(keycode, record);
  266. #else
  267. return true;
  268. #endif
  269. }