- /* Copyright 2016-2017 Jack Humbert
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
- #include "quantum.h"
-
- #if defined(BACKLIGHT_ENABLE) || defined(LED_MATRIX_ENABLE)
- # include "process_backlight.h"
- #endif
-
- #ifdef BLUETOOTH_ENABLE
- # include "outputselect.h"
- #endif
-
- #ifdef GRAVE_ESC_ENABLE
- # include "process_grave_esc.h"
- #endif
-
- #ifdef HAPTIC_ENABLE
- # include "process_haptic.h"
- #endif
-
- #ifdef JOYSTICK_ENABLE
- # include "process_joystick.h"
- #endif
-
- #ifdef LEADER_ENABLE
- # include "process_leader.h"
- #endif
-
- #ifdef MAGIC_ENABLE
- # include "process_magic.h"
- #endif
-
- #ifdef MIDI_ENABLE
- # include "process_midi.h"
- #endif
-
- #ifdef PROGRAMMABLE_BUTTON_ENABLE
- # include "process_programmable_button.h"
- #endif
-
- #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
- # include "process_rgb.h"
- #endif
-
- #ifdef SECURE_ENABLE
- # include "process_secure.h"
- #endif
-
- #ifdef TRI_LAYER_ENABLE
- # include "process_tri_layer.h"
- #endif
-
- #ifdef UNICODE_COMMON_ENABLE
- # include "process_unicode_common.h"
- #endif
-
- #ifdef AUDIO_ENABLE
- # ifndef GOODBYE_SONG
- # define GOODBYE_SONG SONG(GOODBYE_SOUND)
- # endif
- float goodbye_song[][2] = GOODBYE_SONG;
- # ifdef DEFAULT_LAYER_SONGS
- float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
- # endif
- #endif
-
- uint8_t extract_mod_bits(uint16_t code) {
- switch (code) {
- case QK_MODS ... QK_MODS_MAX:
- break;
- default:
- return 0;
- }
-
- uint8_t mods_to_send = 0;
-
- if (code & QK_RMODS_MIN) { // Right mod flag is set
- if (code & QK_LCTL) mods_to_send |= MOD_BIT(KC_RIGHT_CTRL);
- if (code & QK_LSFT) mods_to_send |= MOD_BIT(KC_RIGHT_SHIFT);
- if (code & QK_LALT) mods_to_send |= MOD_BIT(KC_RIGHT_ALT);
- if (code & QK_LGUI) mods_to_send |= MOD_BIT(KC_RIGHT_GUI);
- } else {
- if (code & QK_LCTL) mods_to_send |= MOD_BIT(KC_LEFT_CTRL);
- if (code & QK_LSFT) mods_to_send |= MOD_BIT(KC_LEFT_SHIFT);
- if (code & QK_LALT) mods_to_send |= MOD_BIT(KC_LEFT_ALT);
- if (code & QK_LGUI) mods_to_send |= MOD_BIT(KC_LEFT_GUI);
- }
-
- return mods_to_send;
- }
-
- void do_code16(uint16_t code, void (*f)(uint8_t)) {
- f(extract_mod_bits(code));
- }
-
- __attribute__((weak)) void register_code16(uint16_t code) {
- if (IS_MODIFIER_KEYCODE(code) || code == KC_NO) {
- do_code16(code, register_mods);
- } else {
- do_code16(code, register_weak_mods);
- }
- register_code(code);
- }
-
- __attribute__((weak)) void unregister_code16(uint16_t code) {
- unregister_code(code);
- if (IS_MODIFIER_KEYCODE(code) || code == KC_NO) {
- do_code16(code, unregister_mods);
- } else {
- do_code16(code, unregister_weak_mods);
- }
- }
-
- /** \brief Tap a keycode with a delay.
- *
- * \param code The modded keycode to tap.
- * \param delay The amount of time in milliseconds to leave the keycode registered, before unregistering it.
- */
- __attribute__((weak)) void tap_code16_delay(uint16_t code, uint16_t delay) {
- register_code16(code);
- for (uint16_t i = delay; i > 0; i--) {
- wait_ms(1);
- }
- unregister_code16(code);
- }
-
- /** \brief Tap a keycode with the default delay.
- *
- * \param code The modded keycode to tap. If `code` is `KC_CAPS_LOCK`, the delay will be `TAP_HOLD_CAPS_DELAY`, otherwise `TAP_CODE_DELAY`, if defined.
- */
- __attribute__((weak)) void tap_code16(uint16_t code) {
- tap_code16_delay(code, code == KC_CAPS_LOCK ? TAP_HOLD_CAPS_DELAY : TAP_CODE_DELAY);
- }
-
- __attribute__((weak)) bool pre_process_record_kb(uint16_t keycode, keyrecord_t *record) {
- return pre_process_record_user(keycode, record);
- }
-
- __attribute__((weak)) bool pre_process_record_user(uint16_t keycode, keyrecord_t *record) {
- return true;
- }
-
- __attribute__((weak)) bool process_action_kb(keyrecord_t *record) {
- return true;
- }
-
- __attribute__((weak)) bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
- return process_record_user(keycode, record);
- }
-
- __attribute__((weak)) bool process_record_user(uint16_t keycode, keyrecord_t *record) {
- return true;
- }
-
- __attribute__((weak)) void post_process_record_kb(uint16_t keycode, keyrecord_t *record) {
- post_process_record_user(keycode, record);
- }
-
- __attribute__((weak)) void post_process_record_user(uint16_t keycode, keyrecord_t *record) {}
-
- void shutdown_quantum(bool jump_to_bootloader) {
- clear_keyboard();
- #if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
- process_midi_all_notes_off();
- #endif
- #ifdef AUDIO_ENABLE
- # ifndef NO_MUSIC_MODE
- music_all_notes_off();
- # endif
- uint16_t timer_start = timer_read();
- PLAY_SONG(goodbye_song);
- shutdown_kb(jump_to_bootloader);
- while (timer_elapsed(timer_start) < 250)
- wait_ms(1);
- stop_all_notes();
- #else
- shutdown_kb(jump_to_bootloader);
- wait_ms(250);
- #endif
- #ifdef HAPTIC_ENABLE
- haptic_shutdown();
- #endif
- }
-
- void reset_keyboard(void) {
- shutdown_quantum(true);
- bootloader_jump();
- }
-
- void soft_reset_keyboard(void) {
- shutdown_quantum(false);
- mcu_reset();
- }
-
- /* Convert record into usable keycode via the contained event. */
- uint16_t get_record_keycode(keyrecord_t *record, bool update_layer_cache) {
- #if defined(COMBO_ENABLE) || defined(REPEAT_KEY_ENABLE)
- if (record->keycode) {
- return record->keycode;
- }
- #endif
- return get_event_keycode(record->event, update_layer_cache);
- }
-
- /* Convert event into usable keycode. Checks the layer cache to ensure that it
- * retains the correct keycode after a layer change, if the key is still pressed.
- * "update_layer_cache" is to ensure that it only updates the layer cache when
- * appropriate, otherwise, it will update it and cause layer tap (and other keys)
- * from triggering properly.
- */
- uint16_t get_event_keycode(keyevent_t event, bool update_layer_cache) {
- #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
- /* TODO: Use store_or_get_action() or a similar function. */
- if (!disable_action_cache) {
- uint8_t layer;
-
- if (event.pressed && update_layer_cache) {
- layer = layer_switch_get_layer(event.key);
- update_source_layers_cache(event.key, layer);
- } else {
- layer = read_source_layers_cache(event.key);
- }
- return keymap_key_to_keycode(layer, event.key);
- } else
- #endif
- return keymap_key_to_keycode(layer_switch_get_layer(event.key), event.key);
- }
-
- /* Get keycode, and then process pre tapping functionality */
- bool pre_process_record_quantum(keyrecord_t *record) {
- uint16_t keycode = get_record_keycode(record, true);
- return pre_process_record_kb(keycode, record) &&
- #ifdef COMBO_ENABLE
- process_combo(keycode, record) &&
- #endif
- true;
- }
-
- /* Get keycode, and then call keyboard function */
- void post_process_record_quantum(keyrecord_t *record) {
- uint16_t keycode = get_record_keycode(record, false);
- post_process_record_kb(keycode, record);
- }
-
- /* Core keycode function, hands off handling to other functions,
- then processes internal quantum keycodes, and then processes
- ACTIONs. */
- bool process_record_quantum(keyrecord_t *record) {
- uint16_t keycode = get_record_keycode(record, true);
-
- // This is how you use actions here
- // if (keycode == QK_LEADER) {
- // action_t action;
- // action.code = ACTION_DEFAULT_LAYER_SET(0);
- // process_action(record, action);
- // return false;
- // }
-
- #if defined(SECURE_ENABLE)
- if (!preprocess_secure(keycode, record)) {
- return false;
- }
- #endif
-
- #ifdef TAP_DANCE_ENABLE
- if (preprocess_tap_dance(keycode, record)) {
- // The tap dance might have updated the layer state, therefore the
- // result of the keycode lookup might change.
- keycode = get_record_keycode(record, true);
- }
- #endif
-
- #ifdef RGBLIGHT_ENABLE
- if (record->event.pressed) {
- preprocess_rgblight();
- }
- #endif
-
- #ifdef WPM_ENABLE
- if (record->event.pressed) {
- update_wpm(keycode);
- }
- #endif
-
- if (!(
- #if defined(KEY_LOCK_ENABLE)
- // Must run first to be able to mask key_up events.
- process_key_lock(&keycode, record) &&
- #endif
- #if defined(DYNAMIC_MACRO_ENABLE) && !defined(DYNAMIC_MACRO_USER_CALL)
- // Must run asap to ensure all keypresses are recorded.
- process_dynamic_macro(keycode, record) &&
- #endif
- #ifdef REPEAT_KEY_ENABLE
- process_last_key(keycode, record) && process_repeat_key(keycode, record) &&
- #endif
- #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
- process_clicky(keycode, record) &&
- #endif
- #ifdef HAPTIC_ENABLE
- process_haptic(keycode, record) &&
- #endif
- #if defined(VIA_ENABLE)
- process_record_via(keycode, record) &&
- #endif
- #if defined(POINTING_DEVICE_ENABLE) && defined(POINTING_DEVICE_AUTO_MOUSE_ENABLE)
- process_auto_mouse(keycode, record) &&
- #endif
- process_record_kb(keycode, record) &&
- #if defined(SECURE_ENABLE)
- process_secure(keycode, record) &&
- #endif
- #if defined(SEQUENCER_ENABLE)
- process_sequencer(keycode, record) &&
- #endif
- #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
- process_midi(keycode, record) &&
- #endif
- #ifdef AUDIO_ENABLE
- process_audio(keycode, record) &&
- #endif
- #if defined(BACKLIGHT_ENABLE) || defined(LED_MATRIX_ENABLE)
- process_backlight(keycode, record) &&
- #endif
- #ifdef STENO_ENABLE
- process_steno(keycode, record) &&
- #endif
- #if (defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
- process_music(keycode, record) &&
- #endif
- #ifdef CAPS_WORD_ENABLE
- process_caps_word(keycode, record) &&
- #endif
- #ifdef KEY_OVERRIDE_ENABLE
- process_key_override(keycode, record) &&
- #endif
- #ifdef TAP_DANCE_ENABLE
- process_tap_dance(keycode, record) &&
- #endif
- #if defined(UNICODE_COMMON_ENABLE)
- process_unicode_common(keycode, record) &&
- #endif
- #ifdef LEADER_ENABLE
- process_leader(keycode, record) &&
- #endif
- #ifdef AUTO_SHIFT_ENABLE
- process_auto_shift(keycode, record) &&
- #endif
- #ifdef DYNAMIC_TAPPING_TERM_ENABLE
- process_dynamic_tapping_term(keycode, record) &&
- #endif
- #ifdef SPACE_CADET_ENABLE
- process_space_cadet(keycode, record) &&
- #endif
- #ifdef MAGIC_ENABLE
- process_magic(keycode, record) &&
- #endif
- #ifdef GRAVE_ESC_ENABLE
- process_grave_esc(keycode, record) &&
- #endif
- #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
- process_rgb(keycode, record) &&
- #endif
- #ifdef JOYSTICK_ENABLE
- process_joystick(keycode, record) &&
- #endif
- #ifdef PROGRAMMABLE_BUTTON_ENABLE
- process_programmable_button(keycode, record) &&
- #endif
- #ifdef AUTOCORRECT_ENABLE
- process_autocorrect(keycode, record) &&
- #endif
- #ifdef TRI_LAYER_ENABLE
- process_tri_layer(keycode, record) &&
- #endif
- true)) {
- return false;
- }
-
- if (record->event.pressed) {
- switch (keycode) {
- #ifndef NO_RESET
- case QK_BOOTLOADER:
- reset_keyboard();
- return false;
- case QK_REBOOT:
- soft_reset_keyboard();
- return false;
- #endif
- #ifndef NO_DEBUG
- case QK_DEBUG_TOGGLE:
- debug_enable ^= 1;
- if (debug_enable) {
- print("DEBUG: enabled.\n");
- } else {
- print("DEBUG: disabled.\n");
- }
- #endif
- return false;
- case QK_CLEAR_EEPROM:
- #ifdef NO_RESET
- eeconfig_init();
- #else
- eeconfig_disable();
- soft_reset_keyboard();
- #endif
- return false;
- #ifdef VELOCIKEY_ENABLE
- case QK_VELOCIKEY_TOGGLE:
- velocikey_toggle();
- return false;
- #endif
- #ifdef BLUETOOTH_ENABLE
- case QK_OUTPUT_AUTO:
- set_output(OUTPUT_AUTO);
- return false;
- case QK_OUTPUT_USB:
- set_output(OUTPUT_USB);
- return false;
- case QK_OUTPUT_BLUETOOTH:
- set_output(OUTPUT_BLUETOOTH);
- return false;
- #endif
- #ifndef NO_ACTION_ONESHOT
- case QK_ONE_SHOT_TOGGLE:
- oneshot_toggle();
- break;
- case QK_ONE_SHOT_ON:
- oneshot_enable();
- break;
- case QK_ONE_SHOT_OFF:
- oneshot_disable();
- break;
- #endif
- #ifdef ENABLE_COMPILE_KEYCODE
- case QK_MAKE: // Compiles the firmware, and adds the flash command based on keyboard bootloader
- {
- # ifdef NO_ACTION_ONESHOT
- const uint8_t temp_mod = mod_config(get_mods());
- # else
- const uint8_t temp_mod = mod_config(get_mods() | get_oneshot_mods());
- clear_oneshot_mods();
- # endif
- clear_mods();
-
- SEND_STRING_DELAY("qmk", TAP_CODE_DELAY);
- if (temp_mod & MOD_MASK_SHIFT) { // if shift is held, flash rather than compile
- SEND_STRING_DELAY(" flash ", TAP_CODE_DELAY);
- } else {
- SEND_STRING_DELAY(" compile ", TAP_CODE_DELAY);
- }
- # if defined(CONVERTER_ENABLED)
- SEND_STRING_DELAY("-kb " QMK_KEYBOARD " -km " QMK_KEYMAP " -e CONVERT_TO=" CONVERTER_TARGET SS_TAP(X_ENTER), TAP_CODE_DELAY);
- # else
- SEND_STRING_DELAY("-kb " QMK_KEYBOARD " -km " QMK_KEYMAP SS_TAP(X_ENTER), TAP_CODE_DELAY);
- # endif
- if (temp_mod & MOD_MASK_SHIFT && temp_mod & MOD_MASK_CTRL) {
- reset_keyboard();
- }
- }
- #endif
- }
- }
-
- return process_action_kb(record);
- }
-
- void set_single_persistent_default_layer(uint8_t default_layer) {
- #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
- PLAY_SONG(default_layer_songs[default_layer]);
- #endif
- eeconfig_update_default_layer((layer_state_t)1 << default_layer);
- default_layer_set((layer_state_t)1 << default_layer);
- }
-
- //------------------------------------------------------------------------------
- // Override these functions in your keymap file to play different tunes on
- // different events such as startup and bootloader jump
-
- __attribute__((weak)) bool shutdown_user(bool jump_to_bootloader) {
- return true;
- }
-
- __attribute__((weak)) bool shutdown_kb(bool jump_to_bootloader) {
- if (!shutdown_user(jump_to_bootloader)) {
- return false;
- }
- return true;
- }
-
- void suspend_power_down_quantum(void) {
- suspend_power_down_kb();
- #ifndef NO_SUSPEND_POWER_DOWN
- // Turn off backlight
- # ifdef BACKLIGHT_ENABLE
- backlight_level_noeeprom(0);
- # endif
-
- # ifdef LED_MATRIX_ENABLE
- led_matrix_task();
- # endif
- # ifdef RGB_MATRIX_ENABLE
- rgb_matrix_task();
- # endif
-
- // Turn off LED indicators
- led_suspend();
-
- // Turn off audio
- # ifdef AUDIO_ENABLE
- stop_all_notes();
- # endif
-
- // Turn off underglow
- # if defined(RGBLIGHT_SLEEP) && defined(RGBLIGHT_ENABLE)
- rgblight_suspend();
- # endif
-
- # if defined(LED_MATRIX_ENABLE)
- led_matrix_set_suspend_state(true);
- # endif
- # if defined(RGB_MATRIX_ENABLE)
- rgb_matrix_set_suspend_state(true);
- # endif
-
- # ifdef OLED_ENABLE
- oled_off();
- # endif
- # ifdef ST7565_ENABLE
- st7565_off();
- # endif
- # if defined(POINTING_DEVICE_ENABLE)
- // run to ensure scanning occurs while suspended
- pointing_device_task();
- # endif
- #endif
- }
-
- __attribute__((weak)) void suspend_wakeup_init_quantum(void) {
- // Turn on backlight
- #ifdef BACKLIGHT_ENABLE
- backlight_init();
- #endif
-
- // Restore LED indicators
- led_wakeup();
-
- // Wake up underglow
- #if defined(RGBLIGHT_SLEEP) && defined(RGBLIGHT_ENABLE)
- rgblight_wakeup();
- #endif
-
- #if defined(LED_MATRIX_ENABLE)
- led_matrix_set_suspend_state(false);
- #endif
- #if defined(RGB_MATRIX_ENABLE)
- rgb_matrix_set_suspend_state(false);
- #endif
- suspend_wakeup_init_kb();
- }
-
- /** \brief converts unsigned integers into char arrays
- *
- * Takes an unsigned integer and converts that value into an equivalent char array
- * A padding character may be specified, ' ' for leading spaces, '0' for leading zeros.
- */
-
- const char *get_numeric_str(char *buf, size_t buf_len, uint32_t curr_num, char curr_pad) {
- buf[buf_len - 1] = '\0';
- for (size_t i = 0; i < buf_len - 1; ++i) {
- char c = '0' + curr_num % 10;
- buf[buf_len - 2 - i] = (c == '0' && i == 0) ? '0' : (curr_num > 0 ? c : curr_pad);
- curr_num /= 10;
- }
- return buf;
- }
-
- /** \brief converts uint8_t into char array
- *
- * Takes an uint8_t, and uses an internal static buffer to render that value into a char array
- * A padding character may be specified, ' ' for leading spaces, '0' for leading zeros.
- *
- * NOTE: Subsequent invocations will reuse the same static buffer and overwrite the previous
- * contents. Use the result immediately, instead of caching it.
- */
- const char *get_u8_str(uint8_t curr_num, char curr_pad) {
- static char buf[4] = {0};
- static uint8_t last_num = 0xFF;
- static char last_pad = '\0';
- if (last_num == curr_num && last_pad == curr_pad) {
- return buf;
- }
- last_num = curr_num;
- last_pad = curr_pad;
- return get_numeric_str(buf, sizeof(buf), curr_num, curr_pad);
- }
-
- /** \brief converts uint16_t into char array
- *
- * Takes an uint16_t, and uses an internal static buffer to render that value into a char array
- * A padding character may be specified, ' ' for leading spaces, '0' for leading zeros.
- *
- * NOTE: Subsequent invocations will reuse the same static buffer and overwrite the previous
- * contents. Use the result immediately, instead of caching it.
- */
- const char *get_u16_str(uint16_t curr_num, char curr_pad) {
- static char buf[6] = {0};
- static uint16_t last_num = 0xFF;
- static char last_pad = '\0';
- if (last_num == curr_num && last_pad == curr_pad) {
- return buf;
- }
- last_num = curr_num;
- last_pad = curr_pad;
- return get_numeric_str(buf, sizeof(buf), curr_num, curr_pad);
- }
-
- #if defined(SECURE_ENABLE)
- void secure_hook_quantum(secure_status_t secure_status) {
- // If keys are being held when this is triggered, they may not be released properly
- // this can result in stuck keys, mods and layers. To prevent that, manually
- // clear these, when it is triggered.
-
- if (secure_status == SECURE_PENDING) {
- clear_keyboard();
- layer_clear();
- }
- }
- #endif
|