/* Copyright 2020 Christopher Courtney, aka Drashna Jael're (@drashna) <drashna@live.com> * * 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 "drashna.h" userspace_config_t userspace_config; bool mod_key_press_timer(uint16_t code, uint16_t mod_code, bool pressed) { static uint16_t this_timer; if (pressed) { this_timer = timer_read(); } else { if (timer_elapsed(this_timer) < TAPPING_TERM) { tap_code(code); } else { register_code(mod_code); tap_code(code); unregister_code(mod_code); } } return false; } bool mod_key_press(uint16_t code, uint16_t mod_code, bool pressed, uint16_t this_timer) { if (pressed) { this_timer = timer_read(); } else { if (timer_elapsed(this_timer) < TAPPING_TERM) { tap_code(code); } else { register_code(mod_code); tap_code(code); unregister_code(mod_code); } } return false; } __attribute__((weak)) void keyboard_pre_init_keymap(void) {} void keyboard_pre_init_user(void) { userspace_config.raw = eeconfig_read_user(); keyboard_pre_init_keymap(); } // Add reconfigurable functions here, for keymap customization // This allows for a global, userspace functions, and continued // customization of the keymap. Use _keymap instead of _user // functions in the keymaps // Call user matrix init, set default RGB colors and then // call the keymap's init function __attribute__((weak)) void matrix_init_keymap(void) {} __attribute__((weak)) void matrix_init_secret(void) {} void matrix_init_user(void) { #if defined(BOOTLOADER_CATERINA) && defined(__AVR__) DDRD &= ~(1 << 5); PORTD &= ~(1 << 5); DDRB &= ~(1 << 0); PORTB &= ~(1 << 0); #endif matrix_init_secret(); matrix_init_keymap(); } __attribute__((weak)) void keyboard_post_init_keymap(void) {} void keyboard_post_init_user(void) { #if defined(RGBLIGHT_ENABLE) keyboard_post_init_rgb_light(); #endif #if defined(RGB_MATRIX_ENABLE) keyboard_post_init_rgb_matrix(); #endif #if defined(SPLIT_KEYBOARD) && defined(SPLIT_TRANSACTION_IDS_USER) keyboard_post_init_transport_sync(); #endif keyboard_post_init_keymap(); } #ifdef RGB_MATRIX_ENABLE void rgb_matrix_update_pwm_buffers(void); #endif __attribute__((weak)) void shutdown_keymap(void) {} void shutdown_user(void) { #ifdef RGBLIGHT_ENABLE rgblight_enable_noeeprom(); rgblight_mode_noeeprom(1); rgblight_setrgb_red(); #endif // RGBLIGHT_ENABLE #ifdef RGB_MATRIX_ENABLE rgb_matrix_set_color_all(0xFF, 0x00, 0x00); rgb_matrix_update_pwm_buffers(); #endif // RGB_MATRIX_ENABLE #ifdef OLED_ENABLE oled_off(); #endif shutdown_keymap(); } __attribute__((weak)) void suspend_power_down_keymap(void) {} void suspend_power_down_user(void) { #ifdef OLED_ENABLE oled_off(); #endif suspend_power_down_keymap(); } __attribute__((weak)) void suspend_wakeup_init_keymap(void) {} void suspend_wakeup_init_user(void) { if (layer_state_is(_GAMEPAD)) { layer_off(_GAMEPAD); } if (layer_state_is(_DIABLO)) { layer_off(_DIABLO); } suspend_wakeup_init_keymap(); } // No global matrix scan code, so just run keymap's matrix // scan function __attribute__((weak)) void matrix_scan_keymap(void) {} __attribute__((weak)) void matrix_scan_secret(void) {} void matrix_scan_user(void) { static bool has_ran_yet; if (!has_ran_yet) { has_ran_yet = true; startup_user(); } #ifdef TAP_DANCE_ENABLE // Run Diablo 3 macro checking code. run_diablo_macro_check(); #endif // TAP_DANCE_ENABLE #if defined(RGBLIGHT_ENABLE) matrix_scan_rgb_light(); #endif // RGBLIGHT_ENABLE #if defined(RGB_MATRIX_ENABLE) matrix_scan_rgb_matrix(); #endif matrix_scan_secret(); matrix_scan_keymap(); } #ifdef AUDIO_ENABLE float doom_song[][2] = SONG(E1M1_DOOM); #endif // on layer change, no matter where the change was initiated // Then runs keymap's layer change check __attribute__((weak)) layer_state_t layer_state_set_keymap(layer_state_t state) { return state; } layer_state_t layer_state_set_user(layer_state_t state) { if (!is_keyboard_master()) { return state; } state = update_tri_layer_state(state, _RAISE, _LOWER, _ADJUST); #if defined(RGBLIGHT_ENABLE) state = layer_state_set_rgb_light(state); #endif // RGBLIGHT_ENABLE #if defined(AUDIO_ENABLE) && !defined(__arm__) static bool is_gamepad_on = false; if (layer_state_cmp(state, _GAMEPAD) != is_gamepad_on) { is_gamepad_on = layer_state_cmp(state, _GAMEPAD); if (is_gamepad_on) { PLAY_LOOP(doom_song); } else { stop_all_notes(); } } #endif state = layer_state_set_keymap(state); return state; } // Runs state check and changes underglow color and animation __attribute__((weak)) layer_state_t default_layer_state_set_keymap(layer_state_t state) { return state; } layer_state_t default_layer_state_set_user(layer_state_t state) { if (!is_keyboard_master()) { return state; } state = default_layer_state_set_keymap(state); #if 0 # if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) state = default_layer_state_set_rgb(state); # endif // RGBLIGHT_ENABLE #endif return state; } __attribute__((weak)) void led_set_keymap(uint8_t usb_led) {} void led_set_user(uint8_t usb_led) { led_set_keymap(usb_led); } __attribute__((weak)) void eeconfig_init_keymap(void) {} void eeconfig_init_user(void) { userspace_config.raw = 0; userspace_config.rgb_layer_change = true; eeconfig_update_user(userspace_config.raw); eeconfig_init_keymap(); keyboard_init(); } bool hasAllBitsInMask(uint8_t value, uint8_t mask) { value &= 0xF; mask &= 0xF; return (value & mask) == mask; } #ifdef SPLIT_KEYBOARD __attribute__((weak)) void matrix_slave_scan_keymap(void) {} void matrix_slave_scan_user(void) { # if defined(AUDIO_ENABLE) # if !defined(NO_MUSIC_MODE) music_task(); # endif # ifdef AUDIO_INIT_DELAY if (!is_keyboard_master()) { static bool delayed_tasks_run = false; static uint16_t delayed_task_timer = 0; if (!delayed_tasks_run) { if (!delayed_task_timer) { delayed_task_timer = timer_read(); } else if (timer_elapsed(delayed_task_timer) > 300) { audio_startup(); delayed_tasks_run = true; } } } # endif # endif # ifdef SEQUENCER_ENABLE sequencer_task(); # endif # ifdef LED_MATRIX_ENABLE led_matrix_task(); # endif # ifdef HAPTIC_ENABLE haptic_task(); # endif matrix_slave_scan_keymap(); } #endif __attribute__((weak)) uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) { switch (keycode) { default: return TAPPING_TERM; } } __attribute__((weak)) bool get_permissive_hold(uint16_t keycode, keyrecord_t *record) { // Immediately select the hold action when another key is tapped: // return true; // Do not select the hold action when another key is tapped. // return false; switch (keycode) { default: return false; } } __attribute__((weak)) bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { // Immediately select the hold action when another key is pressed. // return true; // Do not select the hold action when another key is pressed. // return false; switch (keycode) { case QK_LAYER_TAP ... QK_LAYER_TAP_MAX: return true; default: return false; } } __attribute__((weak)) bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { // Do not force the mod-tap key press to be handled as a modifier // if any other key was pressed while the mod-tap key is held down. // return true; // Force the mod-tap key press to be handled as a modifier if any // other key was pressed while the mod-tap key is held down. // return false; switch (keycode) { default: return true; } } __attribute__((weak)) bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) { switch (keycode) { default: return false; } } __attribute__((weak)) bool get_retro_tapping(uint16_t keycode, keyrecord_t *record) { switch (keycode) { default: return false; } }