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