users/spacebarracecar/spacebarracecar.c

   1 #include "spacebarracecar.h"
   2
   3 #ifdef GERMAN_ENABLE
   4 // These indicate if left and right shift are physically pressed
   5 bool lshift = false;
   6 bool rshift = false;
   7
   8 // Interrupt and times for space cadet shift
   9 bool lshiftp = false;
  10 bool rshiftp = false;
  11 uint16_t lshift_timer = 0;
  12 uint16_t rshift_timer = 0;
  13
  14 // Number of items that are saved in prev_kcs
  15 uint8_t prev_indx = 0;
  16 // Used to save the last 6 actual keycodes activated by frankenkeycodes
  17 uint16_t prev_kcs[6] = {0, 0, 0, 0, 0, 0};
  18
  19 // If true the deadkey characters grave and circonflexe are not automatically escaped
  20 bool esct = false;
  21
  22 /*
  23 Used to add a keycode to a prev_kcs to remember it.
  24 When full the last code gets discarded and replaced by
  25 the new one.
  26 */
  27 void add_to_prev(uint16_t kc){
  28   for (int i=0; i<prev_indx; i++){
  29     if (kc == prev_kcs[i])
  30       return;
  31   }
  32   if (prev_indx == 6){
  33     for (int i=5; i>0; i--){
  34       prev_kcs[i] = prev_kcs[i-1];
  35     }
  36     prev_kcs[0] = kc;
  37   } else {
  38     prev_kcs[prev_indx] = kc;
  39     prev_indx++;
  40   }
  41 }
  42
  43 /*
  44 Unregisters all codes saved in prev_kcs and resets prev_indx.
  45 gets called on multiple occasions mainly when shift is released
  46 and when frankenkeycodes are pressed. Prevents output of
  47 wrong characters when really specific key combinations
  48 that would never occur during normal usage are pressed.
  49 */
  50 void unreg_prev(void){
  51   if (prev_indx == 0)
  52     return;
  53   for (int i=0; i<prev_indx; i++){
  54     unregister_code(prev_kcs[i]);
  55   }
  56   prev_indx = 0;
  57 }
  58 #endif
  59
  60 // Interrupt and times for Nav/Esc
  61 bool navesc = false;
  62 uint16_t navesc_timer = 0;
  63
  64 // If true Gui keys and Space Cadet Shift get disabled
  65 bool game = false;
  66
  67 // Interrupts all timers
  68 void timer_timeout(void){
  69   #ifdef GERMAN_ENABLE
  70   lshiftp = false;
  71   rshiftp = false;
  72   #endif
  73   navesc = false;
  74 }
  75
  76 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  77   switch (keycode) {
  78   case CU_GAME:
  79     if(record->event.pressed) {
  80       timer_timeout();
  81       game = !game;
  82     }
  83     // allows keymap to execute further commands when CU_GAME is pressed, for example enabling a macro layer
  84     return process_record_keymap(keycode, record) && false;
  85   case KC_LGUI:
  86   case KC_RGUI:
  87     if (record->event.pressed)
  88       timer_timeout();
  89     if (game)
  90       return false;
  91     else
  92       return true;
  93   case CU_NAV:
  94     if(record->event.pressed) {
  95       navesc = true;
  96       navesc_timer = timer_read();
  97       layer_on(_NAV);
  98     } else {
  99       if (timer_elapsed(navesc_timer) < 200 && navesc) {
 100         register_code(KC_ESC);
 101         unregister_code(KC_ESC);
 102       }
 103       layer_off(_NAV);
 104     }
 105     return false;
 106   case KC_P00:
 107     if(record->event.pressed) {
 108       timer_timeout();
 109       register_code(KC_P0);
 110       unregister_code(KC_P0);
 111       register_code(KC_P0);
 112       unregister_code(KC_P0);
 113     }
 114     return false;
 115
 116   #ifdef RGBLIGHT_ENABLE
 117   case CU_RGBV:
 118     if(record->event.pressed) {
 119       timer_timeout();
 120       if (rgblight_get_val()+32>255)
 121         rgblight_sethsv(rgblight_get_hue(), rgblight_get_sat(), 31);
 122       else
 123         rgblight_sethsv(rgblight_get_hue(), rgblight_get_sat(), rgblight_get_val()+32);
 124     }
 125     return false;
 126   #endif
 127
 128   #ifdef GERMAN_ENABLE
 129   case CU_LSFT:
 130     if(record->event.pressed) {
 131       lshiftp = true;
 132       lshift_timer = timer_read();
 133       unregister_code(KC_LSFT);
 134       register_code(KC_LSFT);
 135       lshift = true;
 136     } else {
 137       if (timer_elapsed(lshift_timer) < 200 && lshiftp && !game) {
 138         register_code(KC_LSFT);
 139         register_code(KC_8);
 140         unregister_code(KC_8);
 141         unregister_code(KC_LSFT);
 142       }
 143       unreg_prev();
 144       if (!rshift)
 145         unregister_code(KC_LSFT);
 146       lshift = false;
 147     }
 148     return false;
 149   case CU_RSFT:
 150     if(record->event.pressed) {
 151       rshiftp = true;
 152       rshift_timer = timer_read();
 153       unregister_code(KC_LSFT);
 154       register_code(KC_LSFT);
 155       rshift = true;
 156     } else {
 157       if (timer_elapsed(rshift_timer) < 200 && rshiftp && !game) {
 158         register_code(KC_LSFT);
 159         register_code(KC_9);
 160         unregister_code(KC_9);
 161         unregister_code(KC_LSFT);
 162       }
 163       unreg_prev();
 164       if (!lshift)
 165         unregister_code(KC_LSFT);
 166       rshift = false;
 167     }
 168     return false;
 169   case CU_ESCT:
 170     if(record->event.pressed) {
 171       timer_timeout();
 172       esct = !esct;
 173     }
 174     return false;
 175   case CU_AE:
 176     UML(DE_AE)
 177   case CU_OE:
 178     UML(DE_OE)
 179   case CU_UE:
 180     UML(DE_UE)
 181   case CU_SS:
 182     if(record->event.pressed) {
 183       timer_timeout();
 184       unregister_code(KC_LSFT);
 185       register_code(DE_SS);
 186       unregister_code(DE_SS);
 187       if (lshift || rshift)
 188         register_code(KC_LSFT);
 189       layer_off(_DEADKEY);
 190     }
 191     return false;
 192   case CU_DDQ:
 193     if(record->event.pressed) {
 194       timer_timeout();
 195       register_code(KC_LSFT);
 196       register_code(KC_2);
 197       unregister_code(KC_2);
 198       if (!lshift && !rshift)
 199         unregister_code(KC_LSFT);
 200       layer_off(_DEADKEY);
 201     }
 202     return false;
 203   case CU_ED:
 204     if(record->event.pressed) {
 205       timer_timeout();
 206       layer_off(_DEADKEY);
 207     }
 208     return false;
 209   case CU_GRV:
 210     if(record->event.pressed) {
 211       timer_timeout();
 212       if (lshift || rshift){
 213         unregister_code(KC_LSFT);
 214         register_code(DE_ALGR);
 215         unregister_code(DE_PLUS);
 216         register_code(DE_PLUS);
 217         unregister_code(DE_PLUS);
 218         unregister_code(DE_ALGR);
 219         register_code(KC_LSFT);
 220       } else {
 221         register_code(KC_LSFT);
 222         unregister_code(DE_ACUT);
 223         register_code(DE_ACUT);
 224         unregister_code(DE_ACUT);
 225         unregister_code(KC_LSFT);
 226         if (!esct) {
 227           register_code(KC_SPC);
 228           unregister_code(KC_SPC);
 229         }
 230       }
 231     }
 232     return false;
 233   case CU_CIRC:
 234     if(record->event.pressed) {
 235       timer_timeout();
 236       unregister_code(KC_LSFT);
 237       unregister_code(DE_CIRC);
 238       register_code(DE_CIRC);
 239       unregister_code(DE_CIRC);
 240       if (!esct) {
 241           register_code(KC_SPC);
 242           unregister_code(KC_SPC);
 243       }
 244       if (lshift || rshift)
 245         register_code(KC_LSFT);
 246     }
 247     return false;
 248   case CU_QUOT:
 249     if(record->event.pressed){
 250       timer_timeout();
 251       register_code(KC_LSFT);
 252       if (lshift || rshift){
 253         layer_on(_DEADKEY);
 254       } else {
 255         unregister_code(DE_HASH);
 256         register_code(DE_HASH);
 257         add_to_prev(DE_HASH);
 258       }
 259     } else {
 260       unregister_code(DE_HASH);
 261       unreg_prev();
 262       if (lshift || rshift)
 263         register_code(KC_LSFT);
 264       else
 265         unregister_code(KC_LSFT);
 266     }
 267     return false;
 268   case CU_6:
 269     if(record->event.pressed){
 270       timer_timeout();
 271       unregister_code(KC_LSFT);
 272       if (lshift || rshift){
 273         unregister_code(DE_CIRC);
 274         register_code(DE_CIRC);
 275         unregister_code(DE_CIRC);
 276         if (!esct) {
 277           register_code(KC_SPC);
 278           unregister_code(KC_SPC);
 279         }
 280         register_code(KC_LSFT);
 281       } else {
 282         register_code(DE_6);
 283       }
 284     } else {
 285       unregister_code(DE_6);
 286     }
 287     return false;
 288   case CU_COMM:
 289     SHIFT_NO(DE_COMM, DE_LESS)
 290   case CU_DOT:
 291     SHIFT_NORM(DE_DOT, DE_LESS)
 292   case CU_SLSH:
 293     SHIFT_ALL(DE_7, DE_SS)
 294   case CU_SCLN:
 295     SHIFT_ALL(DE_COMM, DE_DOT)
 296   case CU_3:
 297     SHIFT_NO(DE_3, DE_HASH)
 298   case CU_7:
 299     SHIFT_NORM(DE_7, DE_6)
 300   case CU_8:
 301     SHIFT_NORM(DE_8, DE_PLUS)
 302   case CU_9:
 303     SHIFT_NORM(DE_9, DE_8)
 304   case CU_0:
 305     SHIFT_NORM(DE_0, DE_9)
 306   case CU_EQL:
 307     SHIFT_SWITCH(DE_0, DE_PLUS)
 308   case CU_LBRC:
 309     SHIFT_ALGR(DE_8, DE_7)
 310   case CU_RBRC:
 311     SHIFT_ALGR(DE_9, DE_0)
 312   case CU_BSLS:
 313     SHIFT_ALGR(DE_SS, DE_LESS)
 314   case CU_Z:
 315     CTRL(DE_Z, KC_Z)
 316   case CU_Y:
 317     CTRL(DE_Y, KC_Y)
 318   case KC_LCTL:
 319   case KC_RCTL:
 320     if(!record->event.pressed) {
 321       timer_timeout();
 322       unregister_code(KC_Z);
 323       unregister_code(KC_Y);
 324     }
 325     return true;
 326   #endif
 327
 328   default:
 329     if(record->event.pressed) {
 330       timer_timeout();
 331
 332       #ifdef GERMAN_ENABLE
 333       if (lshift || rshift)
 334         register_code(KC_LSFT);
 335       else
 336         unregister_code(KC_LSFT);
 337       #endif
 338
 339     }
 340     return process_record_keymap(keycode, record);
 341   }
 342 }