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