users/spacebarracecar/spacebarracecar.c

   1 #include "spacebarracecar.h"
   2
   3 #ifdef GERMAN_ENABLE
   4 bool lshift = false;
   5 bool rshift = false;
   6 bool lshiftp = false;
   7 bool rshiftp = false;
   8 uint16_t lshift_timer = 0;
   9 uint16_t rshift_timer = 0;
  10
  11 uint8_t prev_indx = 0;
  12 uint16_t prev_kcs[6] = {0, 0, 0, 0, 0, 0};
  13
  14 bool esct = false;
  15
  16 void add_to_prev(uint16_t kc){
  17   for (int i=0; i<prev_indx; i++){
  18     if (kc == prev_kcs[i])
  19       return;
  20   }
  21   if (prev_indx == 6){
  22     for (int i=5; i>0; i--){
  23       prev_kcs[i] = prev_kcs[i-1];
  24     }
  25     prev_kcs[0] = kc;
  26   } else {
  27     prev_kcs[prev_indx] = kc;
  28     prev_indx++;
  29   }
  30 }
  31
  32 void unreg_prev(void){
  33   if (prev_indx == 0)
  34     return;
  35   for (int i=0; i<prev_indx; i++){
  36     unregister_code(prev_kcs[i]);
  37   }
  38   prev_indx = 0;
  39 }
  40 #endif
  41
  42 // stuff for nav esc
  43 bool navesc = false;
  44 uint16_t navesc_timer = 0;
  45 bool game = false;
  46
  47 void timer_timeout(void){
  48   #ifdef GERMAN_ENABLE
  49   lshiftp = false;
  50   rshiftp = false;
  51   #endif
  52   navesc = false;
  53 }
  54
  55 bool process_record_userspace(uint16_t keycode, keyrecord_t *record) {
  56   switch (keycode) {
  57   case CU_GAME:
  58     if(record->event.pressed) {
  59       game = !game;
  60     }
  61     return false;
  62   case KC_LGUI:
  63   case KC_RGUI:
  64     if (game)
  65       return false;
  66     else
  67       return true;
  68   case CU_NAV:
  69     if(record->event.pressed) {
  70       navesc = true;
  71       navesc_timer = timer_read();
  72       layer_on(_NAV);
  73     } else {
  74       if (timer_elapsed(navesc_timer) < 200 && navesc) {
  75         register_code(KC_ESC);
  76         unregister_code(KC_ESC);
  77       }
  78       layer_off(_NAV);
  79     }
  80   return false;
  81
  82   #ifdef RGBLIGHT_ENABLE
  83   case CU_RGBV:
  84     if(record->event.pressed) {
  85       if (rgblight_get_val()+32>255)
  86         rgblight_sethsv(rgblight_get_hue(), rgblight_get_sat(), 31);
  87       else
  88         rgblight_sethsv(rgblight_get_hue(), rgblight_get_sat(), rgblight_get_val()+32);
  89     }
  90     return false;
  91   #endif
  92
  93   #ifdef GERMAN_ENABLE
  94   case CU_LSFT:
  95     if(record->event.pressed) {
  96       lshiftp = true;
  97       lshift_timer = timer_read();
  98       unregister_code(KC_LSFT);
  99       register_code(KC_LSFT);
 100       lshift = true;
 101     } else {
 102       if (timer_elapsed(lshift_timer) < 200 && lshiftp && !game) {
 103         register_code(KC_LSFT);
 104         register_code(KC_8);
 105         unregister_code(KC_8);
 106         unregister_code(KC_LSFT);
 107       }
 108       unreg_prev();
 109       if (!rshift)
 110         unregister_code(KC_LSFT);
 111       lshift = false;
 112     }
 113     return false;
 114   case CU_RSFT:
 115     if(record->event.pressed) {
 116       rshiftp = true;
 117       rshift_timer = timer_read();
 118       unregister_code(KC_LSFT);
 119       register_code(KC_LSFT);
 120       rshift = true;
 121     } else {
 122       if (timer_elapsed(rshift_timer) < 200 && rshiftp && !game) {
 123         register_code(KC_LSFT);
 124         register_code(KC_9);
 125         unregister_code(KC_9);
 126         unregister_code(KC_LSFT);
 127       }
 128       unreg_prev();
 129       if (!lshift)
 130         unregister_code(KC_LSFT);
 131       rshift = false;
 132     }
 133     return false;
 134   case CU_ESCT:
 135     if(record->event.pressed) {
 136       esct = !esct;
 137     }
 138     return false;
 139   case CU_AE:
 140     UML(DE_AE)
 141   case CU_OE:
 142     UML(DE_OE)
 143   case CU_UE:
 144     UML(DE_UE)
 145   case CU_SS:
 146     if(record->event.pressed) {
 147       timer_timeout();
 148       unregister_code(KC_LSFT);
 149       register_code(DE_SS);
 150       unregister_code(DE_SS);
 151       if (lshift || rshift)
 152         register_code(KC_LSFT);
 153       layer_off(_DEADKEY);
 154     }
 155     return false;
 156   case CU_DDQ:
 157     if(record->event.pressed) {
 158       timer_timeout();
 159       register_code(KC_LSFT);
 160       register_code(KC_2);
 161       unregister_code(KC_2);
 162       if (!lshift && !rshift)
 163         unregister_code(KC_LSFT);
 164       layer_off(_DEADKEY);
 165     }
 166     return false;
 167   case CU_ED:
 168     if(record->event.pressed) {
 169       timer_timeout();
 170       layer_off(_DEADKEY);
 171     }
 172     return false;
 173   case CU_GRV:
 174     if(record->event.pressed) {
 175       timer_timeout();
 176       if (lshift || rshift){
 177         unregister_code(KC_LSFT);
 178         register_code(DE_ALGR);
 179         unregister_code(DE_PLUS);
 180         register_code(DE_PLUS);
 181         unregister_code(DE_PLUS);
 182         unregister_code(DE_ALGR);
 183         register_code(KC_LSFT);
 184       } else {
 185         register_code(KC_LSFT);
 186         unregister_code(DE_ACUT);
 187         register_code(DE_ACUT);
 188         unregister_code(DE_ACUT);
 189         unregister_code(KC_LSFT);
 190         if (!esct) {
 191           register_code(KC_SPC);
 192           unregister_code(KC_SPC);
 193         }
 194       }
 195     }
 196     return false;
 197   case CU_CIRC:
 198     if(record->event.pressed) {
 199       timer_timeout();
 200       unregister_code(KC_LSFT);
 201       unregister_code(DE_CIRC);
 202       register_code(DE_CIRC);
 203       unregister_code(DE_CIRC);
 204       if (!esct) {
 205           register_code(KC_SPC);
 206           unregister_code(KC_SPC);
 207       }
 208       if (lshift || rshift)
 209         register_code(KC_LSFT);
 210     }
 211     return false;
 212   case CU_QUOT:
 213     if(record->event.pressed){
 214       timer_timeout();
 215       register_code(KC_LSFT);
 216       if (lshift || rshift){
 217         layer_on(_DEADKEY);
 218       } else {
 219         unregister_code(DE_HASH);
 220         register_code(DE_HASH);
 221         add_to_prev(DE_HASH);
 222       }
 223     } else {
 224       unregister_code(DE_HASH);
 225       unreg_prev();
 226       if (lshift || rshift)
 227         register_code(KC_LSFT);
 228       else
 229         unregister_code(KC_LSFT);
 230     }
 231     return false;
 232   case CU_6:
 233     if(record->event.pressed){
 234       timer_timeout();
 235       unregister_code(KC_LSFT);
 236       if (lshift || rshift){
 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         register_code(KC_LSFT);
 245       } else {
 246         register_code(DE_6);
 247       }
 248     } else {
 249       unregister_code(DE_6);
 250     }
 251     return false;
 252   case CU_COMM:
 253     SHIFT_NO(DE_COMM, DE_LESS)
 254   case CU_DOT:
 255     SHIFT_NORM(DE_DOT, DE_LESS)
 256   case CU_SLSH:
 257     SHIFT_ALL(DE_7, DE_SS)
 258   case CU_SCLN:
 259     SHIFT_ALL(DE_COMM, DE_DOT)
 260   case CU_3:
 261     SHIFT_NO(DE_3, DE_HASH)
 262   case CU_7:
 263     SHIFT_NORM(DE_7, DE_6)
 264   case CU_8:
 265     SHIFT_NORM(DE_8, DE_PLUS)
 266   case CU_9:
 267     SHIFT_NORM(DE_9, DE_8)
 268   case CU_0:
 269     SHIFT_NORM(DE_0, DE_9)
 270   case CU_EQL:
 271     SHIFT_SWITCH(DE_0, DE_PLUS)
 272   case CU_LBRC:
 273     SHIFT_ALGR(DE_8, DE_7)
 274   case CU_RBRC:
 275     SHIFT_ALGR(DE_9, DE_0)
 276   case CU_BSLS:
 277     SHIFT_ALGR(DE_SS, DE_LESS)
 278   case CU_Z:
 279     CTRL(DE_Z, KC_Z)
 280   case CU_Y:
 281     CTRL(DE_Y, KC_Y)
 282   case KC_LCTL:
 283   case KC_RCTL:
 284     if(!record->event.pressed) {
 285       unregister_code(KC_Z);
 286       unregister_code(KC_Y);
 287     }
 288     return true;
 289   #endif
 290
 291   default:
 292     if(record->event.pressed) {
 293       timer_timeout();
 294
 295       #ifdef GERMAN_ENABLE
 296       if (lshift || rshift)
 297         register_code(KC_LSFT);
 298       else
 299         unregister_code(KC_LSFT);
 300       #endif
 301
 302     }
 303     return true;
 304   }
 305 }