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