quantum/quantum.c

   1 /* Copyright 2016-2017 Jack Humbert
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  */
  16
  17 #include "quantum.h"
  18
  19 #if !defined(RGBLIGHT_ENABLE) && !defined(RGB_MATRIX_ENABLE)
  20 #    include "rgb.h"
  21 #endif
  22
  23 #ifdef PROTOCOL_LUFA
  24 #    include "outputselect.h"
  25 #endif
  26
  27 #ifdef BACKLIGHT_ENABLE
  28 #    include "backlight.h"
  29     extern backlight_config_t backlight_config;
  30 #endif
  31
  32 #ifdef FAUXCLICKY_ENABLE
  33 #    include "fauxclicky.h"
  34 #endif
  35
  36 #ifdef API_ENABLE
  37 #    include "api.h"
  38 #endif
  39
  40 #ifdef MIDI_ENABLE
  41 #    include "process_midi.h"
  42 #endif
  43
  44 #ifdef VELOCIKEY_ENABLE
  45 #    include "velocikey.h"
  46 #endif
  47
  48 #ifdef HAPTIC_ENABLE
  49 #    include "haptic.h"
  50 #endif
  51
  52 #ifdef ENCODER_ENABLE
  53 #    include "encoder.h"
  54 #endif
  55
  56 #ifdef AUDIO_ENABLE
  57 #    ifndef GOODBYE_SONG
  58 #        define GOODBYE_SONG SONG(GOODBYE_SOUND)
  59 #    endif
  60 #    ifndef AG_NORM_SONG
  61 #        define AG_NORM_SONG SONG(AG_NORM_SOUND)
  62 #    endif
  63 #    ifndef AG_SWAP_SONG
  64 #        define AG_SWAP_SONG SONG(AG_SWAP_SOUND)
  65 #    endif
  66 #    ifndef CG_NORM_SONG
  67 #        define CG_NORM_SONG SONG(AG_NORM_SOUND)
  68 #    endif
  69 #    ifndef CG_SWAP_SONG
  70 #        define CG_SWAP_SONG SONG(AG_SWAP_SOUND)
  71 #    endif
  72 float goodbye_song[][2] = GOODBYE_SONG;
  73 float ag_norm_song[][2] = AG_NORM_SONG;
  74 float ag_swap_song[][2] = AG_SWAP_SONG;
  75 float cg_norm_song[][2] = CG_NORM_SONG;
  76 float cg_swap_song[][2] = CG_SWAP_SONG;
  77 #    ifdef DEFAULT_LAYER_SONGS
  78 float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
  79 #    endif
  80 #endif
  81
  82 static void do_code16(uint16_t code, void (*f)(uint8_t)) {
  83     switch (code) {
  84         case QK_MODS ... QK_MODS_MAX:
  85             break;
  86         default:
  87             return;
  88     }
  89
  90     uint8_t mods_to_send = 0;
  91
  92     if (code & QK_RMODS_MIN) { // Right mod flag is set
  93         if (code & QK_LCTL) mods_to_send |= MOD_BIT(KC_RCTL);
  94         if (code & QK_LSFT) mods_to_send |= MOD_BIT(KC_RSFT);
  95         if (code & QK_LALT) mods_to_send |= MOD_BIT(KC_RALT);
  96         if (code & QK_LGUI) mods_to_send |= MOD_BIT(KC_RGUI);
  97     } else {
  98         if (code & QK_LCTL) mods_to_send |= MOD_BIT(KC_LCTL);
  99         if (code & QK_LSFT) mods_to_send |= MOD_BIT(KC_LSFT);
 100         if (code & QK_LALT) mods_to_send |= MOD_BIT(KC_LALT);
 101         if (code & QK_LGUI) mods_to_send |= MOD_BIT(KC_LGUI);
 102     }
 103
 104     f(mods_to_send);
 105 }
 106
 107 void register_code16(uint16_t code) {
 108     if (IS_MOD(code) || code == KC_NO) {
 109         do_code16(code, register_mods);
 110     } else {
 111         do_code16(code, register_weak_mods);
 112     }
 113     register_code(code);
 114 }
 115
 116 void unregister_code16(uint16_t code) {
 117     unregister_code(code);
 118     if (IS_MOD(code) || code == KC_NO) {
 119         do_code16(code, unregister_mods);
 120     } else {
 121         do_code16(code, unregister_weak_mods);
 122     }
 123 }
 124
 125 void tap_code16(uint16_t code) {
 126     register_code16(code);
 127 #if TAP_CODE_DELAY > 0
 128     wait_ms(TAP_CODE_DELAY);
 129 #endif
 130     unregister_code16(code);
 131 }
 132
 133 __attribute__((weak)) bool process_action_kb(keyrecord_t *record) { return true; }
 134
 135 __attribute__((weak)) bool process_record_kb(uint16_t keycode, keyrecord_t *record) { return process_record_user(keycode, record); }
 136
 137 __attribute__((weak)) bool process_record_user(uint16_t keycode, keyrecord_t *record) { return true; }
 138
 139 void reset_keyboard(void) {
 140     clear_keyboard();
 141 #if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
 142     process_midi_all_notes_off();
 143 #endif
 144 #ifdef AUDIO_ENABLE
 145 #    ifndef NO_MUSIC_MODE
 146     music_all_notes_off();
 147 #    endif
 148     uint16_t timer_start = timer_read();
 149     PLAY_SONG(goodbye_song);
 150     shutdown_user();
 151     while (timer_elapsed(timer_start) < 250) wait_ms(1);
 152     stop_all_notes();
 153 #else
 154     shutdown_user();
 155     wait_ms(250);
 156 #endif
 157 #ifdef HAPTIC_ENABLE
 158     haptic_shutdown();
 159 #endif
 160 // this is also done later in bootloader.c - not sure if it's neccesary here
 161 #ifdef BOOTLOADER_CATERINA
 162     *(uint16_t *)0x0800 = 0x7777;  // these two are a-star-specific
 163 #endif
 164     bootloader_jump();
 165 }
 166
 167 /* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
 168  * Used to ensure that the correct keycode is released if the key is released.
 169  */
 170 static bool grave_esc_was_shifted = false;
 171
 172 /* Convert record into usable keycode via the contained event. */
 173 uint16_t get_record_keycode(keyrecord_t *record) { return get_event_keycode(record->event); }
 174
 175 /* Convert event into usable keycode. Checks the layer cache to ensure that it
 176  * retains the correct keycode after a layer change, if the key is still pressed.
 177  */
 178 uint16_t get_event_keycode(keyevent_t event) {
 179 #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
 180     /* TODO: Use store_or_get_action() or a similar function. */
 181     if (!disable_action_cache) {
 182         uint8_t layer;
 183
 184         if (event.pressed) {
 185             layer = layer_switch_get_layer(event.key);
 186             update_source_layers_cache(event.key, layer);
 187         } else {
 188             layer = read_source_layers_cache(event.key);
 189         }
 190         return keymap_key_to_keycode(layer, event.key);
 191     } else
 192 #endif
 193         return keymap_key_to_keycode(layer_switch_get_layer(event.key), event.key);
 194 }
 195
 196 /* Main keycode processing function. Hands off handling to other functions,
 197  * then processes internal Quantum keycodes, then processes ACTIONs.
 198  */
 199 bool process_record_quantum(keyrecord_t *record) {
 200     uint16_t keycode = get_record_keycode(record);
 201
 202     // This is how you use actions here
 203     // if (keycode == KC_LEAD) {
 204     //   action_t action;
 205     //   action.code = ACTION_DEFAULT_LAYER_SET(0);
 206     //   process_action(record, action);
 207     //   return false;
 208     // }
 209
 210 #ifdef VELOCIKEY_ENABLE
 211     if (velocikey_enabled() && record->event.pressed) {
 212         velocikey_accelerate();
 213     }
 214 #endif
 215
 216 #ifdef TAP_DANCE_ENABLE
 217     preprocess_tap_dance(keycode, record);
 218 #endif
 219
 220     if (!(
 221 #if defined(KEY_LOCK_ENABLE)
 222             // Must run first to be able to mask key_up events.
 223             process_key_lock(&keycode, record) &&
 224 #endif
 225 #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
 226             process_clicky(keycode, record) &&
 227 #endif  // AUDIO_CLICKY
 228 #ifdef HAPTIC_ENABLE
 229             process_haptic(keycode, record) &&
 230 #endif  // HAPTIC_ENABLE
 231 #if defined(RGB_MATRIX_ENABLE)
 232             process_rgb_matrix(keycode, record) &&
 233 #endif
 234             process_record_kb(keycode, record) &&
 235 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
 236             process_midi(keycode, record) &&
 237 #endif
 238 #ifdef AUDIO_ENABLE
 239             process_audio(keycode, record) &&
 240 #endif
 241 #ifdef STENO_ENABLE
 242             process_steno(keycode, record) &&
 243 #endif
 244 #if (defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
 245             process_music(keycode, record) &&
 246 #endif
 247 #ifdef TAP_DANCE_ENABLE
 248             process_tap_dance(keycode, record) &&
 249 #endif
 250 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
 251             process_unicode_common(keycode, record) &&
 252 #endif
 253 #ifdef LEADER_ENABLE
 254             process_leader(keycode, record) &&
 255 #endif
 256 #ifdef COMBO_ENABLE
 257             process_combo(keycode, record) &&
 258 #endif
 259 #ifdef PRINTING_ENABLE
 260             process_printer(keycode, record) &&
 261 #endif
 262 #ifdef AUTO_SHIFT_ENABLE
 263             process_auto_shift(keycode, record) &&
 264 #endif
 265 #ifdef TERMINAL_ENABLE
 266             process_terminal(keycode, record) &&
 267 #endif
 268 #ifdef SPACE_CADET_ENABLE
 269             process_space_cadet(keycode, record) &&
 270 #endif
 271             true)) {
 272         return false;
 273     }
 274
 275     // Shift / paren setup
 276
 277     switch (keycode) {
 278         case RESET:
 279             if (record->event.pressed) {
 280                 reset_keyboard();
 281             }
 282             return false;
 283         case DEBUG:
 284             if (record->event.pressed) {
 285                 debug_enable ^= 1;
 286                 if (debug_enable) {
 287                     print("DEBUG: enabled.\n");
 288                 } else {
 289                     print("DEBUG: disabled.\n");
 290                 }
 291             }
 292             return false;
 293         case EEPROM_RESET:
 294             if (record->event.pressed) {
 295                 eeconfig_init();
 296             }
 297             return false;
 298 #ifdef FAUXCLICKY_ENABLE
 299         case FC_TOG:
 300             if (record->event.pressed) {
 301                 FAUXCLICKY_TOGGLE;
 302             }
 303             return false;
 304         case FC_ON:
 305             if (record->event.pressed) {
 306                 FAUXCLICKY_ON;
 307             }
 308             return false;
 309         case FC_OFF:
 310             if (record->event.pressed) {
 311                 FAUXCLICKY_OFF;
 312             }
 313             return false;
 314 #endif
 315 #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
 316         case RGB_TOG:
 317 // Split keyboards need to trigger on key-up for edge-case issue
 318 #    ifndef SPLIT_KEYBOARD
 319             if (record->event.pressed) {
 320 #    else
 321             if (!record->event.pressed) {
 322 #    endif
 323                 rgblight_toggle();
 324             }
 325             return false;
 326         case RGB_MODE_FORWARD:
 327             if (record->event.pressed) {
 328                 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT));
 329                 if (shifted) {
 330                     rgblight_step_reverse();
 331                 } else {
 332                     rgblight_step();
 333                 }
 334             }
 335             return false;
 336         case RGB_MODE_REVERSE:
 337             if (record->event.pressed) {
 338                 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT));
 339                 if (shifted) {
 340                     rgblight_step();
 341                 } else {
 342                     rgblight_step_reverse();
 343                 }
 344             }
 345             return false;
 346         case RGB_HUI:
 347 // Split keyboards need to trigger on key-up for edge-case issue
 348 #    ifndef SPLIT_KEYBOARD
 349             if (record->event.pressed) {
 350 #    else
 351             if (!record->event.pressed) {
 352 #    endif
 353                 rgblight_increase_hue();
 354             }
 355             return false;
 356         case RGB_HUD:
 357 // Split keyboards need to trigger on key-up for edge-case issue
 358 #    ifndef SPLIT_KEYBOARD
 359             if (record->event.pressed) {
 360 #    else
 361             if (!record->event.pressed) {
 362 #    endif
 363                 rgblight_decrease_hue();
 364             }
 365             return false;
 366         case RGB_SAI:
 367 // Split keyboards need to trigger on key-up for edge-case issue
 368 #    ifndef SPLIT_KEYBOARD
 369             if (record->event.pressed) {
 370 #    else
 371             if (!record->event.pressed) {
 372 #    endif
 373                 rgblight_increase_sat();
 374             }
 375             return false;
 376         case RGB_SAD:
 377 // Split keyboards need to trigger on key-up for edge-case issue
 378 #    ifndef SPLIT_KEYBOARD
 379             if (record->event.pressed) {
 380 #    else
 381             if (!record->event.pressed) {
 382 #    endif
 383                 rgblight_decrease_sat();
 384             }
 385             return false;
 386         case RGB_VAI:
 387 // Split keyboards need to trigger on key-up for edge-case issue
 388 #    ifndef SPLIT_KEYBOARD
 389             if (record->event.pressed) {
 390 #    else
 391             if (!record->event.pressed) {
 392 #    endif
 393                 rgblight_increase_val();
 394             }
 395             return false;
 396         case RGB_VAD:
 397 // Split keyboards need to trigger on key-up for edge-case issue
 398 #    ifndef SPLIT_KEYBOARD
 399             if (record->event.pressed) {
 400 #    else
 401             if (!record->event.pressed) {
 402 #    endif
 403                 rgblight_decrease_val();
 404             }
 405             return false;
 406         case RGB_SPI:
 407             if (record->event.pressed) {
 408                 rgblight_increase_speed();
 409             }
 410             return false;
 411         case RGB_SPD:
 412             if (record->event.pressed) {
 413                 rgblight_decrease_speed();
 414             }
 415             return false;
 416         case RGB_MODE_PLAIN:
 417             if (record->event.pressed) {
 418                 rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
 419             }
 420             return false;
 421         case RGB_MODE_BREATHE:
 422 #    ifdef RGBLIGHT_EFFECT_BREATHING
 423             if (record->event.pressed) {
 424                 if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) {
 425                     rgblight_step();
 426                 } else {
 427                     rgblight_mode(RGBLIGHT_MODE_BREATHING);
 428                 }
 429             }
 430 #    endif
 431             return false;
 432         case RGB_MODE_RAINBOW:
 433 #    ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
 434             if (record->event.pressed) {
 435                 if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) {
 436                     rgblight_step();
 437                 } else {
 438                     rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
 439                 }
 440             }
 441 #    endif
 442             return false;
 443         case RGB_MODE_SWIRL:
 444 #    ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
 445             if (record->event.pressed) {
 446                 if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) {
 447                     rgblight_step();
 448                 } else {
 449                     rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
 450                 }
 451             }
 452 #    endif
 453             return false;
 454         case RGB_MODE_SNAKE:
 455 #    ifdef RGBLIGHT_EFFECT_SNAKE
 456             if (record->event.pressed) {
 457                 if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) {
 458                     rgblight_step();
 459                 } else {
 460                     rgblight_mode(RGBLIGHT_MODE_SNAKE);
 461                 }
 462             }
 463 #    endif
 464             return false;
 465         case RGB_MODE_KNIGHT:
 466 #    ifdef RGBLIGHT_EFFECT_KNIGHT
 467             if (record->event.pressed) {
 468                 if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) {
 469                     rgblight_step();
 470                 } else {
 471                     rgblight_mode(RGBLIGHT_MODE_KNIGHT);
 472                 }
 473             }
 474 #    endif
 475             return false;
 476         case RGB_MODE_XMAS:
 477 #    ifdef RGBLIGHT_EFFECT_CHRISTMAS
 478             if (record->event.pressed) {
 479                 rgblight_mode(RGBLIGHT_MODE_CHRISTMAS);
 480             }
 481 #    endif
 482             return false;
 483         case RGB_MODE_GRADIENT:
 484 #    ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
 485             if (record->event.pressed) {
 486                 if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) {
 487                     rgblight_step();
 488                 } else {
 489                     rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT);
 490                 }
 491             }
 492 #    endif
 493             return false;
 494         case RGB_MODE_RGBTEST:
 495 #    ifdef RGBLIGHT_EFFECT_RGB_TEST
 496             if (record->event.pressed) {
 497                 rgblight_mode(RGBLIGHT_MODE_RGB_TEST);
 498             }
 499 #    endif
 500             return false;
 501 #endif  // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
 502 #ifdef VELOCIKEY_ENABLE
 503         case VLK_TOG:
 504             if (record->event.pressed) {
 505                 velocikey_toggle();
 506             }
 507             return false;
 508 #endif
 509 #ifdef PROTOCOL_LUFA
 510         case OUT_AUTO:
 511             if (record->event.pressed) {
 512                 set_output(OUTPUT_AUTO);
 513             }
 514             return false;
 515         case OUT_USB:
 516             if (record->event.pressed) {
 517                 set_output(OUTPUT_USB);
 518             }
 519             return false;
 520 #    ifdef BLUETOOTH_ENABLE
 521         case OUT_BT:
 522             if (record->event.pressed) {
 523                 set_output(OUTPUT_BLUETOOTH);
 524             }
 525             return false;
 526 #    endif
 527 #endif
 528         case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_ALT_GUI:
 529         case MAGIC_SWAP_LCTL_LGUI ... MAGIC_EE_HANDS_RIGHT:
 530             if (record->event.pressed) {
 531                 // MAGIC actions (BOOTMAGIC without the boot)
 532                 if (!eeconfig_is_enabled()) {
 533                     eeconfig_init();
 534                 }
 535                 /* keymap config */
 536                 keymap_config.raw = eeconfig_read_keymap();
 537                 switch (keycode) {
 538                     case MAGIC_SWAP_CONTROL_CAPSLOCK:
 539                         keymap_config.swap_control_capslock = true;
 540                         break;
 541                     case MAGIC_CAPSLOCK_TO_CONTROL:
 542                         keymap_config.capslock_to_control = true;
 543                         break;
 544                     case MAGIC_SWAP_LALT_LGUI:
 545                         keymap_config.swap_lalt_lgui = true;
 546                         break;
 547                     case MAGIC_SWAP_RALT_RGUI:
 548                         keymap_config.swap_ralt_rgui = true;
 549                         break;
 550                     case MAGIC_SWAP_LCTL_LGUI:
 551                         keymap_config.swap_lctl_lgui = true;
 552                         break;
 553                     case MAGIC_SWAP_RCTL_RGUI:
 554                         keymap_config.swap_rctl_rgui = true;
 555                         break;
 556                     case MAGIC_NO_GUI:
 557                         keymap_config.no_gui = true;
 558                         break;
 559                     case MAGIC_SWAP_GRAVE_ESC:
 560                         keymap_config.swap_grave_esc = true;
 561                         break;
 562                     case MAGIC_SWAP_BACKSLASH_BACKSPACE:
 563                         keymap_config.swap_backslash_backspace = true;
 564                         break;
 565                     case MAGIC_HOST_NKRO:
 566                         clear_keyboard(); // clear first buffer to prevent stuck keys
 567                         keymap_config.nkro = true;
 568                         break;
 569                     case MAGIC_SWAP_ALT_GUI:
 570                         keymap_config.swap_lalt_lgui = keymap_config.swap_ralt_rgui = true;
 571 #ifdef AUDIO_ENABLE
 572                         PLAY_SONG(ag_swap_song);
 573 #endif
 574                         break;
 575                     case MAGIC_SWAP_CTL_GUI:
 576                         keymap_config.swap_lctl_lgui = keymap_config.swap_rctl_rgui = true;
 577 #ifdef AUDIO_ENABLE
 578                         PLAY_SONG(cg_swap_song);
 579 #endif
 580                         break;
 581                     case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
 582                         keymap_config.swap_control_capslock = false;
 583                         break;
 584                     case MAGIC_UNCAPSLOCK_TO_CONTROL:
 585                         keymap_config.capslock_to_control = false;
 586                         break;
 587                     case MAGIC_UNSWAP_LALT_LGUI:
 588                         keymap_config.swap_lalt_lgui = false;
 589                         break;
 590                     case MAGIC_UNSWAP_RALT_RGUI:
 591                         keymap_config.swap_ralt_rgui = false;
 592                         break;
 593                     case MAGIC_UNSWAP_LCTL_LGUI:
 594                         keymap_config.swap_lctl_lgui = false;
 595                         break;
 596                     case MAGIC_UNSWAP_RCTL_RGUI:
 597                         keymap_config.swap_rctl_rgui = false;
 598                         break;
 599                     case MAGIC_UNNO_GUI:
 600                         keymap_config.no_gui = false;
 601                         break;
 602                     case MAGIC_UNSWAP_GRAVE_ESC:
 603                         keymap_config.swap_grave_esc = false;
 604                         break;
 605                     case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
 606                         keymap_config.swap_backslash_backspace = false;
 607                         break;
 608                     case MAGIC_UNHOST_NKRO:
 609                         clear_keyboard(); // clear first buffer to prevent stuck keys
 610                         keymap_config.nkro = false;
 611                         break;
 612                     case MAGIC_UNSWAP_ALT_GUI:
 613                         keymap_config.swap_lalt_lgui = keymap_config.swap_ralt_rgui = false;
 614 #ifdef AUDIO_ENABLE
 615                         PLAY_SONG(ag_norm_song);
 616 #endif
 617                         break;
 618                     case MAGIC_UNSWAP_CTL_GUI:
 619                         keymap_config.swap_lctl_lgui = keymap_config.swap_rctl_rgui = false;
 620 #ifdef AUDIO_ENABLE
 621                         PLAY_SONG(cg_norm_song);
 622 #endif
 623                         break;
 624                     case MAGIC_TOGGLE_ALT_GUI:
 625                         keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui;
 626                         keymap_config.swap_ralt_rgui = keymap_config.swap_lalt_lgui;
 627 #ifdef AUDIO_ENABLE
 628                         if (keymap_config.swap_ralt_rgui) {
 629                             PLAY_SONG(ag_swap_song);
 630                         } else {
 631                             PLAY_SONG(ag_norm_song);
 632                         }
 633 #endif
 634                         break;
 635                     case MAGIC_TOGGLE_CTL_GUI:
 636                         keymap_config.swap_lctl_lgui = !keymap_config.swap_lctl_lgui;
 637                         keymap_config.swap_rctl_rgui = keymap_config.swap_lctl_lgui;
 638 #ifdef AUDIO_ENABLE
 639                         if (keymap_config.swap_rctl_rgui) {
 640                             PLAY_SONG(cg_swap_song);
 641                         } else {
 642                             PLAY_SONG(cg_norm_song);
 643                         }
 644 #endif
 645                         break;
 646                     case MAGIC_TOGGLE_NKRO:
 647                         clear_keyboard(); // clear first buffer to prevent stuck keys
 648                         keymap_config.nkro = !keymap_config.nkro;
 649                         break;
 650                     case MAGIC_EE_HANDS_LEFT:
 651                         eeconfig_update_handedness(true);
 652                         break;
 653                     case MAGIC_EE_HANDS_RIGHT:
 654                         eeconfig_update_handedness(false);
 655                         break;
 656                     default:
 657                         break;
 658                 }
 659                 eeconfig_update_keymap(keymap_config.raw);
 660                 clear_keyboard();  // clear to prevent stuck keys
 661
 662                 return false;
 663             }
 664             break;
 665
 666         case GRAVE_ESC: {
 667             uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT) | MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI)));
 668
 669 #ifdef GRAVE_ESC_ALT_OVERRIDE
 670             // if ALT is pressed, ESC is always sent
 671             // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
 672             if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
 673                 shifted = 0;
 674             }
 675 #endif
 676
 677 #ifdef GRAVE_ESC_CTRL_OVERRIDE
 678             // if CTRL is pressed, ESC is always sent
 679             // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
 680             if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
 681                 shifted = 0;
 682             }
 683 #endif
 684
 685 #ifdef GRAVE_ESC_GUI_OVERRIDE
 686             // if GUI is pressed, ESC is always sent
 687             if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
 688                 shifted = 0;
 689             }
 690 #endif
 691
 692 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
 693             // if SHIFT is pressed, ESC is always sent
 694             if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
 695                 shifted = 0;
 696             }
 697 #endif
 698
 699             if (record->event.pressed) {
 700                 grave_esc_was_shifted = shifted;
 701                 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
 702             } else {
 703                 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
 704             }
 705
 706             send_keyboard_report();
 707             return false;
 708         }
 709
 710 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
 711         case BL_BRTG: {
 712             if (record->event.pressed) {
 713                 backlight_toggle_breathing();
 714             }
 715             return false;
 716         }
 717 #endif
 718     }
 719
 720     return process_action_kb(record);
 721 }
 722
 723 __attribute__((weak)) const bool ascii_to_shift_lut[128] PROGMEM = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 724
 725                                                                     0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0};
 726
 727 __attribute__((weak)) const bool ascii_to_altgr_lut[128] PROGMEM = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 728
 729                                                                     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 730
 731 __attribute__((weak)) const uint8_t ascii_to_keycode_lut[128] PROGMEM = {// NUL   SOH      STX      ETX      EOT      ENQ      ACK      BEL
 732                                                                          XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
 733                                                                          // BS    TAB      LF       VT       FF       CR       SO       SI
 734                                                                          KC_BSPC, KC_TAB, KC_ENT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
 735                                                                          // DLE   DC1      DC2      DC3      DC4      NAK      SYN      ETB
 736                                                                          XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
 737                                                                          // CAN   EM       SUB      ESC      FS       GS       RS       US
 738                                                                          XXXXXXX, XXXXXXX, XXXXXXX, KC_ESC, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
 739
 740                                                                          //       !        "        #        $        %        &        '
 741                                                                          KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
 742                                                                          // (     )        *        +        ,        -        .        /
 743                                                                          KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 744                                                                          // 0     1        2        3        4        5        6        7
 745                                                                          KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 746                                                                          // 8     9        :        ;        <        =        >        ?
 747                                                                          KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
 748                                                                          // @     A        B        C        D        E        F        G
 749                                                                          KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 750                                                                          // H     I        J        K        L        M        N        O
 751                                                                          KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 752                                                                          // P     Q        R        S        T        U        V        W
 753                                                                          KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 754                                                                          // X     Y        Z        [        \        ]        ^        _
 755                                                                          KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
 756                                                                          // `     a        b        c        d        e        f        g
 757                                                                          KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 758                                                                          // h     i        j        k        l        m        n        o
 759                                                                          KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 760                                                                          // p     q        r        s        t        u        v        w
 761                                                                          KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 762                                                                          // x     y        z        {        |        }        ~        DEL
 763                                                                          KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL};
 764
 765 void send_string(const char *str) { send_string_with_delay(str, 0); }
 766
 767 void send_string_P(const char *str) { send_string_with_delay_P(str, 0); }
 768
 769 void send_string_with_delay(const char *str, uint8_t interval) {
 770     while (1) {
 771         char ascii_code = *str;
 772         if (!ascii_code) break;
 773         if (ascii_code == SS_TAP_CODE) {
 774             // tap
 775             uint8_t keycode = *(++str);
 776             register_code(keycode);
 777             unregister_code(keycode);
 778         } else if (ascii_code == SS_DOWN_CODE) {
 779             // down
 780             uint8_t keycode = *(++str);
 781             register_code(keycode);
 782         } else if (ascii_code == SS_UP_CODE) {
 783             // up
 784             uint8_t keycode = *(++str);
 785             unregister_code(keycode);
 786         } else {
 787             send_char(ascii_code);
 788         }
 789         ++str;
 790         // interval
 791         {
 792             uint8_t ms = interval;
 793             while (ms--) wait_ms(1);
 794         }
 795     }
 796 }
 797
 798 void send_string_with_delay_P(const char *str, uint8_t interval) {
 799     while (1) {
 800         char ascii_code = pgm_read_byte(str);
 801         if (!ascii_code) break;
 802         if (ascii_code == SS_TAP_CODE) {
 803             // tap
 804             uint8_t keycode = pgm_read_byte(++str);
 805             register_code(keycode);
 806             unregister_code(keycode);
 807         } else if (ascii_code == SS_DOWN_CODE) {
 808             // down
 809             uint8_t keycode = pgm_read_byte(++str);
 810             register_code(keycode);
 811         } else if (ascii_code == SS_UP_CODE) {
 812             // up
 813             uint8_t keycode = pgm_read_byte(++str);
 814             unregister_code(keycode);
 815         } else {
 816             send_char(ascii_code);
 817         }
 818         ++str;
 819         // interval
 820         {
 821             uint8_t ms = interval;
 822             while (ms--) wait_ms(1);
 823         }
 824     }
 825 }
 826
 827 void send_char(char ascii_code) {
 828     uint8_t keycode    = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
 829     bool    is_shifted = pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code]);
 830     bool    is_altgred = pgm_read_byte(&ascii_to_altgr_lut[(uint8_t)ascii_code]);
 831
 832     if (is_shifted) {
 833         register_code(KC_LSFT);
 834     }
 835     if (is_altgred) {
 836         register_code(KC_RALT);
 837     }
 838     tap_code(keycode);
 839     if (is_altgred) {
 840         unregister_code(KC_RALT);
 841     }
 842     if (is_shifted) {
 843         unregister_code(KC_LSFT);
 844     }
 845 }
 846
 847 void set_single_persistent_default_layer(uint8_t default_layer) {
 848 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
 849     PLAY_SONG(default_layer_songs[default_layer]);
 850 #endif
 851     eeconfig_update_default_layer(1U << default_layer);
 852     default_layer_set(1U << default_layer);
 853 }
 854
 855 layer_state_t update_tri_layer_state(layer_state_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 856     layer_state_t mask12 = (1UL << layer1) | (1UL << layer2);
 857     layer_state_t mask3  = 1UL << layer3;
 858     return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
 859 }
 860
 861 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) { layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3)); }
 862
 863 void tap_random_base64(void) {
 864 #if defined(__AVR_ATmega32U4__)
 865     uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
 866 #else
 867     uint8_t key = rand() % 64;
 868 #endif
 869     switch (key) {
 870         case 0 ... 25:
 871             register_code(KC_LSFT);
 872             register_code(key + KC_A);
 873             unregister_code(key + KC_A);
 874             unregister_code(KC_LSFT);
 875             break;
 876         case 26 ... 51:
 877             register_code(key - 26 + KC_A);
 878             unregister_code(key - 26 + KC_A);
 879             break;
 880         case 52:
 881             register_code(KC_0);
 882             unregister_code(KC_0);
 883             break;
 884         case 53 ... 61:
 885             register_code(key - 53 + KC_1);
 886             unregister_code(key - 53 + KC_1);
 887             break;
 888         case 62:
 889             register_code(KC_LSFT);
 890             register_code(KC_EQL);
 891             unregister_code(KC_EQL);
 892             unregister_code(KC_LSFT);
 893             break;
 894         case 63:
 895             register_code(KC_SLSH);
 896             unregister_code(KC_SLSH);
 897             break;
 898     }
 899 }
 900
 901 __attribute__((weak)) void bootmagic_lite(void) {
 902     // The lite version of TMK's bootmagic based on Wilba.
 903     // 100% less potential for accidentally making the
 904     // keyboard do stupid things.
 905
 906     // We need multiple scans because debouncing can't be turned off.
 907     matrix_scan();
 908 #if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
 909     wait_ms(DEBOUNCING_DELAY * 2);
 910 #elif defined(DEBOUNCE) && DEBOUNCE > 0
 911     wait_ms(DEBOUNCE * 2);
 912 #else
 913     wait_ms(30);
 914 #endif
 915     matrix_scan();
 916
 917     // If the Esc and space bar are held down on power up,
 918     // reset the EEPROM valid state and jump to bootloader.
 919     // Assumes Esc is at [0,0].
 920     // This isn't very generalized, but we need something that doesn't
 921     // rely on user's keymaps in firmware or EEPROM.
 922     if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
 923         eeconfig_disable();
 924         // Jump to bootloader.
 925         bootloader_jump();
 926     }
 927 }
 928
 929 void matrix_init_quantum() {
 930 #ifdef BOOTMAGIC_LITE
 931     bootmagic_lite();
 932 #endif
 933     if (!eeconfig_is_enabled()) {
 934         eeconfig_init();
 935     }
 936 #ifdef BACKLIGHT_ENABLE
 937 #    ifdef LED_MATRIX_ENABLE
 938     led_matrix_init();
 939 #    else
 940     backlight_init_ports();
 941 #    endif
 942 #endif
 943 #ifdef AUDIO_ENABLE
 944     audio_init();
 945 #endif
 946 #ifdef RGB_MATRIX_ENABLE
 947     rgb_matrix_init();
 948 #endif
 949 #ifdef ENCODER_ENABLE
 950     encoder_init();
 951 #endif
 952 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
 953     unicode_input_mode_init();
 954 #endif
 955 #ifdef HAPTIC_ENABLE
 956     haptic_init();
 957 #endif
 958 #ifdef OUTPUT_AUTO_ENABLE
 959     set_output(OUTPUT_AUTO);
 960 #endif
 961 #ifdef DIP_SWITCH_ENABLE
 962     dip_switch_init();
 963 #endif
 964
 965     matrix_init_kb();
 966 }
 967
 968 void matrix_scan_quantum() {
 969 #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
 970     matrix_scan_music();
 971 #endif
 972
 973 #ifdef TAP_DANCE_ENABLE
 974     matrix_scan_tap_dance();
 975 #endif
 976
 977 #ifdef COMBO_ENABLE
 978     matrix_scan_combo();
 979 #endif
 980
 981 #if defined(BACKLIGHT_ENABLE)
 982 #    if defined(LED_MATRIX_ENABLE)
 983     led_matrix_task();
 984 #    elif defined(BACKLIGHT_PIN)
 985     backlight_task();
 986 #    endif
 987 #endif
 988
 989 #ifdef RGB_MATRIX_ENABLE
 990     rgb_matrix_task();
 991 #endif
 992
 993 #ifdef ENCODER_ENABLE
 994     encoder_read();
 995 #endif
 996
 997 #ifdef HAPTIC_ENABLE
 998     haptic_task();
 999 #endif
1000
1001 #ifdef DIP_SWITCH_ENABLE
1002     dip_switch_read(false);
1003 #endif
1004
1005     matrix_scan_kb();
1006 }
1007
1008 #ifdef HD44780_ENABLED
1009 #    include "hd44780.h"
1010 #endif
1011
1012 // Functions for spitting out values
1013 //
1014
1015 void send_dword(uint32_t number) {  // this might not actually work
1016     uint16_t word = (number >> 16);
1017     send_word(word);
1018     send_word(number & 0xFFFFUL);
1019 }
1020
1021 void send_word(uint16_t number) {
1022     uint8_t byte = number >> 8;
1023     send_byte(byte);
1024     send_byte(number & 0xFF);
1025 }
1026
1027 void send_byte(uint8_t number) {
1028     uint8_t nibble = number >> 4;
1029     send_nibble(nibble);
1030     send_nibble(number & 0xF);
1031 }
1032
1033 void send_nibble(uint8_t number) {
1034     switch (number) {
1035         case 0:
1036             register_code(KC_0);
1037             unregister_code(KC_0);
1038             break;
1039         case 1 ... 9:
1040             register_code(KC_1 + (number - 1));
1041             unregister_code(KC_1 + (number - 1));
1042             break;
1043         case 0xA ... 0xF:
1044             register_code(KC_A + (number - 0xA));
1045             unregister_code(KC_A + (number - 0xA));
1046             break;
1047     }
1048 }
1049
1050 __attribute__((weak)) uint16_t hex_to_keycode(uint8_t hex) {
1051     hex = hex & 0xF;
1052     if (hex == 0x0) {
1053         return KC_0;
1054     } else if (hex < 0xA) {
1055         return KC_1 + (hex - 0x1);
1056     } else {
1057         return KC_A + (hex - 0xA);
1058     }
1059 }
1060
1061 void api_send_unicode(uint32_t unicode) {
1062 #ifdef API_ENABLE
1063     uint8_t chunk[4];
1064     dword_to_bytes(unicode, chunk);
1065     MT_SEND_DATA(DT_UNICODE, chunk, 5);
1066 #endif
1067 }
1068
1069 __attribute__((weak)) void led_set_user(uint8_t usb_led) {}
1070
1071 __attribute__((weak)) void led_set_kb(uint8_t usb_led) { led_set_user(usb_led); }
1072
1073 __attribute__((weak)) void led_init_ports(void) {}
1074
1075 __attribute__((weak)) void led_set(uint8_t usb_led) {
1076 #if defined(BACKLIGHT_CAPS_LOCK) && defined(BACKLIGHT_ENABLE)
1077     // Use backlight as Caps Lock indicator
1078     uint8_t bl_toggle_lvl = 0;
1079
1080     if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK) && !backlight_config.enable) {
1081         // Turning Caps Lock ON and backlight is disabled in config
1082         // Toggling backlight to the brightest level
1083         bl_toggle_lvl = BACKLIGHT_LEVELS;
1084     } else if (IS_LED_OFF(usb_led, USB_LED_CAPS_LOCK) && backlight_config.enable) {
1085         // Turning Caps Lock OFF and backlight is enabled in config
1086         // Toggling backlight and restoring config level
1087         bl_toggle_lvl = backlight_config.level;
1088     }
1089
1090     // Set level without modify backlight_config to keep ability to restore state
1091     backlight_set(bl_toggle_lvl);
1092 #endif
1093
1094     led_set_kb(usb_led);
1095 }
1096
1097 //------------------------------------------------------------------------------
1098 // Override these functions in your keymap file to play different tunes on
1099 // different events such as startup and bootloader jump
1100
1101 __attribute__((weak)) void startup_user() {}
1102
1103 __attribute__((weak)) void shutdown_user() {}
1104
1105 //------------------------------------------------------------------------------