process_unicode.c 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206
  1. #include "process_unicode.h"
  2. static uint8_t input_mode;
  3. uint16_t hex_to_keycode(uint8_t hex)
  4. {
  5. if (hex == 0x0) {
  6. return KC_0;
  7. } else if (hex < 0xA) {
  8. return KC_1 + (hex - 0x1);
  9. } else {
  10. return KC_A + (hex - 0xA);
  11. }
  12. }
  13. void set_unicode_input_mode(uint8_t os_target)
  14. {
  15. input_mode = os_target;
  16. }
  17. __attribute__((weak))
  18. void unicode_input_start (void) {
  19. switch(input_mode) {
  20. case UC_OSX:
  21. register_code(KC_LALT);
  22. break;
  23. case UC_LNX:
  24. register_code(KC_LCTL);
  25. register_code(KC_LSFT);
  26. register_code(KC_U);
  27. unregister_code(KC_U);
  28. unregister_code(KC_LSFT);
  29. unregister_code(KC_LCTL);
  30. break;
  31. case UC_WIN:
  32. register_code(KC_LALT);
  33. register_code(KC_PPLS);
  34. unregister_code(KC_PPLS);
  35. break;
  36. }
  37. wait_ms(UNICODE_TYPE_DELAY);
  38. }
  39. __attribute__((weak))
  40. void unicode_input_finish (void) {
  41. switch(input_mode) {
  42. case UC_OSX:
  43. case UC_WIN:
  44. unregister_code(KC_LALT);
  45. break;
  46. case UC_LNX:
  47. register_code(KC_SPC);
  48. unregister_code(KC_SPC);
  49. break;
  50. }
  51. }
  52. void register_hex(uint16_t hex) {
  53. for(int i = 3; i >= 0; i--) {
  54. uint8_t digit = ((hex >> (i*4)) & 0xF);
  55. register_code(hex_to_keycode(digit));
  56. unregister_code(hex_to_keycode(digit));
  57. }
  58. }
  59. bool process_unicode(uint16_t keycode, keyrecord_t *record) {
  60. if (keycode > QK_UNICODE && record->event.pressed) {
  61. uint16_t unicode = keycode & 0x7FFF;
  62. unicode_input_start();
  63. register_hex(unicode);
  64. unicode_input_finish();
  65. }
  66. return true;
  67. }
  68. #ifdef UCIS_ENABLE
  69. void qk_ucis_start(void) {
  70. qk_ucis_state.count = 0;
  71. qk_ucis_state.in_progress = true;
  72. qk_ucis_start_user();
  73. }
  74. __attribute__((weak))
  75. void qk_ucis_start_user(void) {
  76. unicode_input_start();
  77. register_hex(0x2328);
  78. unicode_input_finish();
  79. }
  80. static bool is_uni_seq(char *seq) {
  81. uint8_t i;
  82. for (i = 0; seq[i]; i++) {
  83. uint16_t code;
  84. if (('1' <= seq[i]) && (seq[i] <= '0'))
  85. code = seq[i] - '1' + KC_1;
  86. else
  87. code = seq[i] - 'a' + KC_A;
  88. if (i > qk_ucis_state.count || qk_ucis_state.codes[i] != code)
  89. return false;
  90. }
  91. return (qk_ucis_state.codes[i] == KC_ENT ||
  92. qk_ucis_state.codes[i] == KC_SPC);
  93. }
  94. __attribute__((weak))
  95. void qk_ucis_symbol_fallback (void) {
  96. for (uint8_t i = 0; i < qk_ucis_state.count - 1; i++) {
  97. uint8_t code = qk_ucis_state.codes[i];
  98. register_code(code);
  99. unregister_code(code);
  100. wait_ms(UNICODE_TYPE_DELAY);
  101. }
  102. }
  103. void register_ucis(const char *hex) {
  104. for(int i = 0; hex[i]; i++) {
  105. uint8_t kc = 0;
  106. char c = hex[i];
  107. switch (c) {
  108. case '0':
  109. kc = KC_0;
  110. break;
  111. case '1' ... '9':
  112. kc = c - '1' + KC_1;
  113. break;
  114. case 'a' ... 'f':
  115. kc = c - 'a' + KC_A;
  116. break;
  117. case 'A' ... 'F':
  118. kc = c - 'A' + KC_A;
  119. break;
  120. }
  121. if (kc) {
  122. register_code (kc);
  123. unregister_code (kc);
  124. wait_ms (UNICODE_TYPE_DELAY);
  125. }
  126. }
  127. }
  128. bool process_ucis (uint16_t keycode, keyrecord_t *record) {
  129. uint8_t i;
  130. if (!qk_ucis_state.in_progress)
  131. return true;
  132. if (qk_ucis_state.count >= UCIS_MAX_SYMBOL_LENGTH &&
  133. !(keycode == KC_BSPC || keycode == KC_ESC || keycode == KC_SPC || keycode == KC_ENT)) {
  134. return false;
  135. }
  136. if (!record->event.pressed)
  137. return true;
  138. qk_ucis_state.codes[qk_ucis_state.count] = keycode;
  139. qk_ucis_state.count++;
  140. if (keycode == KC_BSPC) {
  141. if (qk_ucis_state.count >= 2) {
  142. qk_ucis_state.count -= 2;
  143. return true;
  144. } else {
  145. qk_ucis_state.count--;
  146. return false;
  147. }
  148. }
  149. if (keycode == KC_ENT || keycode == KC_SPC || keycode == KC_ESC) {
  150. bool symbol_found = false;
  151. for (i = qk_ucis_state.count; i > 0; i--) {
  152. register_code (KC_BSPC);
  153. unregister_code (KC_BSPC);
  154. wait_ms(UNICODE_TYPE_DELAY);
  155. }
  156. if (keycode == KC_ESC) {
  157. qk_ucis_state.in_progress = false;
  158. return false;
  159. }
  160. unicode_input_start();
  161. for (i = 0; ucis_symbol_table[i].symbol; i++) {
  162. if (is_uni_seq (ucis_symbol_table[i].symbol)) {
  163. symbol_found = true;
  164. register_ucis(ucis_symbol_table[i].code + 2);
  165. break;
  166. }
  167. }
  168. if (!symbol_found) {
  169. qk_ucis_symbol_fallback();
  170. }
  171. unicode_input_finish();
  172. qk_ucis_state.in_progress = false;
  173. return false;
  174. }
  175. return true;
  176. }
  177. #endif