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   timer_timeout_keymap();
  75 }
  76
  77 __attribute__((weak))
  78 void timer_timeout_keymap(void){
  79 }
  80
  81 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  82   switch (keycode) {
  83   case CU_GAME:
  84     if(record->event.pressed) {
  85       timer_timeout();
  86       game = !game;
  87     }
  88     // allows keymap to execute further commands when CU_GAME is pressed, for example enabling a macro layer
  89     return process_record_keymap(keycode, record) && false;
  90   case KC_LGUI:
  91   case KC_RGUI:
  92     if (record->event.pressed)
  93       timer_timeout();
  94     if (game)
  95       return false;
  96     else
  97       return true;
  98   case CU_NAV:
  99     if(record->event.pressed) {
 100       navesc = true;
 101       navesc_timer = timer_read();
 102       layer_on(_NAV);
 103     } else {
 104       if (timer_elapsed(navesc_timer) < TAPPING_TERM && navesc) {
 105         register_code(KC_ESC);
 106         unregister_code(KC_ESC);
 107       }
 108       layer_off(_NAV);
 109     }
 110     return false;
 111   case KC_P00:
 112     if(record->event.pressed) {
 113       timer_timeout();
 114       register_code(KC_P0);
 115       unregister_code(KC_P0);
 116       register_code(KC_P0);
 117       unregister_code(KC_P0);
 118     }
 119     return false;
 120
 121   #ifdef RGBLIGHT_ENABLE
 122   case CU_RGBV:
 123     if(record->event.pressed) {
 124       timer_timeout();
 125       if (rgblight_get_val()+32>255)
 126         rgblight_sethsv(rgblight_get_hue(), rgblight_get_sat(), 31);
 127       else
 128         rgblight_sethsv(rgblight_get_hue(), rgblight_get_sat(), rgblight_get_val()+32);
 129     }
 130     return false;
 131   #endif
 132
 133   #ifdef GERMAN_ENABLE
 134   case CU_LSFT:
 135     if(record->event.pressed) {
 136       lshiftp = true;
 137       lshift_timer = timer_read();
 138       unregister_code(KC_LSFT);
 139       register_code(KC_LSFT);
 140       lshift = true;
 141     } else {
 142       if (timer_elapsed(lshift_timer) < TAPPING_TERM && lshiftp && !game) {
 143         register_code(KC_LSFT);
 144         register_code(KC_8);
 145         unregister_code(KC_8);
 146         unregister_code(KC_LSFT);
 147       }
 148       unreg_prev();
 149       if (!rshift)
 150         unregister_code(KC_LSFT);
 151       lshift = false;
 152     }
 153     return false;
 154   case CU_RSFT:
 155     if(record->event.pressed) {
 156       rshiftp = true;
 157       rshift_timer = timer_read();
 158       unregister_code(KC_LSFT);
 159       register_code(KC_LSFT);
 160       rshift = true;
 161     } else {
 162       if (timer_elapsed(rshift_timer) < TAPPING_TERM && rshiftp && !game) {
 163         register_code(KC_LSFT);
 164         register_code(KC_9);
 165         unregister_code(KC_9);
 166         unregister_code(KC_LSFT);
 167       }
 168       unreg_prev();
 169       if (!lshift)
 170         unregister_code(KC_LSFT);
 171       rshift = false;
 172     }
 173     return false;
 174   case CU_ESCT:
 175     if(record->event.pressed) {
 176       timer_timeout();
 177       esct = !esct;
 178     }
 179     return false;
 180   case CU_AE:
 181     UML(DE_AE)
 182   case CU_OE:
 183     UML(DE_OE)
 184   case CU_UE:
 185     UML(DE_UE)
 186   case CU_SS:
 187     if(record->event.pressed) {
 188       timer_timeout();
 189       unregister_code(KC_LSFT);
 190       register_code(DE_SS);
 191       unregister_code(DE_SS);
 192       if (lshift || rshift)
 193         register_code(KC_LSFT);
 194       layer_off(_DEADKEY);
 195     }
 196     return false;
 197   case CU_DDQ:
 198     if(record->event.pressed) {
 199       timer_timeout();
 200       register_code(KC_LSFT);
 201       register_code(KC_2);
 202       unregister_code(KC_2);
 203       if (!lshift && !rshift)
 204         unregister_code(KC_LSFT);
 205       layer_off(_DEADKEY);
 206     }
 207     return false;
 208   case CU_ED:
 209     if(record->event.pressed) {
 210       timer_timeout();
 211       layer_off(_DEADKEY);
 212     }
 213     return false;
 214   case CU_GRV:
 215     if(record->event.pressed) {
 216       timer_timeout();
 217       if (lshift || rshift){
 218         unregister_code(KC_LSFT);
 219         register_code(KC_ALGR);
 220         unregister_code(DE_PLUS);
 221         register_code(DE_PLUS);
 222         unregister_code(DE_PLUS);
 223         unregister_code(KC_ALGR);
 224         register_code(KC_LSFT);
 225       } else {
 226         register_code(KC_LSFT);
 227         unregister_code(DE_ACUT);
 228         register_code(DE_ACUT);
 229         unregister_code(DE_ACUT);
 230         unregister_code(KC_LSFT);
 231         if (!esct) {
 232           register_code(KC_SPC);
 233           unregister_code(KC_SPC);
 234         }
 235       }
 236     }
 237     return false;
 238   case CU_CIRC:
 239     if(record->event.pressed) {
 240       timer_timeout();
 241       unregister_code(KC_LSFT);
 242       unregister_code(DE_CIRC);
 243       register_code(DE_CIRC);
 244       unregister_code(DE_CIRC);
 245       if (!esct) {
 246           register_code(KC_SPC);
 247           unregister_code(KC_SPC);
 248       }
 249       if (lshift || rshift)
 250         register_code(KC_LSFT);
 251     }
 252     return false;
 253   case CU_QUOT:
 254     if(record->event.pressed){
 255       timer_timeout();
 256       register_code(KC_LSFT);
 257       if (lshift || rshift){
 258         layer_on(_DEADKEY);
 259       } else {
 260         unregister_code(DE_HASH);
 261         register_code(DE_HASH);
 262         add_to_prev(DE_HASH);
 263       }
 264     } else {
 265       unregister_code(DE_HASH);
 266       unreg_prev();
 267       if (lshift || rshift)
 268         register_code(KC_LSFT);
 269       else
 270         unregister_code(KC_LSFT);
 271     }
 272     return false;
 273   case CU_6:
 274     if(record->event.pressed){
 275       timer_timeout();
 276       unregister_code(KC_LSFT);
 277       if (lshift || rshift){
 278         unregister_code(DE_CIRC);
 279         register_code(DE_CIRC);
 280         unregister_code(DE_CIRC);
 281         if (!esct) {
 282           register_code(KC_SPC);
 283           unregister_code(KC_SPC);
 284         }
 285         register_code(KC_LSFT);
 286       } else {
 287         register_code(DE_6);
 288       }
 289     } else {
 290       unregister_code(DE_6);
 291     }
 292     return false;
 293   case CU_COMM:
 294     SHIFT_NO(DE_COMM, DE_LESS)
 295   case CU_DOT:
 296     SHIFT_NORM(DE_DOT, DE_LESS)
 297   case CU_SLSH:
 298     SHIFT_ALL(DE_7, DE_SS)
 299   case CU_SCLN:
 300     SHIFT_ALL(DE_COMM, DE_DOT)
 301   case CU_3:
 302     SHIFT_NO(DE_3, DE_HASH)
 303   case CU_7:
 304     SHIFT_NORM(DE_7, DE_6)
 305   case CU_8:
 306     SHIFT_NORM(DE_8, DE_PLUS)
 307   case CU_9:
 308     SHIFT_NORM(DE_9, DE_8)
 309   case CU_0:
 310     SHIFT_NORM(DE_0, DE_9)
 311   case CU_EQL:
 312     SHIFT_SWITCH(DE_0, DE_PLUS)
 313   case CU_LBRC:
 314     SHIFT_ALGR(DE_8, DE_7)
 315   case CU_RBRC:
 316     SHIFT_ALGR(DE_9, DE_0)
 317   case CU_BSLS:
 318     SHIFT_ALGR(DE_SS, DE_LESS)
 319   case CU_Z:
 320     CTRL(DE_Z, KC_Z)
 321   case CU_Y:
 322     CTRL(DE_Y, KC_Y)
 323   case KC_LCTL:
 324   case KC_RCTL:
 325     if(!record->event.pressed) {
 326       timer_timeout();
 327       unregister_code(KC_Z);
 328       unregister_code(KC_Y);
 329     }
 330     return true;
 331   #endif
 332
 333   default:
 334     if(record->event.pressed) {
 335       timer_timeout();
 336
 337       #ifdef GERMAN_ENABLE
 338       if (lshift || rshift)
 339         register_code(KC_LSFT);
 340       else
 341         unregister_code(KC_LSFT);
 342       #endif
 343
 344     }
 345     return process_record_keymap(keycode, record);
 346   }
 347 }
 348
 349 __attribute__((weak))
 350 bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
 351   return true;
 352 }