keyboards/planck/keymaps/zach/zach_common_functions.c

   1 #ifndef ZACH_COMMON_FUNCTIONS
   2 #define ZACH_COMMON_FUNCTIONS
   3 #include "eeconfig.h"
   4 #include "action_layer.h"
   5 #include "keymap_colemak.h"
   6 extern keymap_config_t keymap_config;
   7
   8 // Fillers to make layering more clear
   9 #define _______ KC_TRNS
  10 #define XXXXXXX KC_NO
  11 #define C(n)    RCTL(n)
  12 #define CADKEY  RCTL(RALT(KC_DEL))
  13
  14 void tap(uint16_t keycode){
  15     register_code(keycode);
  16     unregister_code(keycode);
  17 };
  18
  19 void persistant_default_layer_set(uint16_t default_layer){
  20     eeconfig_update_default_layer(default_layer);
  21     default_layer_set(default_layer);
  22 };
  23
  24 // Automatic number generation of important keywords
  25 enum my_keycodes{
  26     // Layer numbers
  27     _COLEMAK = 0,
  28     _SWCOLE,
  29     _RAISE,
  30     _LOWER,
  31     _ADJUST,
  32     _UNICODES,
  33     // These use process_record_user()
  34     COLEMAK = SAFE_RANGE,
  35     SWCOLE,
  36     LOWER,
  37     RAISE,
  38     SHFT_CAP,
  39     CTRLB,
  40     CPYPST,
  41     FACE,
  42     UNIWIN,
  43     UNILIN,
  44     DISFACE,
  45     TFLIP,
  46     TPUT,
  47     SHRUG,
  48     PENIS,
  49     BOOBS,
  50     Sil_Pas,
  51     Sil_Usr,
  52     UltiU,
  53     UltiP,
  54     TappyR,
  55     TappyL,
  56     RANDIG,
  57     FINGER,
  58     // Tap_Dance nums
  59     RAI = 0,
  60     LOW,
  61     SUP
  62 };
  63
  64 #ifdef AUDIO_ENABLE
  65 #include "audio.h"
  66 float tone_startup[][2]         = SONG(STARTUP_SOUND);
  67 float tone_goodbye[][2]         = SONG(GOODBYE_SOUND);
  68 float tone_colemak[][2]         = SONG(COLEMAK_SOUND);
  69 float tone_swcole[][2]          = SONG(QWERTY_SOUND);
  70 float tone_capslock_on[][2]     = SONG(CAPS_LOCK_ON_SOUND);
  71 float tone_capslock_off[][2]    = SONG(CAPS_LOCK_OFF_SOUND);
  72 float tone_ctrl_mod[][2]        = SONG(COIN_SOUND);
  73 float tone_copy[][2]            = SONG(SCROLL_LOCK_ON_SOUND);
  74 float tone_paste[][2]           = SONG(SCROLL_LOCK_OFF_SOUND);
  75 float uniwin[][2]               = SONG(UNICODE_WINDOWS);
  76 float unilin[][2]               = SONG(UNICODE_LINUX);
  77 #endif
  78
  79 #ifdef TAP_DANCE_ENABLE
  80 #define TAPPING_TERM 200
  81
  82 uint8_t Lstate = 0, Rstate = 0;
  83 uint32_t Ltimer = 0, Rtimer = 0;
  84 uint32_t Ltimes[3], Rtimes[4];   // Ratio of tap times should be about 1.335 (L/R)
  85 void rhythm_parse(void){
  86     int L = Ltimes[0] + Ltimes[1] + Ltimes[2];  // Start to end time
  87     int R = Rtimes[0] + Rtimes[1] + Rtimes[2] + Rtimes[3];
  88     if(abs(R-L) > 10){
  89         tap(KC_N); tap(KC_O);
  90         return;
  91     } else {
  92         L = (L / 3)*100;                    // Average time per tap * 100
  93         R = (R / 4);
  94         if(abs(abs(L/R)-133) > 1){
  95             tap(KC_N); tap(KC_O);
  96             tap(KC_P); tap(KC_E);
  97             return;
  98         } else {
  99             tap(KC_O); tap(KC_K);
 100             return;
 101         }
 102     }
 103 };
 104
 105 void dance_raise_press(qk_tap_dance_state_t *state, void *user_data){// Called on each tap
 106   switch(state->count){      // Only turn the layer on once
 107     case 1:
 108         layer_off(_UNICODES);
 109         layer_on(_RAISE);
 110         update_tri_layer(_LOWER, _RAISE, _ADJUST);
 111         break;
 112   }
 113 };
 114 void dance_raise_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on release
 115   switch(state->count){
 116     case 1:         // Normal action. Turn off layers
 117         layer_off(_RAISE);
 118         update_tri_layer(_LOWER, _RAISE, _ADJUST);
 119         layer_off(_UNICODES);
 120         break;
 121   }
 122 };
 123 /////////////////////////////////////////////////////////////////////
 124 void dance_lower_press(qk_tap_dance_state_t *state, void *user_data){// Called on tap
 125   switch(state->count){
 126     case 1:         // Turn on lower
 127         layer_off(_UNICODES);
 128         layer_on(_LOWER);
 129         update_tri_layer(_LOWER, _RAISE, _ADJUST);
 130         break;
 131   }
 132 };
 133 void dance_lower_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on release
 134   switch(state->count){
 135     case 1:         // Normal action. Turn off layers
 136         layer_off(_LOWER);
 137         update_tri_layer(_LOWER, _RAISE, _ADJUST);
 138         layer_off(_UNICODES);
 139         break;
 140     case 2:         // Turn on _UNICODES layer
 141         layer_off(_LOWER);
 142         update_tri_layer(_LOWER, _RAISE, _ADJUST);
 143         layer_on(_UNICODES);
 144         #ifdef AUDIO_ENABLE
 145             PLAY_NOTE_ARRAY(tone_ctrl_mod, false, 0);
 146         #endif
 147         break;
 148   }
 149 };
 150 /////////////////////////////////////////////////////////////////////
 151 void dance_super_press(qk_tap_dance_state_t *state, void *user_data){   // Called on down
 152     if(state->count == 1){
 153         register_code(KC_LGUI);
 154     }
 155 }
 156 void dance_super_done(qk_tap_dance_state_t *state, void *user_data){    // Called on timeout
 157   switch(state->count){
 158     case 2:
 159         register_code(KC_LGUI);
 160         tap(KC_L);
 161         unregister_code(KC_LGUI);
 162         break;
 163   }
 164 }
 165 void dance_super_lift(qk_tap_dance_state_t *state, void *user_data){        // Called on up
 166     unregister_code(KC_LGUI);
 167 }
 168
 169 qk_tap_dance_action_t tap_dance_actions[] = {
 170     [RAI] = ACTION_TAP_DANCE_FN_ADVANCED(dance_raise_press, NULL, dance_raise_lift),
 171     [LOW] = ACTION_TAP_DANCE_FN_ADVANCED(dance_lower_press, NULL, dance_lower_lift),
 172     [SUP] = ACTION_TAP_DANCE_FN_ADVANCED(dance_super_press, dance_super_done, dance_super_lift)
 173 };
 174 #endif
 175
 176 #ifdef UNICODE_ENABLE
 177 // Unicode shortcuts
 178 #define IBANG   UC(0x203D)
 179 #define RAROW   UC(0x2192)
 180 #define LAROW   UC(0x2190)
 181 #define DEGREE  UC(0x00B0)
 182 #define OMEGA   UC(0x03A9)
 183 #define WOMEGA  UC(0x03C9)
 184 #define MICRO   UC(0x00B5)
 185 #define PLUMIN  UC(0x00B1)
 186 #define SUPA2   UC(0x00B2)
 187 #define ROMAN1  UC(0x2160)
 188 #define ROMAN2  UC(0x2161)
 189 #define ROMAN3  UC(0x2162)
 190 #define ROMAN4  UC(0x2163)
 191 #define ROMAN5  UC(0x2164)
 192 #define ROMAN6  UC(0x2165)
 193 #define ROMAN7  UC(0x2166)
 194 #define roman1  UC(0x2170)
 195 #define roman2  UC(0x2171)
 196 #define roman3  UC(0x2172)
 197 #define roman4  UC(0x2173)
 198 #define roman5  UC(0x2174)
 199 #define roman6  UC(0x2175)
 200 #define roman7  UC(0x2176)
 201
 202 #ifdef UNICODEMAP_ENABLE        // For Unicode characters larger than 0x8000. Send with X(<unicode>)
 203 enum Ext_Unicode{
 204     PENGUIN = 0,
 205     BOAR,
 206     MONKEY,
 207     DRAGON,
 208     CHICK,
 209     TUMBLER
 210 };
 211 const uint32_t PROGMEM unicode_map[] = {
 212     [PENGUIN]   = 0x1F427,
 213     [BOAR]      = 0x1F417,
 214     [MONKEY]    = 0x1F412,
 215     [DRAGON]    = 0x1F409,
 216     [CHICK]     = 0x1F425,
 217     [TUMBLER]   = 0x1F943
 218 };
 219 #define PENGY   X(PENGUIN)
 220 #define BOARY   X(BOAR)
 221 #define MNKY    X(MONKEY)
 222 #define DRGN    X(DRAGON)
 223 #define DUCK    X(CHICK)
 224 #define TMBL    X(TUMBLER)
 225 #endif
 226
 227 #endif
 228
 229 static uint16_t key_timer;
 230 static uint8_t  caps_status = 0;
 231 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 232   switch (keycode) {
 233     case COLEMAK:
 234         if(record->event.pressed){
 235             persistant_default_layer_set(1UL<<_COLEMAK);
 236             #ifdef AUDIO_ENABLE
 237               PLAY_NOTE_ARRAY(tone_colemak, false, 0);
 238             #endif
 239         }
 240         return false;
 241         break;
 242     case SWCOLE:
 243         if(record->event.pressed){
 244             persistant_default_layer_set(1UL<<_SWCOLE);
 245             #ifdef AUDIO_ENABLE
 246               PLAY_NOTE_ARRAY(tone_swcole, false, 0);
 247             #endif
 248         }
 249         return false;
 250         break;
 251     case RAISE:
 252         if(record->event.pressed){
 253             layer_on(_RAISE);
 254             update_tri_layer(_LOWER, _RAISE, _ADJUST);
 255         } else {
 256             layer_off(_RAISE);
 257             update_tri_layer(_LOWER, _RAISE, _ADJUST);
 258         }
 259         return false;
 260         break;
 261     case LOWER:
 262         if(record->event.pressed){
 263             layer_on(_LOWER);
 264             update_tri_layer(_LOWER, _RAISE, _ADJUST);
 265         } else {
 266             layer_off(_LOWER);
 267             update_tri_layer(_LOWER, _RAISE, _ADJUST);
 268         }
 269         return false;
 270         break;
 271     case SHFT_CAP:
 272         if(record->event.pressed){
 273             key_timer = timer_read();               // if the key is being pressed, we start the timer.
 274             register_code(KC_LSHIFT);
 275         } else {                                    // this means the key was just released (tap or "held down")
 276             if(timer_elapsed(key_timer) < 152){     // Time in ms, the threshold we pick for counting something as a tap.
 277                 tap(KC_CAPS);
 278                 if(caps_status == 0){
 279                     caps_status = 1;
 280                     #ifdef AUDIO_ENABLE
 281                         PLAY_NOTE_ARRAY(tone_capslock_on, false, 0);
 282                     #endif
 283                 } else {
 284                     caps_status = 0;
 285                     #ifdef AUDIO_ENABLE
 286                         PLAY_NOTE_ARRAY(tone_capslock_off, false, 0);
 287                     #endif
 288                 }
 289             }
 290             unregister_code(KC_LSHIFT);
 291         }
 292         return false;
 293         break;
 294     case CTRLB:                                     // Control-B on tap (bold)
 295         if(record->event.pressed){
 296             key_timer = timer_read();               // if the key is being pressed, we start the timer.
 297             register_code(KC_LCTL);
 298         } else {                                    // this means the key was just released (tap or "held down")
 299             if (timer_elapsed(key_timer) < 152) {   // Time in ms, the threshold we pick for counting something as a tap.
 300                 tap(KC_B);
 301                 #ifdef AUDIO_ENABLE
 302                     PLAY_NOTE_ARRAY(tone_ctrl_mod, false, 0);
 303                 #endif
 304                 #ifdef BACKLIGHT_BREATHING
 305                     breathing_speed_set(2);
 306                     breathing_pulse();
 307                 #endif
 308             }
 309             unregister_code(KC_LCTL);
 310         }
 311         return false;
 312         break;
 313     case CPYPST:                                    // One key copy/paste
 314         if(record->event.pressed){
 315             key_timer = timer_read();
 316         } else {
 317             if (timer_elapsed(key_timer) > 152) {   // Hold, copy
 318                 register_code(KC_LCTL);
 319                 tap(KC_C);
 320                 unregister_code(KC_LCTL);
 321                 #ifdef AUDIO_ENABLE
 322                     PLAY_NOTE_ARRAY(tone_copy, false, 0);
 323                 #endif
 324             } else {                                // Tap, paste
 325                 register_code(KC_LCTL);
 326                 tap(KC_V);
 327                 unregister_code(KC_LCTL);
 328                 #ifdef AUDIO_ENABLE
 329                     PLAY_NOTE_ARRAY(tone_paste, false, 0);
 330                 #endif
 331             }
 332         }
 333         return false;
 334         break;
 335     #ifdef UNICODE_ENABLE
 336     case UNIWIN:
 337         if(record->event.pressed){
 338             set_unicode_input_mode(UC_WIN);
 339             #ifdef AUDIO_ENABLE
 340               PLAY_NOTE_ARRAY(uniwin, false, 0);
 341             #endif
 342         }
 343         return false;
 344         break;
 345     case UNILIN:
 346         if(record->event.pressed){
 347             set_unicode_input_mode(UC_LNX);
 348             #ifdef AUDIO_ENABLE
 349               PLAY_NOTE_ARRAY(unilin, false, 0);
 350             #endif
 351         }
 352         return false;
 353         break;
 354     case DISFACE:       // ಠ_ಠ
 355         if(record->event.pressed){
 356             process_unicode((0x0CA0|QK_UNICODE), record);   // Eye
 357             register_code(KC_RSFT);
 358             tap(KC_MINS);
 359             unregister_code(KC_RSFT);
 360             process_unicode((0x0CA0|QK_UNICODE), record);   // Eye
 361         }
 362         return false;
 363         break;
 364     case TFLIP:         // (╯°□°)╯ ︵ ┻━┻
 365         if(record->event.pressed){
 366             register_code(KC_RSFT);
 367             tap(KC_9);
 368             unregister_code(KC_RSFT);
 369             process_unicode((0x256F|QK_UNICODE), record);   // Arm
 370             process_unicode((0x00B0|QK_UNICODE), record);   // Eye
 371             process_unicode((0x25A1|QK_UNICODE), record);   // Mouth
 372             process_unicode((0x00B0|QK_UNICODE), record);   // Eye
 373             register_code(KC_RSFT);
 374             tap(KC_0);
 375             unregister_code(KC_RSFT);
 376             process_unicode((0x256F|QK_UNICODE), record);   // Arm
 377             tap(KC_SPC);
 378             process_unicode((0x0361|QK_UNICODE), record);   // Flippy
 379             tap(KC_SPC);
 380             process_unicode((0x253B|QK_UNICODE), record);   // Table
 381             process_unicode((0x2501|QK_UNICODE), record);   // Table
 382             process_unicode((0x253B|QK_UNICODE), record);   // Table
 383         }
 384         return false;
 385         break;
 386     case TPUT:          // ┬──┬ ノ( ゜-゜ノ)
 387         if(record->event.pressed){
 388             process_unicode((0x252C|QK_UNICODE), record);   // Table
 389             process_unicode((0x2500|QK_UNICODE), record);   // Table
 390             process_unicode((0x2500|QK_UNICODE), record);   // Table
 391             process_unicode((0x252C|QK_UNICODE), record);   // Table
 392             tap(KC_SPC);
 393             process_unicode((0x30CE|QK_UNICODE), record);   // Arm
 394             register_code(KC_RSFT);
 395             tap(KC_9);
 396             unregister_code(KC_RSFT);
 397             tap(KC_SPC);
 398             process_unicode((0x309C|QK_UNICODE), record);   // Eye
 399             tap(KC_MINS);
 400             process_unicode((0x309C|QK_UNICODE), record);   // Eye
 401             process_unicode((0x30CE|QK_UNICODE), record);   // Arm
 402             register_code(KC_RSFT);
 403             tap(KC_0);
 404             unregister_code(KC_RSFT);
 405         }
 406         return false;
 407         break;
 408     case SHRUG:         // ¯\_(ツ)_/¯
 409         if(record->event.pressed){
 410             process_unicode((0x00AF|QK_UNICODE), record);   // Hand
 411             tap(KC_BSLS);                                   // Arm
 412             register_code(KC_RSFT);
 413             tap(KC_UNDS);                                   // Arm
 414             tap(KC_LPRN);                                   // Head
 415             unregister_code(KC_RSFT);
 416             process_unicode((0x30C4|QK_UNICODE), record);   // Face
 417             register_code(KC_RSFT);
 418             tap(KC_RPRN);                                   // Head
 419             tap(KC_UNDS);                                   // Arm
 420             unregister_code(KC_RSFT);
 421             tap(KC_SLSH);                                   // Arm
 422             process_unicode((0x00AF|QK_UNICODE), record);   // Hand
 423         }
 424         return false;
 425         break;
 426     #endif
 427     case FACE:          // (o_O)
 428         if(record->event.pressed){
 429             register_code(KC_RSFT);
 430             tap(KC_LPRN);
 431             unregister_code(KC_RSFT);
 432             tap(KC_O);
 433             register_code(KC_RSFT);
 434             tap(KC_UNDS);
 435             tap(KC_O);
 436             tap(KC_RPRN);
 437             unregister_code(KC_RSFT);
 438         }
 439         return false;
 440         break;
 441     case RANDIG:
 442         if (record->event.pressed) {
 443             tap_random_base64();
 444         }
 445         return false;
 446         break;
 447   }
 448   return true;
 449 };
 450
 451 void matrix_init_user(void){        // Run once at startup
 452     #ifdef AUDIO_ENABLE
 453         _delay_ms(50); // gets rid of tick
 454         PLAY_NOTE_ARRAY(tone_startup, false, 0);
 455     #endif
 456 }
 457
 458 #ifdef AUDIO_ENABLE
 459 void play_goodbye_tone(void){
 460   PLAY_NOTE_ARRAY(tone_goodbye, false, 0);
 461   _delay_ms(150);
 462 }
 463
 464 void shutdown_user(){
 465     PLAY_NOTE_ARRAY(tone_goodbye, false, 0);
 466     _delay_ms(150);
 467     stop_all_notes();
 468 }
 469
 470 void music_on_user(void){           // Run when the music layer is turned on
 471     PLAY_NOTE_ARRAY(tone_startup, false, 0);
 472 }
 473
 474 void music_off_user(void){          // Run when music is turned off
 475         PLAY_NOTE_ARRAY(tone_goodbye, false, 0);
 476 }
 477 #endif
 478
 479 #endif