2017-11-17 11:59:54 -08:00
/*
Copyright 2017 Christopher Courtney <drashna@live.com> @drashna
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/>.
*/
2017-11-06 21:11:08 -08:00
#include "drashna.h"
2018-05-31 22:11:06 -07:00
#include "tap_dances.h"
#include "rgb_stuff.h"
2017-11-06 21:11:08 -08:00
2018-05-02 08:39:46 -07:00
userspace_config_t userspace_config ;
// Helper Functions
2018-05-31 22:11:06 -07:00
// This block is for all of the gaming macros, as they were all doing
// the same thing, but with differring text sent.
bool send_game_macro ( const char * str , keyrecord_t * record , bool override ) {
if ( ! record -> event . pressed || override ) {
2018-08-29 10:42:15 -07:00
uint16_t keycode ;
if ( userspace_config . is_overwatch ) {
keycode = KC_BSPC ;
} else {
keycode = KC_ENTER ;
}
2018-05-31 22:11:06 -07:00
clear_keyboard ();
2018-08-29 10:42:15 -07:00
tap ( keycode );
2018-05-31 22:11:06 -07:00
wait_ms ( 50 );
2018-07-16 18:04:32 -07:00
send_string_with_delay ( str , MACRO_TIMER );
2018-05-31 22:11:06 -07:00
wait_ms ( 50 );
tap ( KC_ENTER );
}
if ( override ) wait_ms ( 3000 );
return false ;
}
2018-07-16 18:04:32 -07:00
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 ){
register_code ( code );
unregister_code ( code );
} else {
register_code ( mod_code );
register_code ( code );
unregister_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 ){
register_code ( code );
unregister_code ( code );
} else {
register_code ( mod_code );
register_code ( code );
unregister_code ( code );
unregister_code ( mod_code );
}
}
return false ;
}
2017-11-17 11:59:54 -08:00
2017-11-10 19:58:53 -08:00
// 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
2017-11-06 21:11:08 -08:00
__attribute__ (( weak ))
void matrix_init_keymap ( void ) {}
2018-07-16 18:04:32 -07:00
__attribute__ (( weak ))
void startup_keymap ( void ) {}
2018-08-29 10:42:15 -07:00
__attribute__ (( weak ))
void shutdown_keymap ( void ) {}
2018-07-16 18:04:32 -07:00
__attribute__ (( weak ))
void suspend_power_down_keymap ( void ) {}
__attribute__ (( weak ))
void suspend_wakeup_init_keymap ( void ) {}
2017-11-06 21:11:08 -08:00
__attribute__ (( weak ))
void matrix_scan_keymap ( void ) {}
__attribute__ (( weak ))
bool process_record_keymap ( uint16_t keycode , keyrecord_t * record ) {
return true ;
}
2017-11-17 11:59:54 -08:00
2018-05-31 22:11:06 -07:00
__attribute__ (( weak ))
bool process_record_secrets ( uint16_t keycode , keyrecord_t * record ) {
return true ;
}
2018-07-16 18:04:32 -07:00
2017-11-10 19:58:53 -08:00
__attribute__ (( weak ))
uint32_t layer_state_set_keymap ( uint32_t state ) {
return state ;
}
2017-11-06 21:11:08 -08:00
2018-07-16 18:04:32 -07:00
__attribute__ (( weak ))
uint32_t default_layer_state_set_keymap ( uint32_t state ) {
return state ;
}
2017-11-17 11:59:54 -08:00
__attribute__ (( weak ))
void led_set_keymap ( uint8_t usb_led ) {}
2017-11-06 21:11:08 -08:00
2018-08-29 10:42:15 -07:00
2017-11-10 19:58:53 -08:00
// Call user matrix init, set default RGB colors and then
// call the keymap's init function
2017-11-06 21:11:08 -08:00
void matrix_init_user ( void ) {
2018-05-15 19:34:34 -07:00
userspace_config . raw = eeprom_read_byte ( EECONFIG_USERSPACE );
2017-11-06 21:11:08 -08:00
2018-05-31 22:11:06 -07:00
#ifdef AUDIO_CLICKY
clicky_enable = userspace_config . clicky_enable ;
#endif
2018-05-15 19:34:34 -07:00
#ifdef BOOTLOADER_CATERINA
DDRD &= ~ ( 1 << 5 );
PORTD &= ~ ( 1 << 5 );
2018-03-31 19:38:06 -07:00
2018-05-15 19:34:34 -07:00
DDRB &= ~ ( 1 << 0 );
PORTB &= ~ ( 1 << 0 );
#endif
2018-05-02 08:39:46 -07:00
2018-05-31 22:11:06 -07:00
#if (defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE))
2018-03-31 19:38:06 -07:00
set_unicode_input_mode ( UC_WINC );
#endif //UNICODE_ENABLE
2017-11-06 21:11:08 -08:00
matrix_init_keymap ();
}
2018-05-31 22:11:06 -07:00
2018-07-16 18:04:32 -07:00
void startup_user ( void ) {
#ifdef RGBLIGHT_ENABLE
matrix_init_rgb ();
#endif //RGBLIGHT_ENABLE
startup_keymap ();
}
2018-08-29 10:42:15 -07:00
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_led led ;
for ( int i = 0 ; i < DRIVER_LED_TOTAL ; i ++ ) {
led = g_rgb_leds [ i ];
if ( led . matrix_co . raw < 0xFF ) {
rgb_matrix_set_color ( i , 0xFF , 0x00 , 0x00 );
}
}
#endif //RGB_MATRIX_ENABLE
shutdown_keymap ();
}
2018-07-16 18:04:32 -07:00
void suspend_power_down_user ( void )
{
suspend_power_down_keymap ();
}
void suspend_wakeup_init_user ( void )
{
suspend_wakeup_init_keymap ();
#ifdef KEYBOARD_ergodox_ez
wait_ms ( 10 );
#endif
}
2018-05-31 22:11:06 -07:00
2018-03-25 13:01:15 -07:00
// No global matrix scan code, so just run keymap's matrix
2017-11-10 19:58:53 -08:00
// scan function
2017-11-06 21:11:08 -08:00
void matrix_scan_user ( void ) {
2018-07-16 18:04:32 -07:00
static bool has_ran_yet ;
if ( ! has_ran_yet ) {
has_ran_yet = true ;
startup_user ();
}
2018-05-02 08:39:46 -07:00
2017-11-17 11:59:54 -08:00
#ifdef TAP_DANCE_ENABLE // Run Diablo 3 macro checking code.
run_diablo_macro_check ();
2018-03-31 19:38:06 -07:00
#endif // TAP_DANCE_ENABLE
2018-05-02 08:39:46 -07:00
2018-05-31 22:11:06 -07:00
#ifdef RGBLIGHT_ENABLE
matrix_scan_rgb ();
#endif // RGBLIGHT_ENABLE
2017-11-06 21:11:08 -08:00
matrix_scan_keymap ();
}
2018-04-20 17:53:19 -07:00
2017-11-06 21:11:08 -08:00
2018-03-01 07:46:57 -08:00
2017-11-10 19:58:53 -08:00
// Defines actions tor my global custom keycodes. Defined in drashna.h file
2018-03-25 13:01:15 -07:00
// Then runs the _keymap's record handier if not processed here
2017-11-06 21:11:08 -08:00
bool process_record_user ( uint16_t keycode , keyrecord_t * record ) {
2018-01-17 11:28:23 -08:00
2018-03-31 19:38:06 -07:00
// If console is enabled, it will print the matrix position and status of each key pressed
2018-05-31 22:11:06 -07:00
#ifdef KEYLOGGER_ENABLE
2017-11-06 21:11:08 -08:00
xprintf ( "KL: row: %u, column: %u, pressed: %u \n " , record -> event . key . col , record -> event . key . row , record -> event . pressed );
2018-05-31 22:11:06 -07:00
#endif //KEYLOGGER_ENABLE
2018-01-17 11:28:23 -08:00
2017-11-06 21:11:08 -08:00
switch ( keycode ) {
case KC_QWERTY :
if ( record -> event . pressed ) {
2018-03-25 13:01:15 -07:00
set_single_persistent_default_layer ( _QWERTY );
2017-11-06 21:11:08 -08:00
}
return false ;
break ;
case KC_COLEMAK :
if ( record -> event . pressed ) {
2018-03-25 13:01:15 -07:00
set_single_persistent_default_layer ( _COLEMAK );
2017-11-06 21:11:08 -08:00
}
return false ;
break ;
case KC_DVORAK :
if ( record -> event . pressed ) {
2018-03-25 13:01:15 -07:00
set_single_persistent_default_layer ( _DVORAK );
2017-11-06 21:11:08 -08:00
}
return false ;
break ;
case KC_WORKMAN :
if ( record -> event . pressed ) {
2018-03-25 13:01:15 -07:00
set_single_persistent_default_layer ( _WORKMAN );
2017-11-06 21:11:08 -08:00
}
return false ;
break ;
2018-03-01 07:46:57 -08:00
case KC_MAKE : // Compiles the firmware, and adds the flash command based on keyboard bootloader
2017-11-06 21:11:08 -08:00
if ( ! record -> event . pressed ) {
2018-07-16 18:04:32 -07:00
send_string_with_delay_P ( PSTR ( "make " QMK_KEYBOARD ":" QMK_KEYMAP
2017-12-05 18:45:42 -08:00
#if (defined(BOOTLOADER_DFU) || defined(BOOTLOADER_LUFA_DFU) || defined(BOOTLOADER_QMK_DFU))
2018-03-01 07:46:57 -08:00
":dfu"
2017-12-05 18:45:42 -08:00
#elif defined(BOOTLOADER_HALFKAY)
2018-03-01 07:46:57 -08:00
":teensy"
#elif defined(BOOTLOADER_CATERINA)
":avrdude"
2018-03-31 19:38:06 -07:00
#endif // bootloader options
2018-07-16 18:04:32 -07:00
SS_TAP ( X_ENTER )), 10 );
2017-11-06 21:11:08 -08:00
}
return false ;
break ;
2018-03-25 13:01:15 -07:00
2018-03-01 07:46:57 -08:00
case EPRM : // Resets EEPROM
2017-11-06 21:11:08 -08:00
if ( record -> event . pressed ) {
eeconfig_init ();
2018-05-31 22:11:06 -07:00
default_layer_set ( 1UL << eeconfig_read_default_layer ());
layer_state_set ( layer_state );
2017-11-06 21:11:08 -08:00
}
return false ;
break ;
2018-03-01 07:46:57 -08:00
case VRSN : // Prints firmware version
2017-11-06 21:11:08 -08:00
if ( record -> event . pressed ) {
2018-07-16 18:04:32 -07:00
send_string_with_delay_P ( PSTR ( QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION ", Built on: " QMK_BUILDDATE ), MACRO_TIMER );
2017-11-06 21:11:08 -08:00
}
return false ;
break ;
2018-03-25 13:01:15 -07:00
2018-05-31 22:11:06 -07:00
/* Code has been depreciated
case KC_SECRET_1 ... KC_SECRET_5: // Secrets! Externally defined strings, not stored in repo
if (!record->event.pressed) {
clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
send_string(decoy_secret[keycode - KC_SECRET_1]);
}
return false;
break;
*/
2018-03-01 07:46:57 -08:00
// These are a serious of gaming macros.
// Only enables for the viterbi, basically,
// to save on firmware space, since it's limited.
2018-05-31 22:11:06 -07:00
#ifdef MACROS_ENABLED
2018-03-01 07:46:57 -08:00
case KC_OVERWATCH : // Toggle's if we hit "ENTER" or "BACKSPACE" to input macros
2018-05-02 08:39:46 -07:00
if ( record -> event . pressed ) { userspace_config . is_overwatch ^= 1 ; eeprom_update_byte ( EECONFIG_USERSPACE , userspace_config . raw ); }
2018-03-01 07:46:57 -08:00
#ifdef RGBLIGHT_ENABLE
2018-05-31 22:11:06 -07:00
userspace_config . is_overwatch ? rgblight_mode_noeeprom ( 17 ) : rgblight_mode_noeeprom ( 18 );
2018-03-01 07:46:57 -08:00
#endif //RGBLIGHT_ENABLE
2018-03-25 13:01:15 -07:00
return false ; break ;
2018-03-01 07:46:57 -08:00
case KC_SALT :
2018-03-25 13:01:15 -07:00
return send_game_macro ( "Salt, salt, salt..." , record , false );
2018-03-01 07:46:57 -08:00
case KC_MORESALT :
2018-03-25 13:01:15 -07:00
return send_game_macro ( "Please sir, can I have some more salt?!" , record , false );
2018-03-01 07:46:57 -08:00
case KC_SALTHARD :
2018-03-25 13:01:15 -07:00
return send_game_macro ( "Your salt only makes me harder, and even more aggressive!" , record , false );
2018-03-01 07:46:57 -08:00
case KC_GOODGAME :
2018-03-25 13:01:15 -07:00
return send_game_macro ( "Good game, everyone!" , record , false );
2018-03-01 07:46:57 -08:00
case KC_GLHF :
2018-03-25 13:01:15 -07:00
return send_game_macro ( "Good luck, have fun!!!" , record , false );
2018-03-01 07:46:57 -08:00
case KC_SYMM :
2018-03-25 13:01:15 -07:00
return send_game_macro ( "Left click to win!" , record , false );
2018-03-01 07:46:57 -08:00
case KC_JUSTGAME :
2018-03-25 13:01:15 -07:00
return send_game_macro ( "It may be a game, but if you don't want to actually try, please go play AI, so that people that actually want to take the game seriously and \" get good \" have a place to do so without trolls like you throwing games." , record , false );
2018-03-01 07:46:57 -08:00
case KC_TORB :
2018-03-25 13:01:15 -07:00
return send_game_macro ( "That was positively riveting!" , record , false );
2018-03-01 07:46:57 -08:00
case KC_AIM :
2018-03-25 13:01:15 -07:00
send_game_macro ( "That aim is absolutely amazing. It's almost like you're a machine!" , record , true );
return send_game_macro ( "Wait! That aim is TOO good! You're clearly using an aim hack! CHEATER!" , record , false );
2018-03-01 07:46:57 -08:00
case KC_C9 :
2018-03-25 13:01:15 -07:00
return send_game_macro ( "OMG!!! C9!!!" , record , false );
2018-03-01 07:46:57 -08:00
case KC_GGEZ :
2018-03-25 13:01:15 -07:00
return send_game_macro ( "That was a fantastic game, though it was a bit easy. Try harder next time!" , record , false );
2018-05-31 22:11:06 -07:00
#endif // MACROS_ENABLED
2018-03-01 07:46:57 -08:00
2018-03-25 13:01:15 -07:00
case KC_DIABLO_CLEAR : // reset all Diablo timers, disabling them
2018-05-31 22:11:06 -07:00
#ifdef TAP_DANCE_ENABLE
2018-03-01 07:46:57 -08:00
if ( record -> event . pressed ) {
uint8_t dtime ;
for ( dtime = 0 ; dtime < 4 ; dtime ++ ) {
diablo_key_time [ dtime ] = diablo_times [ 0 ];
}
}
2018-07-16 18:04:32 -07:00
#endif // TAP_DANCE_ENABLE
2018-03-01 07:46:57 -08:00
return false ; break ;
2018-04-20 17:53:19 -07:00
2018-05-02 08:39:46 -07:00
case CLICKY_TOGGLE :
2018-05-15 19:34:34 -07:00
#ifdef AUDIO_CLICKY
2018-05-02 08:39:46 -07:00
userspace_config . clicky_enable = clicky_enable ;
eeprom_update_byte ( EECONFIG_USERSPACE , userspace_config . raw );
2018-05-15 19:34:34 -07:00
#endif
2018-05-02 08:39:46 -07:00
break ;
2018-04-20 17:53:19 -07:00
#ifdef UNICODE_ENABLE
case UC_FLIP : // (╯°□°)╯ ︵ ┻━┻
if ( record -> event . pressed ) {
register_code ( KC_RSFT );
tap ( KC_9 );
unregister_code ( KC_RSFT );
process_unicode (( 0x256F | QK_UNICODE ), record ); // Arm
process_unicode (( 0x00B0 | QK_UNICODE ), record ); // Eye
process_unicode (( 0x25A1 | QK_UNICODE ), record ); // Mouth
process_unicode (( 0x00B0 | QK_UNICODE ), record ); // Eye
register_code ( KC_RSFT );
tap ( KC_0 );
unregister_code ( KC_RSFT );
process_unicode (( 0x256F | QK_UNICODE ), record ); // Arm
tap ( KC_SPC );
process_unicode (( 0x0361 | QK_UNICODE ), record ); // Flippy
tap ( KC_SPC );
process_unicode (( 0x253B | QK_UNICODE ), record ); // Table
process_unicode (( 0x2501 | QK_UNICODE ), record ); // Table
process_unicode (( 0x253B | QK_UNICODE ), record ); // Table
}
return false ;
break ;
#endif // UNICODE_ENABLE
2017-11-06 21:11:08 -08:00
}
2018-07-16 18:04:32 -07:00
return process_record_keymap ( keycode , record ) &&
#ifdef RGBLIGHT_ENABLE
process_record_user_rgb ( keycode , record ) &&
#endif // RGBLIGHT_ENABLE
process_record_secrets ( keycode , record );
2017-11-06 21:11:08 -08:00
}
2018-03-01 07:46:57 -08:00
2018-05-02 08:39:46 -07:00
2017-11-10 19:58:53 -08:00
// Runs state check and changes underglow color and animation
// on layer change, no matter where the change was initiated
// Then runs keymap's layer change check
2017-11-17 11:59:54 -08:00
uint32_t layer_state_set_user ( uint32_t state ) {
2018-05-02 08:39:46 -07:00
state = update_tri_layer_state ( state , _RAISE , _LOWER , _ADJUST );
#ifdef RGBLIGHT_ENABLE
2018-05-31 22:11:06 -07:00
state = layer_state_set_rgb ( state );
2018-05-02 08:39:46 -07:00
#endif // RGBLIGHT_ENABLE
2017-11-10 19:58:53 -08:00
return layer_state_set_keymap ( state );
2017-11-06 21:11:08 -08:00
}
2017-11-17 11:59:54 -08:00
2018-07-16 18:04:32 -07:00
uint32_t default_layer_state_set_kb ( uint32_t state ) {
return default_layer_state_set_keymap ( state );
}
2018-03-01 07:46:57 -08:00
// Any custom LED code goes here.
// So far, I only have keyboard specific code,
2018-03-25 13:01:15 -07:00
// So nothing goes here.
2018-03-01 07:46:57 -08:00
void led_set_user ( uint8_t usb_led ) {
led_set_keymap ( usb_led );
}