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(DYNAMIC_MACRO_ENABLE) && !defined(DYNAMIC_MACRO_USER_CALL)
 226             // Must run asap to ensure all keypresses are recorded.
 227             process_dynamic_macro(keycode, record) &&
 228 #endif
 229 #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
 230             process_clicky(keycode, record) &&
 231 #endif  // AUDIO_CLICKY
 232 #ifdef HAPTIC_ENABLE
 233             process_haptic(keycode, record) &&
 234 #endif  // HAPTIC_ENABLE
 235 #if defined(RGB_MATRIX_ENABLE)
 236             process_rgb_matrix(keycode, record) &&
 237 #endif
 238             process_record_kb(keycode, record) &&
 239 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
 240             process_midi(keycode, record) &&
 241 #endif
 242 #ifdef AUDIO_ENABLE
 243             process_audio(keycode, record) &&
 244 #endif
 245 #ifdef STENO_ENABLE
 246             process_steno(keycode, record) &&
 247 #endif
 248 #if (defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
 249             process_music(keycode, record) &&
 250 #endif
 251 #ifdef TAP_DANCE_ENABLE
 252             process_tap_dance(keycode, record) &&
 253 #endif
 254 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
 255             process_unicode_common(keycode, record) &&
 256 #endif
 257 #ifdef LEADER_ENABLE
 258             process_leader(keycode, record) &&
 259 #endif
 260 #ifdef COMBO_ENABLE
 261             process_combo(keycode, record) &&
 262 #endif
 263 #ifdef PRINTING_ENABLE
 264             process_printer(keycode, record) &&
 265 #endif
 266 #ifdef AUTO_SHIFT_ENABLE
 267             process_auto_shift(keycode, record) &&
 268 #endif
 269 #ifdef TERMINAL_ENABLE
 270             process_terminal(keycode, record) &&
 271 #endif
 272 #ifdef SPACE_CADET_ENABLE
 273             process_space_cadet(keycode, record) &&
 274 #endif
 275             true)) {
 276         return false;
 277     }
 278
 279     // Shift / paren setup
 280
 281     switch (keycode) {
 282         case RESET:
 283             if (record->event.pressed) {
 284                 reset_keyboard();
 285             }
 286             return false;
 287         case DEBUG:
 288             if (record->event.pressed) {
 289                 debug_enable ^= 1;
 290                 if (debug_enable) {
 291                     print("DEBUG: enabled.\n");
 292                 } else {
 293                     print("DEBUG: disabled.\n");
 294                 }
 295             }
 296             return false;
 297         case EEPROM_RESET:
 298             if (record->event.pressed) {
 299                 eeconfig_init();
 300             }
 301             return false;
 302 #ifdef FAUXCLICKY_ENABLE
 303         case FC_TOG:
 304             if (record->event.pressed) {
 305                 FAUXCLICKY_TOGGLE;
 306             }
 307             return false;
 308         case FC_ON:
 309             if (record->event.pressed) {
 310                 FAUXCLICKY_ON;
 311             }
 312             return false;
 313         case FC_OFF:
 314             if (record->event.pressed) {
 315                 FAUXCLICKY_OFF;
 316             }
 317             return false;
 318 #endif
 319 #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
 320         case RGB_TOG:
 321 // Split keyboards need to trigger on key-up for edge-case issue
 322 #    ifndef SPLIT_KEYBOARD
 323             if (record->event.pressed) {
 324 #    else
 325             if (!record->event.pressed) {
 326 #    endif
 327                 rgblight_toggle();
 328             }
 329             return false;
 330         case RGB_MODE_FORWARD:
 331             if (record->event.pressed) {
 332                 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT));
 333                 if (shifted) {
 334                     rgblight_step_reverse();
 335                 } else {
 336                     rgblight_step();
 337                 }
 338             }
 339             return false;
 340         case RGB_MODE_REVERSE:
 341             if (record->event.pressed) {
 342                 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT));
 343                 if (shifted) {
 344                     rgblight_step();
 345                 } else {
 346                     rgblight_step_reverse();
 347                 }
 348             }
 349             return false;
 350         case RGB_HUI:
 351 // Split keyboards need to trigger on key-up for edge-case issue
 352 #    ifndef SPLIT_KEYBOARD
 353             if (record->event.pressed) {
 354 #    else
 355             if (!record->event.pressed) {
 356 #    endif
 357                 rgblight_increase_hue();
 358             }
 359             return false;
 360         case RGB_HUD:
 361 // Split keyboards need to trigger on key-up for edge-case issue
 362 #    ifndef SPLIT_KEYBOARD
 363             if (record->event.pressed) {
 364 #    else
 365             if (!record->event.pressed) {
 366 #    endif
 367                 rgblight_decrease_hue();
 368             }
 369             return false;
 370         case RGB_SAI:
 371 // Split keyboards need to trigger on key-up for edge-case issue
 372 #    ifndef SPLIT_KEYBOARD
 373             if (record->event.pressed) {
 374 #    else
 375             if (!record->event.pressed) {
 376 #    endif
 377                 rgblight_increase_sat();
 378             }
 379             return false;
 380         case RGB_SAD:
 381 // Split keyboards need to trigger on key-up for edge-case issue
 382 #    ifndef SPLIT_KEYBOARD
 383             if (record->event.pressed) {
 384 #    else
 385             if (!record->event.pressed) {
 386 #    endif
 387                 rgblight_decrease_sat();
 388             }
 389             return false;
 390         case RGB_VAI:
 391 // Split keyboards need to trigger on key-up for edge-case issue
 392 #    ifndef SPLIT_KEYBOARD
 393             if (record->event.pressed) {
 394 #    else
 395             if (!record->event.pressed) {
 396 #    endif
 397                 rgblight_increase_val();
 398             }
 399             return false;
 400         case RGB_VAD:
 401 // Split keyboards need to trigger on key-up for edge-case issue
 402 #    ifndef SPLIT_KEYBOARD
 403             if (record->event.pressed) {
 404 #    else
 405             if (!record->event.pressed) {
 406 #    endif
 407                 rgblight_decrease_val();
 408             }
 409             return false;
 410         case RGB_SPI:
 411             if (record->event.pressed) {
 412                 rgblight_increase_speed();
 413             }
 414             return false;
 415         case RGB_SPD:
 416             if (record->event.pressed) {
 417                 rgblight_decrease_speed();
 418             }
 419             return false;
 420         case RGB_MODE_PLAIN:
 421             if (record->event.pressed) {
 422                 rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
 423             }
 424             return false;
 425         case RGB_MODE_BREATHE:
 426 #    ifdef RGBLIGHT_EFFECT_BREATHING
 427             if (record->event.pressed) {
 428                 if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) {
 429                     rgblight_step();
 430                 } else {
 431                     rgblight_mode(RGBLIGHT_MODE_BREATHING);
 432                 }
 433             }
 434 #    endif
 435             return false;
 436         case RGB_MODE_RAINBOW:
 437 #    ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
 438             if (record->event.pressed) {
 439                 if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) {
 440                     rgblight_step();
 441                 } else {
 442                     rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
 443                 }
 444             }
 445 #    endif
 446             return false;
 447         case RGB_MODE_SWIRL:
 448 #    ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
 449             if (record->event.pressed) {
 450                 if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) {
 451                     rgblight_step();
 452                 } else {
 453                     rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
 454                 }
 455             }
 456 #    endif
 457             return false;
 458         case RGB_MODE_SNAKE:
 459 #    ifdef RGBLIGHT_EFFECT_SNAKE
 460             if (record->event.pressed) {
 461                 if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) {
 462                     rgblight_step();
 463                 } else {
 464                     rgblight_mode(RGBLIGHT_MODE_SNAKE);
 465                 }
 466             }
 467 #    endif
 468             return false;
 469         case RGB_MODE_KNIGHT:
 470 #    ifdef RGBLIGHT_EFFECT_KNIGHT
 471             if (record->event.pressed) {
 472                 if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) {
 473                     rgblight_step();
 474                 } else {
 475                     rgblight_mode(RGBLIGHT_MODE_KNIGHT);
 476                 }
 477             }
 478 #    endif
 479             return false;
 480         case RGB_MODE_XMAS:
 481 #    ifdef RGBLIGHT_EFFECT_CHRISTMAS
 482             if (record->event.pressed) {
 483                 rgblight_mode(RGBLIGHT_MODE_CHRISTMAS);
 484             }
 485 #    endif
 486             return false;
 487         case RGB_MODE_GRADIENT:
 488 #    ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
 489             if (record->event.pressed) {
 490                 if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) {
 491                     rgblight_step();
 492                 } else {
 493                     rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT);
 494                 }
 495             }
 496 #    endif
 497             return false;
 498         case RGB_MODE_RGBTEST:
 499 #    ifdef RGBLIGHT_EFFECT_RGB_TEST
 500             if (record->event.pressed) {
 501                 rgblight_mode(RGBLIGHT_MODE_RGB_TEST);
 502             }
 503 #    endif
 504             return false;
 505 #endif  // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
 506 #ifdef VELOCIKEY_ENABLE
 507         case VLK_TOG:
 508             if (record->event.pressed) {
 509                 velocikey_toggle();
 510             }
 511             return false;
 512 #endif
 513 #ifdef PROTOCOL_LUFA
 514         case OUT_AUTO:
 515             if (record->event.pressed) {
 516                 set_output(OUTPUT_AUTO);
 517             }
 518             return false;
 519         case OUT_USB:
 520             if (record->event.pressed) {
 521                 set_output(OUTPUT_USB);
 522             }
 523             return false;
 524 #    ifdef BLUETOOTH_ENABLE
 525         case OUT_BT:
 526             if (record->event.pressed) {
 527                 set_output(OUTPUT_BLUETOOTH);
 528             }
 529             return false;
 530 #    endif
 531 #endif
 532         case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_ALT_GUI:
 533         case MAGIC_SWAP_LCTL_LGUI ... MAGIC_EE_HANDS_RIGHT:
 534             if (record->event.pressed) {
 535                 // MAGIC actions (BOOTMAGIC without the boot)
 536                 if (!eeconfig_is_enabled()) {
 537                     eeconfig_init();
 538                 }
 539                 /* keymap config */
 540                 keymap_config.raw = eeconfig_read_keymap();
 541                 switch (keycode) {
 542                     case MAGIC_SWAP_CONTROL_CAPSLOCK:
 543                         keymap_config.swap_control_capslock = true;
 544                         break;
 545                     case MAGIC_CAPSLOCK_TO_CONTROL:
 546                         keymap_config.capslock_to_control = true;
 547                         break;
 548                     case MAGIC_SWAP_LALT_LGUI:
 549                         keymap_config.swap_lalt_lgui = true;
 550                         break;
 551                     case MAGIC_SWAP_RALT_RGUI:
 552                         keymap_config.swap_ralt_rgui = true;
 553                         break;
 554                     case MAGIC_SWAP_LCTL_LGUI:
 555                         keymap_config.swap_lctl_lgui = true;
 556                         break;
 557                     case MAGIC_SWAP_RCTL_RGUI:
 558                         keymap_config.swap_rctl_rgui = true;
 559                         break;
 560                     case MAGIC_NO_GUI:
 561                         keymap_config.no_gui = true;
 562                         break;
 563                     case MAGIC_SWAP_GRAVE_ESC:
 564                         keymap_config.swap_grave_esc = true;
 565                         break;
 566                     case MAGIC_SWAP_BACKSLASH_BACKSPACE:
 567                         keymap_config.swap_backslash_backspace = true;
 568                         break;
 569                     case MAGIC_HOST_NKRO:
 570                         clear_keyboard();  // clear first buffer to prevent stuck keys
 571                         keymap_config.nkro = true;
 572                         break;
 573                     case MAGIC_SWAP_ALT_GUI:
 574                         keymap_config.swap_lalt_lgui = keymap_config.swap_ralt_rgui = true;
 575 #ifdef AUDIO_ENABLE
 576                         PLAY_SONG(ag_swap_song);
 577 #endif
 578                         break;
 579                     case MAGIC_SWAP_CTL_GUI:
 580                         keymap_config.swap_lctl_lgui = keymap_config.swap_rctl_rgui = true;
 581 #ifdef AUDIO_ENABLE
 582                         PLAY_SONG(cg_swap_song);
 583 #endif
 584                         break;
 585                     case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
 586                         keymap_config.swap_control_capslock = false;
 587                         break;
 588                     case MAGIC_UNCAPSLOCK_TO_CONTROL:
 589                         keymap_config.capslock_to_control = false;
 590                         break;
 591                     case MAGIC_UNSWAP_LALT_LGUI:
 592                         keymap_config.swap_lalt_lgui = false;
 593                         break;
 594                     case MAGIC_UNSWAP_RALT_RGUI:
 595                         keymap_config.swap_ralt_rgui = false;
 596                         break;
 597                     case MAGIC_UNSWAP_LCTL_LGUI:
 598                         keymap_config.swap_lctl_lgui = false;
 599                         break;
 600                     case MAGIC_UNSWAP_RCTL_RGUI:
 601                         keymap_config.swap_rctl_rgui = false;
 602                         break;
 603                     case MAGIC_UNNO_GUI:
 604                         keymap_config.no_gui = false;
 605                         break;
 606                     case MAGIC_UNSWAP_GRAVE_ESC:
 607                         keymap_config.swap_grave_esc = false;
 608                         break;
 609                     case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
 610                         keymap_config.swap_backslash_backspace = false;
 611                         break;
 612                     case MAGIC_UNHOST_NKRO:
 613                         clear_keyboard();  // clear first buffer to prevent stuck keys
 614                         keymap_config.nkro = false;
 615                         break;
 616                     case MAGIC_UNSWAP_ALT_GUI:
 617                         keymap_config.swap_lalt_lgui = keymap_config.swap_ralt_rgui = false;
 618 #ifdef AUDIO_ENABLE
 619                         PLAY_SONG(ag_norm_song);
 620 #endif
 621                         break;
 622                     case MAGIC_UNSWAP_CTL_GUI:
 623                         keymap_config.swap_lctl_lgui = keymap_config.swap_rctl_rgui = false;
 624 #ifdef AUDIO_ENABLE
 625                         PLAY_SONG(cg_norm_song);
 626 #endif
 627                         break;
 628                     case MAGIC_TOGGLE_ALT_GUI:
 629                         keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui;
 630                         keymap_config.swap_ralt_rgui = keymap_config.swap_lalt_lgui;
 631 #ifdef AUDIO_ENABLE
 632                         if (keymap_config.swap_ralt_rgui) {
 633                             PLAY_SONG(ag_swap_song);
 634                         } else {
 635                             PLAY_SONG(ag_norm_song);
 636                         }
 637 #endif
 638                         break;
 639                     case MAGIC_TOGGLE_CTL_GUI:
 640                         keymap_config.swap_lctl_lgui = !keymap_config.swap_lctl_lgui;
 641                         keymap_config.swap_rctl_rgui = keymap_config.swap_lctl_lgui;
 642 #ifdef AUDIO_ENABLE
 643                         if (keymap_config.swap_rctl_rgui) {
 644                             PLAY_SONG(cg_swap_song);
 645                         } else {
 646                             PLAY_SONG(cg_norm_song);
 647                         }
 648 #endif
 649                         break;
 650                     case MAGIC_TOGGLE_NKRO:
 651                         clear_keyboard();  // clear first buffer to prevent stuck keys
 652                         keymap_config.nkro = !keymap_config.nkro;
 653                         break;
 654                     case MAGIC_EE_HANDS_LEFT:
 655                         eeconfig_update_handedness(true);
 656                         break;
 657                     case MAGIC_EE_HANDS_RIGHT:
 658                         eeconfig_update_handedness(false);
 659                         break;
 660                     default:
 661                         break;
 662                 }
 663                 eeconfig_update_keymap(keymap_config.raw);
 664                 clear_keyboard();  // clear to prevent stuck keys
 665
 666                 return false;
 667             }
 668             break;
 669
 670         case GRAVE_ESC: {
 671             uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT) | MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI)));
 672
 673 #ifdef GRAVE_ESC_ALT_OVERRIDE
 674             // if ALT is pressed, ESC is always sent
 675             // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
 676             if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
 677                 shifted = 0;
 678             }
 679 #endif
 680
 681 #ifdef GRAVE_ESC_CTRL_OVERRIDE
 682             // if CTRL is pressed, ESC is always sent
 683             // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
 684             if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
 685                 shifted = 0;
 686             }
 687 #endif
 688
 689 #ifdef GRAVE_ESC_GUI_OVERRIDE
 690             // if GUI is pressed, ESC is always sent
 691             if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
 692                 shifted = 0;
 693             }
 694 #endif
 695
 696 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
 697             // if SHIFT is pressed, ESC is always sent
 698             if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
 699                 shifted = 0;
 700             }
 701 #endif
 702
 703             if (record->event.pressed) {
 704                 grave_esc_was_shifted = shifted;
 705                 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
 706             } else {
 707                 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
 708             }
 709
 710             send_keyboard_report();
 711             return false;
 712         }
 713
 714 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
 715         case BL_BRTG: {
 716             if (record->event.pressed) {
 717                 backlight_toggle_breathing();
 718             }
 719             return false;
 720         }
 721 #endif
 722     }
 723
 724     return process_action_kb(record);
 725 }
 726
 727 __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,
 728
 729                                                                     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};
 730
 731 __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,
 732
 733                                                                     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};
 734
 735 __attribute__((weak)) const uint8_t ascii_to_keycode_lut[128] PROGMEM = {// NUL   SOH      STX      ETX      EOT      ENQ      ACK      BEL
 736                                                                          XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
 737                                                                          // BS    TAB      LF       VT       FF       CR       SO       SI
 738                                                                          KC_BSPC, KC_TAB, KC_ENT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
 739                                                                          // DLE   DC1      DC2      DC3      DC4      NAK      SYN      ETB
 740                                                                          XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
 741                                                                          // CAN   EM       SUB      ESC      FS       GS       RS       US
 742                                                                          XXXXXXX, XXXXXXX, XXXXXXX, KC_ESC, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
 743
 744                                                                          //       !        "        #        $        %        &        '
 745                                                                          KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
 746                                                                          // (     )        *        +        ,        -        .        /
 747                                                                          KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 748                                                                          // 0     1        2        3        4        5        6        7
 749                                                                          KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 750                                                                          // 8     9        :        ;        <        =        >        ?
 751                                                                          KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
 752                                                                          // @     A        B        C        D        E        F        G
 753                                                                          KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 754                                                                          // H     I        J        K        L        M        N        O
 755                                                                          KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 756                                                                          // P     Q        R        S        T        U        V        W
 757                                                                          KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 758                                                                          // X     Y        Z        [        \        ]        ^        _
 759                                                                          KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
 760                                                                          // `     a        b        c        d        e        f        g
 761                                                                          KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 762                                                                          // h     i        j        k        l        m        n        o
 763                                                                          KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 764                                                                          // p     q        r        s        t        u        v        w
 765                                                                          KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 766                                                                          // x     y        z        {        |        }        ~        DEL
 767                                                                          KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL};
 768
 769 void send_string(const char *str) { send_string_with_delay(str, 0); }
 770
 771 void send_string_P(const char *str) { send_string_with_delay_P(str, 0); }
 772
 773 void send_string_with_delay(const char *str, uint8_t interval) {
 774     while (1) {
 775         char ascii_code = *str;
 776         if (!ascii_code) break;
 777         if (ascii_code == SS_TAP_CODE) {
 778             // tap
 779             uint8_t keycode = *(++str);
 780             register_code(keycode);
 781             unregister_code(keycode);
 782         } else if (ascii_code == SS_DOWN_CODE) {
 783             // down
 784             uint8_t keycode = *(++str);
 785             register_code(keycode);
 786         } else if (ascii_code == SS_UP_CODE) {
 787             // up
 788             uint8_t keycode = *(++str);
 789             unregister_code(keycode);
 790         } else {
 791             send_char(ascii_code);
 792         }
 793         ++str;
 794         // interval
 795         {
 796             uint8_t ms = interval;
 797             while (ms--) wait_ms(1);
 798         }
 799     }
 800 }
 801
 802 void send_string_with_delay_P(const char *str, uint8_t interval) {
 803     while (1) {
 804         char ascii_code = pgm_read_byte(str);
 805         if (!ascii_code) break;
 806         if (ascii_code == SS_TAP_CODE) {
 807             // tap
 808             uint8_t keycode = pgm_read_byte(++str);
 809             register_code(keycode);
 810             unregister_code(keycode);
 811         } else if (ascii_code == SS_DOWN_CODE) {
 812             // down
 813             uint8_t keycode = pgm_read_byte(++str);
 814             register_code(keycode);
 815         } else if (ascii_code == SS_UP_CODE) {
 816             // up
 817             uint8_t keycode = pgm_read_byte(++str);
 818             unregister_code(keycode);
 819         } else {
 820             send_char(ascii_code);
 821         }
 822         ++str;
 823         // interval
 824         {
 825             uint8_t ms = interval;
 826             while (ms--) wait_ms(1);
 827         }
 828     }
 829 }
 830
 831 void send_char(char ascii_code) {
 832     uint8_t keycode    = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
 833     bool    is_shifted = pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code]);
 834     bool    is_altgred = pgm_read_byte(&ascii_to_altgr_lut[(uint8_t)ascii_code]);
 835
 836     if (is_shifted) {
 837         register_code(KC_LSFT);
 838     }
 839     if (is_altgred) {
 840         register_code(KC_RALT);
 841     }
 842     tap_code(keycode);
 843     if (is_altgred) {
 844         unregister_code(KC_RALT);
 845     }
 846     if (is_shifted) {
 847         unregister_code(KC_LSFT);
 848     }
 849 }
 850
 851 void set_single_persistent_default_layer(uint8_t default_layer) {
 852 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
 853     PLAY_SONG(default_layer_songs[default_layer]);
 854 #endif
 855     eeconfig_update_default_layer(1U << default_layer);
 856     default_layer_set(1U << default_layer);
 857 }
 858
 859 layer_state_t update_tri_layer_state(layer_state_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 860     layer_state_t mask12 = (1UL << layer1) | (1UL << layer2);
 861     layer_state_t mask3  = 1UL << layer3;
 862     return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
 863 }
 864
 865 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)); }
 866
 867 void tap_random_base64(void) {
 868 #if defined(__AVR_ATmega32U4__)
 869     uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
 870 #else
 871     uint8_t key = rand() % 64;
 872 #endif
 873     switch (key) {
 874         case 0 ... 25:
 875             register_code(KC_LSFT);
 876             register_code(key + KC_A);
 877             unregister_code(key + KC_A);
 878             unregister_code(KC_LSFT);
 879             break;
 880         case 26 ... 51:
 881             register_code(key - 26 + KC_A);
 882             unregister_code(key - 26 + KC_A);
 883             break;
 884         case 52:
 885             register_code(KC_0);
 886             unregister_code(KC_0);
 887             break;
 888         case 53 ... 61:
 889             register_code(key - 53 + KC_1);
 890             unregister_code(key - 53 + KC_1);
 891             break;
 892         case 62:
 893             register_code(KC_LSFT);
 894             register_code(KC_EQL);
 895             unregister_code(KC_EQL);
 896             unregister_code(KC_LSFT);
 897             break;
 898         case 63:
 899             register_code(KC_SLSH);
 900             unregister_code(KC_SLSH);
 901             break;
 902     }
 903 }
 904
 905 __attribute__((weak)) void bootmagic_lite(void) {
 906     // The lite version of TMK's bootmagic based on Wilba.
 907     // 100% less potential for accidentally making the
 908     // keyboard do stupid things.
 909
 910     // We need multiple scans because debouncing can't be turned off.
 911     matrix_scan();
 912 #if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
 913     wait_ms(DEBOUNCING_DELAY * 2);
 914 #elif defined(DEBOUNCE) && DEBOUNCE > 0
 915     wait_ms(DEBOUNCE * 2);
 916 #else
 917     wait_ms(30);
 918 #endif
 919     matrix_scan();
 920
 921     // If the Esc and space bar are held down on power up,
 922     // reset the EEPROM valid state and jump to bootloader.
 923     // Assumes Esc is at [0,0].
 924     // This isn't very generalized, but we need something that doesn't
 925     // rely on user's keymaps in firmware or EEPROM.
 926     if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
 927         eeconfig_disable();
 928         // Jump to bootloader.
 929         bootloader_jump();
 930     }
 931 }
 932
 933 void matrix_init_quantum() {
 934 #ifdef BOOTMAGIC_LITE
 935     bootmagic_lite();
 936 #endif
 937     if (!eeconfig_is_enabled()) {
 938         eeconfig_init();
 939     }
 940 #ifdef BACKLIGHT_ENABLE
 941 #    ifdef LED_MATRIX_ENABLE
 942     led_matrix_init();
 943 #    else
 944     backlight_init_ports();
 945 #    endif
 946 #endif
 947 #ifdef AUDIO_ENABLE
 948     audio_init();
 949 #endif
 950 #ifdef RGB_MATRIX_ENABLE
 951     rgb_matrix_init();
 952 #endif
 953 #ifdef ENCODER_ENABLE
 954     encoder_init();
 955 #endif
 956 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
 957     unicode_input_mode_init();
 958 #endif
 959 #ifdef HAPTIC_ENABLE
 960     haptic_init();
 961 #endif
 962 #ifdef OUTPUT_AUTO_ENABLE
 963     set_output(OUTPUT_AUTO);
 964 #endif
 965 #ifdef DIP_SWITCH_ENABLE
 966     dip_switch_init();
 967 #endif
 968
 969     matrix_init_kb();
 970 }
 971
 972 void matrix_scan_quantum() {
 973 #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
 974     matrix_scan_music();
 975 #endif
 976
 977 #ifdef TAP_DANCE_ENABLE
 978     matrix_scan_tap_dance();
 979 #endif
 980
 981 #ifdef COMBO_ENABLE
 982     matrix_scan_combo();
 983 #endif
 984
 985 #if defined(BACKLIGHT_ENABLE)
 986 #    if defined(LED_MATRIX_ENABLE)
 987     led_matrix_task();
 988 #    elif defined(BACKLIGHT_PIN) || defined(BACKLIGHT_PINS)
 989     backlight_task();
 990 #    endif
 991 #endif
 992
 993 #ifdef RGB_MATRIX_ENABLE
 994     rgb_matrix_task();
 995 #endif
 996
 997 #ifdef ENCODER_ENABLE
 998     encoder_read();
 999 #endif
1000
1001 #ifdef HAPTIC_ENABLE
1002     haptic_task();
1003 #endif
1004
1005 #ifdef DIP_SWITCH_ENABLE
1006     dip_switch_read(false);
1007 #endif
1008
1009     matrix_scan_kb();
1010 }
1011
1012 #ifdef HD44780_ENABLED
1013 #    include "hd44780.h"
1014 #endif
1015
1016 // Functions for spitting out values
1017 //
1018
1019 void send_dword(uint32_t number) {  // this might not actually work
1020     uint16_t word = (number >> 16);
1021     send_word(word);
1022     send_word(number & 0xFFFFUL);
1023 }
1024
1025 void send_word(uint16_t number) {
1026     uint8_t byte = number >> 8;
1027     send_byte(byte);
1028     send_byte(number & 0xFF);
1029 }
1030
1031 void send_byte(uint8_t number) {
1032     uint8_t nibble = number >> 4;
1033     send_nibble(nibble);
1034     send_nibble(number & 0xF);
1035 }
1036
1037 void send_nibble(uint8_t number) {
1038     switch (number) {
1039         case 0:
1040             register_code(KC_0);
1041             unregister_code(KC_0);
1042             break;
1043         case 1 ... 9:
1044             register_code(KC_1 + (number - 1));
1045             unregister_code(KC_1 + (number - 1));
1046             break;
1047         case 0xA ... 0xF:
1048             register_code(KC_A + (number - 0xA));
1049             unregister_code(KC_A + (number - 0xA));
1050             break;
1051     }
1052 }
1053
1054 __attribute__((weak)) uint16_t hex_to_keycode(uint8_t hex) {
1055     hex = hex & 0xF;
1056     if (hex == 0x0) {
1057         return KC_0;
1058     } else if (hex < 0xA) {
1059         return KC_1 + (hex - 0x1);
1060     } else {
1061         return KC_A + (hex - 0xA);
1062     }
1063 }
1064
1065 void api_send_unicode(uint32_t unicode) {
1066 #ifdef API_ENABLE
1067     uint8_t chunk[4];
1068     dword_to_bytes(unicode, chunk);
1069     MT_SEND_DATA(DT_UNICODE, chunk, 5);
1070 #endif
1071 }
1072
1073 __attribute__((weak)) void led_set_user(uint8_t usb_led) {}
1074
1075 __attribute__((weak)) void led_set_kb(uint8_t usb_led) { led_set_user(usb_led); }
1076
1077 __attribute__((weak)) void led_init_ports(void) {}
1078
1079 __attribute__((weak)) void led_set(uint8_t usb_led) {
1080 #if defined(BACKLIGHT_CAPS_LOCK) && defined(BACKLIGHT_ENABLE)
1081     // Use backlight as Caps Lock indicator
1082     uint8_t bl_toggle_lvl = 0;
1083
1084     if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK) && !backlight_config.enable) {
1085         // Turning Caps Lock ON and backlight is disabled in config
1086         // Toggling backlight to the brightest level
1087         bl_toggle_lvl = BACKLIGHT_LEVELS;
1088     } else if (IS_LED_OFF(usb_led, USB_LED_CAPS_LOCK) && backlight_config.enable) {
1089         // Turning Caps Lock OFF and backlight is enabled in config
1090         // Toggling backlight and restoring config level
1091         bl_toggle_lvl = backlight_config.level;
1092     }
1093
1094     // Set level without modify backlight_config to keep ability to restore state
1095     backlight_set(bl_toggle_lvl);
1096 #endif
1097
1098     led_set_kb(usb_led);
1099 }
1100
1101 //------------------------------------------------------------------------------
1102 // Override these functions in your keymap file to play different tunes on
1103 // different events such as startup and bootloader jump
1104
1105 __attribute__((weak)) void startup_user() {}
1106
1107 __attribute__((weak)) void shutdown_user() {}
1108
1109 //------------------------------------------------------------------------------