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