quantum/process_keycode/process_unicode_common.c

   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
  17 #include "process_unicode_common.h"
  18 #include "eeprom.h"
  19 #include <ctype.h>
  20 #include <string.h>
  21
  22 unicode_config_t unicode_config;
  23 uint8_t          unicode_saved_mods;
  24
  25 #if UNICODE_SELECTED_MODES != -1
  26 static uint8_t selected[] = { UNICODE_SELECTED_MODES };
  27 static uint8_t selected_count = sizeof selected / sizeof *selected;
  28 static uint8_t selected_index;
  29 #endif
  30
  31 void unicode_input_mode_init(void) {
  32   unicode_config.raw = eeprom_read_byte(EECONFIG_UNICODEMODE);
  33 #if UNICODE_SELECTED_MODES != -1
  34   #if UNICODE_CYCLE_PERSIST
  35   // Find input_mode in selected modes
  36   uint8_t i;
  37   for (i = 0; i < selected_count; i++) {
  38     if (selected[i] == unicode_config.input_mode) {
  39       selected_index = i;
  40       break;
  41     }
  42   }
  43   if (i == selected_count) {
  44     // Not found: input_mode isn't selected, change to one that is
  45     unicode_config.input_mode = selected[selected_index = 0];
  46   }
  47   #else
  48   // Always change to the first selected input mode
  49   unicode_config.input_mode = selected[selected_index = 0];
  50   #endif
  51 #endif
  52   dprintf("Unicode input mode init to: %u\n", unicode_config.input_mode);
  53 }
  54
  55 uint8_t get_unicode_input_mode(void) {
  56   return unicode_config.input_mode;
  57 }
  58
  59 void set_unicode_input_mode(uint8_t mode) {
  60   unicode_config.input_mode = mode;
  61   persist_unicode_input_mode();
  62   dprintf("Unicode input mode set to: %u\n", unicode_config.input_mode);
  63 }
  64
  65 void cycle_unicode_input_mode(uint8_t offset) {
  66 #if UNICODE_SELECTED_MODES != -1
  67   selected_index = (selected_index + offset) % selected_count;
  68   unicode_config.input_mode = selected[selected_index];
  69   #if UNICODE_CYCLE_PERSIST
  70   persist_unicode_input_mode();
  71   #endif
  72   dprintf("Unicode input mode cycle to: %u\n", unicode_config.input_mode);
  73 #endif
  74 }
  75
  76 void persist_unicode_input_mode(void) {
  77   eeprom_update_byte(EECONFIG_UNICODEMODE, unicode_config.input_mode);
  78 }
  79
  80 __attribute__((weak))
  81 void unicode_input_start(void) {
  82   unicode_saved_mods = get_mods(); // Save current mods
  83   clear_mods(); // Unregister mods to start from a clean state
  84
  85   switch (unicode_config.input_mode) {
  86   case UC_OSX:
  87     register_code(UNICODE_KEY_OSX);
  88     break;
  89   case UC_LNX:
  90     tap_code16(UNICODE_KEY_LNX);
  91     break;
  92   case UC_WIN:
  93     register_code(KC_LALT);
  94     tap_code(KC_PPLS);
  95     break;
  96   case UC_WINC:
  97     tap_code(UNICODE_KEY_WINC);
  98     tap_code(KC_U);
  99     break;
 100   }
 101
 102   wait_ms(UNICODE_TYPE_DELAY);
 103 }
 104
 105 __attribute__((weak))
 106 void unicode_input_finish(void) {
 107   switch (unicode_config.input_mode) {
 108   case UC_OSX:
 109     unregister_code(UNICODE_KEY_OSX);
 110     break;
 111   case UC_LNX:
 112     tap_code(KC_SPC);
 113     break;
 114   case UC_WIN:
 115     unregister_code(KC_LALT);
 116     break;
 117   case UC_WINC:
 118     tap_code(KC_ENTER);
 119     break;
 120   }
 121
 122   set_mods(unicode_saved_mods); // Reregister previously set mods
 123 }
 124
 125 __attribute__((weak))
 126 void unicode_input_cancel(void) {
 127   switch (unicode_config.input_mode) {
 128   case UC_OSX:
 129     unregister_code(UNICODE_KEY_OSX);
 130     break;
 131   case UC_LNX:
 132   case UC_WINC:
 133     tap_code(KC_ESC);
 134     break;
 135   case UC_WIN:
 136     unregister_code(KC_LALT);
 137     break;
 138   }
 139
 140   set_mods(unicode_saved_mods); // Reregister previously set mods
 141 }
 142
 143 __attribute__((weak))
 144 uint16_t hex_to_keycode(uint8_t hex) {
 145   if (hex == 0x0) {
 146     return KC_0;
 147   } else if (hex < 0xA) {
 148     return KC_1 + (hex - 0x1);
 149   } else {
 150     return KC_A + (hex - 0xA);
 151   }
 152 }
 153
 154 void register_hex(uint16_t hex) {
 155   for(int i = 3; i >= 0; i--) {
 156     uint8_t digit = ((hex >> (i*4)) & 0xF);
 157     tap_code(hex_to_keycode(digit));
 158   }
 159 }
 160
 161 void send_unicode_hex_string(const char *str) {
 162   if (!str) { return; }
 163
 164   while (*str) {
 165     // Find the next code point (token) in the string
 166     for (; *str == ' '; str++);
 167     size_t n = strcspn(str, " "); // Length of the current token
 168     char code_point[n+1];
 169     strncpy(code_point, str, n);
 170     code_point[n] = '\0'; // Make sure it's null-terminated
 171
 172     // Normalize the code point: make all hex digits lowercase
 173     for (char *p = code_point; *p; p++) {
 174       *p = tolower((unsigned char)*p);
 175     }
 176
 177     // Send the code point as a Unicode input string
 178     unicode_input_start();
 179     send_string(code_point);
 180     unicode_input_finish();
 181
 182     str += n; // Move to the first ' ' (or '\0') after the current token
 183   }
 184 }
 185
 186 bool process_unicode_common(uint16_t keycode, keyrecord_t *record) {
 187   if (record->event.pressed) {
 188     switch (keycode) {
 189     case UNICODE_MODE_FORWARD:
 190       cycle_unicode_input_mode(+1);
 191       break;
 192     case UNICODE_MODE_REVERSE:
 193       cycle_unicode_input_mode(-1);
 194       break;
 195
 196     case UNICODE_MODE_OSX:
 197       set_unicode_input_mode(UC_OSX);
 198 #if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_OSX)
 199       static float song_osx[][2] = UNICODE_SONG_OSX;
 200       PLAY_SONG(song_osx);
 201 #endif
 202       break;
 203     case UNICODE_MODE_LNX:
 204       set_unicode_input_mode(UC_LNX);
 205 #if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_LNX)
 206       static float song_lnx[][2] = UNICODE_SONG_LNX;
 207       PLAY_SONG(song_lnx);
 208 #endif
 209       break;
 210     case UNICODE_MODE_WIN:
 211       set_unicode_input_mode(UC_WIN);
 212 #if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_WIN)
 213       static float song_win[][2] = UNICODE_SONG_WIN;
 214       PLAY_SONG(song_win);
 215 #endif
 216       break;
 217     case UNICODE_MODE_BSD:
 218       set_unicode_input_mode(UC_BSD);
 219 #if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_BSD)
 220       static float song_bsd[][2] = UNICODE_SONG_BSD;
 221       PLAY_SONG(song_bsd);
 222 #endif
 223       break;
 224     case UNICODE_MODE_WINC:
 225       set_unicode_input_mode(UC_WINC);
 226 #if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_WINC)
 227       static float song_winc[][2] = UNICODE_SONG_WINC;
 228       PLAY_SONG(song_winc);
 229 #endif
 230       break;
 231     }
 232   }
 233 #if   defined(UNICODE_ENABLE)
 234   return process_unicode(keycode, record);
 235 #elif defined(UNICODEMAP_ENABLE)
 236   return process_unicodemap(keycode, record);
 237 #elif defined(UCIS_ENABLE)
 238   return process_ucis(keycode, record);
 239 #else
 240   return true;
 241 #endif
 242 }