const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { // MACRODOWN only works in this function switch(id) { case 0: if (record->event.pressed) { register_code(KC_RSFT); register_code(KC_RCTL); register_code(KC_ESC); } else{ clear_keyboard(); } break; case 1: if (record->event.pressed) { register_code(KC_LCTL); register_code(KC_LALT); register_code(KC_DEL); } else{ clear_keyboard(); } break; } return MACRO_NONE; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { if (record->event.pressed) { switch(keycode) { case MAC_UE: if(keyboard_report->mods & MOD_BIT(KC_LSFT)) { clear_keyboard(); SEND_STRING(SS_LALT("u") SS_LSFT("u")); } else { SEND_STRING(SS_LALT("u")"u"); } return false; case MAC_AE: if(keyboard_report->mods & MOD_BIT(KC_LSFT)) { clear_keyboard(); SEND_STRING(SS_LALT("u") SS_LSFT("a")); } else { SEND_STRING(SS_LALT("u")"a"); } return false; case MAC_OE: if(keyboard_report->mods & MOD_BIT(KC_LSFT)) { clear_keyboard(); SEND_STRING(SS_LALT("u") SS_LSFT("o")); } else { SEND_STRING(SS_LALT("u")"o"); } return false; case MAC_SS: SEND_STRING(SS_LALT("s")); return false; } } return true; };
void left_scan(void) { uint8_t ret = i2c_start(I2C_ADDR_WRITE, HOTDOX_I2C_TIMEOUT); if (ret == 0) { i2c_stop(); if (!i2c_initialized) { i2c_initialized = true; left_config(); clear_keyboard(); print("mcp23017 attached!!!\n"); } } else { if (i2c_initialized) { i2c_initialized = false; clear_keyboard(); print("mcp23017 deattached!!!\n"); } } return; }
static bool command_common(uint8_t code) { static host_driver_t *host_driver = 0; switch (code) { #ifdef SLEEP_LED_ENABLE case KC_Z: // test breathing sleep LED print("Sleep LED test\n"); sleep_led_toggle(); led_set(host_keyboard_leds()); break; #endif #ifdef BOOTMAGIC_ENABLE case KC_E: print("eeconfig:\n"); print_eeconfig(); break; #endif #ifdef KEYBOARD_LOCK_ENABLE case KC_CAPSLOCK: if (host_get_driver()) { host_driver = host_get_driver(); clear_keyboard(); host_set_driver(0); print("Locked.\n"); } else { host_set_driver(host_driver); print("Unlocked.\n"); } break; #endif case KC_H: case KC_SLASH: /* ? */ command_common_help(); break; case KC_C: debug_matrix = false; debug_keyboard = false; debug_mouse = false; debug_enable = false; command_console_help(); print("C> "); command_state = CONSOLE; break; case KC_PAUSE: clear_keyboard(); print("\n\nbootloader... "); _delay_ms(1000); bootloader_jump(); // not return break; case KC_D: if (debug_enable) { <<<<<<< HEAD print("\ndebug: off\n"); ======= print("\ndebug: on\n"); >>>>>>> upstream/master
void action_tapping_process(keyrecord_t record) { if (process_tapping(&record)) { if (!IS_NOEVENT(record.event)) { debug("processed: "); debug_record(record); debug("\n"); } } else { if (!waiting_buffer_enq(record)) { // clear all in case of overflow. debug("OVERFLOW: CLEAR ALL STATES\n"); clear_keyboard(); waiting_buffer_clear(); tapping_key = (keyrecord_t){}; } } // process waiting_buffer if (!IS_NOEVENT(record.event) && waiting_buffer_head != waiting_buffer_tail) { debug("---- action_exec: process waiting_buffer -----\n"); } for (; waiting_buffer_tail != waiting_buffer_head; waiting_buffer_tail = (waiting_buffer_tail + 1) % WAITING_BUFFER_SIZE) { if (process_tapping(&waiting_buffer[waiting_buffer_tail])) { debug("processed: waiting_buffer["); debug_dec(waiting_buffer_tail); debug("] = "); debug_record(waiting_buffer[waiting_buffer_tail]); debug("\n\n"); } else { break; } } if (!IS_NOEVENT(record.event)) { debug("\n"); } }
/* translates keycode to action */ static action_t keycode_to_action(uint8_t keycode) { action_t action = {}; switch (keycode) { case KC_A ... KC_EXSEL: case KC_LCTRL ... KC_RGUI: action.code = ACTION_KEY(keycode); break; case KC_SYSTEM_POWER ... KC_SYSTEM_WAKE: action.code = ACTION_USAGE_SYSTEM(KEYCODE2SYSTEM(keycode)); break; case KC_AUDIO_MUTE ... KC_WWW_FAVORITES: action.code = ACTION_USAGE_CONSUMER(KEYCODE2CONSUMER(keycode)); break; case KC_MS_UP ... KC_MS_ACCEL2: action.code = ACTION_MOUSEKEY(keycode); break; case KC_TRNS: action.code = ACTION_TRANSPARENT; break; case KC_BOOTLOADER: clear_keyboard(); wait_ms(50); bootloader_jump(); // not return break; default: action.code = ACTION_NO; break; } return action; }
static void exit_command_mode_2(void) { print("Exiting config mode ...\n"); SEND_COMMAND("---\r\n"); // exit clear_keyboard(); host_set_driver(prev_driver); }
void reset_keyboard(void) { 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_user(); while(timer_elapsed(timer_start) < 250) wait_ms(1); stop_all_notes(); #else shutdown_user(); wait_ms(250); #endif // this is also done later in bootloader.c - not sure if it's neccesary here #ifdef BOOTLOADER_CATERINA *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific #endif bootloader_jump(); }
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { if (record->event.pressed) { switch(id) { case 0: return MACRO( D(LSFT), T(9), U(LSFT), D(LSFT), T(0), U(LSFT), T(LEFT), END ); case 1: return MACRO( D(LSFT), T(LBRC), U(LSFT), D(LSFT), T(RBRC), U(LSFT), T(LEFT), END ); case 2: return MACRO( T(LBRC), T(RBRC), T(LEFT), END); case 3: clear_keyboard(); case 4: return MACRO( D(LSFT), T(SCOLON), U(LSFT), D(LSFT), T(9), U(LSFT), D(LSFT), T(0), U(LSFT), D(LSFT), T(LBRACKET), U(LSFT), D(LSFT), T(9), U(LSFT), D(LSFT), T(SCOLON), U(LSFT), D(LSFT), T(0), U(LSFT), D(LSFT), T(BSLASH), U(LSFT), D(LSFT), T(SCOLON), U(LSFT), D(LSFT), T(7), U(LSFT), D(LSFT), T(RBRACKET), U(LSFT), T(SCOLON), D(LSFT), T(SCOLON), U(LSFT), END ); case WINSH: set_unicode_input_mode(UC_WIN); return false; break; case WIN: set_unicode_input_mode(UC_WINC); return false; break; case OSX: set_unicode_input_mode(UC_OSX); return false; break; } } return MACRO_NONE; };
/* * user defined action function */ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) { uint8_t tap_count = record->tap.count; switch (id) { case RESET_LAYER_STATE: if (record->event.pressed) { if (!get_oneshot_locked_mods() && !get_oneshot_layer_state()) { register_code(KC_ESC); } } else { if (!get_oneshot_locked_mods() && !get_oneshot_layer_state()) { unregister_code(KC_ESC); } else { reset_oneshot_layer(); clear_oneshot_locked_mods(); layer_clear(); clear_keyboard(); } } break; case PROMICRO_RESET: if(tap_count == 5) { promicro_bootloader_jmp(false); } break; case PROMICRO_PROGRAM: if(tap_count == 5) { promicro_bootloader_jmp(true); } break; default: break; } }
void hook_usb_suspend_entry(void) { //dprintf("huse\n"); // Turn LED off to save power // Set 0 with putting aside status before suspend and restore // it after wakeup, then LED is updated at keyboard_task() in main loop _led_stats = keyboard_led_stats; keyboard_led_stats = 0; led_set(keyboard_led_stats); matrix_clear(); clear_keyboard(); send_sleep_to_other_side(true); mcpu_hardware_shutdown(true); #ifdef BACKLIGHT_ENABLE suspend_animation(); backlight_enableShutdown(true); #endif #ifdef SLEEP_LED_ENABLE sleep_led_enable(); #endif }
void hook_usb_wakeup(void) { //dprintf("huwu\n"); // // ---> This replaces the call of suspend_wakeup_init() <-- // // suspend_wakeup_init(); // clear keyboard state matrix_clear(); clear_keyboard(); #ifdef BACKLIGHT_ENABLE // // --> do not call this! I2C IRQ will destroy USB communication! <-- // // backlight_init(); backlight_enableShutdown(false); resume_animation_in_idle_state(); #endif #ifdef SLEEP_LED_ENABLE sleep_led_disable(); #endif mcpu_hardware_shutdown(false); send_sleep_to_other_side(false); // Restore LED status // BIOS/grub won't recognize/enumerate if led_set() takes long(around 40ms?) // Converters fall into the case and miss wakeup event(timeout to reply?) in the end. // led_set(host_keyboard_leds()); // Instead, restore stats and update at keyboard_task() in main loop keyboard_led_stats = _led_stats; }
static void switch_default_layer(uint8_t layer) { print("switch_default_layer: "); print_dec(biton32(default_layer_state)); print(" to "); print_dec(layer); print("\n"); default_layer_set(1UL<<layer); clear_keyboard(); }
// run immediately after wakeup void suspend_wakeup_init(void) { // clear keyboard state clear_keyboard(); #ifdef BACKLIGHT_ENABLE backlight_init(); #endif }
void tmux(bool pressed) { if (pressed) { add_mods(MOD_BIT(KC_LALT)); add_key(KC_COMMA); send_keyboard_report(); clear_keyboard(); } }
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) { if (record->event.pressed) { switch (id) { case SWITCH_TO_BLE_DRIVER: clear_keyboard(); _delay_ms(1000); host_set_driver(&nrf51822_driver); break; case SWITCH_TO_USB_DRIVER: clear_keyboard(); _delay_ms(1000); host_set_driver(&lufa_driver); break; } } }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { uint8_t mods = get_mods(); clear_keyboard(); handle_french_keycode(mods, keycode, record); set_mods(mods); return true; }
void action_function(keyrecord_t *event, uint8_t id, uint8_t opt) { if (id == TEENSY_KEY) { clear_keyboard(); print("\n\nJump to bootloader... "); _delay_ms(250); bootloader_jump(); // should not return print("not supported.\n"); } }
// run immediately after wakeup void suspend_wakeup_init(void) { // clear keyboard state clear_keyboard(); #ifdef SUSPEND_ACTION suspend_wakeup_init_action(); #endif #ifdef BACKLIGHT_ENABLE backlight_init(); #endif }
void reset_keyboard(void) { clear_keyboard(); #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_ENABLE_BASIC)) music_all_notes_off(); shutdown_user(); #endif wait_ms(250); #ifdef CATERINA_BOOTLOADER *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific #endif bootloader_jump(); }
void reset_keyboard(void) { clear_keyboard(); #ifdef AUDIO_ENABLE stop_all_notes(); shutdown_user(); #endif wait_ms(250); #ifdef CATERINA_BOOTLOADER *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific #endif bootloader_jump(); }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case DFU: if (record->event.pressed) { clear_keyboard(); reset_keyboard(); } return false; break; } return process_record_keymap(keycode, record) && process_record_secrets(keycode, record); }
static void enter_command_mode_2(void) { prev_driver = host_get_driver(); clear_keyboard(); host_set_driver(&rn42_config_driver); // null driver; not to send a key to host //while (rn42_linked()) ; wait_ms(1100); // need 1 sec SEND_COMMAND("$$$"); wait_ms(600); // need 1 sec print_rn42(); const char *s = SEND_COMMAND("v\r\n"); if (strncmp("v", s, 1) != 0) SEND_COMMAND("+\r\n"); // local echo on }
void SetNormalState(void) { // TODO: Do we have to do this here? clear_keyboard(); layer_clear(); #ifdef ERGODOX ergodox_led_all_off(); #endif // ERGODOX UltramodEventReset(); UltramodMachineReset(); }
void UltramodReset(void) { clear_keyboard(); layer_clear(); #ifdef ERGODOX ergodox_led_all_off(); #endif // ERGODOX UltramodSettingsReset(); UltramodEventReset(); UltramodMachineReset(); }
void reset_keyboard(void) { clear_keyboard(); #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_ENABLE_BASIC)) music_all_notes_off(); uint16_t timer_start = timer_read(); PLAY_SONG(goodbye_song); shutdown_user(); while(timer_elapsed(timer_start) < 250) wait_ms(1); stop_all_notes(); #else wait_ms(250); #endif #ifdef CATERINA_BOOTLOADER *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific #endif bootloader_jump(); }
void matrix_scan_user(void) { // We abuse this for early sending of key // Key repeat only on QWER/SYMB layers if (cMode != QWERTY || !inChord) return; // Check timers #ifndef NO_REPEAT if (repEngaged && timer_elapsed(repTimer) > REP_DELAY) { // Process Key for report processChord(false); // Send report to host send_keyboard_report(); clear_keyboard(); repTimer = timer_read(); } if (!repEngaged && timer_elapsed(repTimer) > REP_INIT_DELAY) { repEngaged = true; } #endif };
bool process_record_quantum(keyrecord_t *record) { /* This gets the keycode from the key pressed */ keypos_t key = record->event.key; uint16_t keycode; #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 (record->event.pressed) { layer = layer_switch_get_layer(key); update_source_layers_cache(key, layer); } else { layer = read_source_layers_cache(key); } keycode = keymap_key_to_keycode(layer, key); } else #endif keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key); // This is how you use actions here // if (keycode == KC_LEAD) { // action_t action; // action.code = ACTION_DEFAULT_LAYER_SET(0); // process_action(record, action); // return false; // } #ifdef TAP_DANCE_ENABLE preprocess_tap_dance(keycode, record); #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(AUDIO_ENABLE) && defined(AUDIO_CLICKY) process_clicky(keycode, record) && #endif //AUDIO_CLICKY process_record_kb(keycode, record) && #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_KEYPRESSES) process_rgb_matrix(keycode, record) && #endif #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED) process_midi(keycode, record) && #endif #ifdef AUDIO_ENABLE process_audio(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 TAP_DANCE_ENABLE process_tap_dance(keycode, record) && #endif #ifdef LEADER_ENABLE process_leader(keycode, record) && #endif #ifdef COMBO_ENABLE process_combo(keycode, record) && #endif #ifdef UNICODE_ENABLE process_unicode(keycode, record) && #endif #ifdef UCIS_ENABLE process_ucis(keycode, record) && #endif #ifdef PRINTING_ENABLE process_printer(keycode, record) && #endif #ifdef AUTO_SHIFT_ENABLE process_auto_shift(keycode, record) && #endif #ifdef UNICODEMAP_ENABLE process_unicode_map(keycode, record) && #endif #ifdef TERMINAL_ENABLE process_terminal(keycode, record) && #endif true)) { return false; } // Shift / paren setup switch(keycode) { case RESET: if (record->event.pressed) { reset_keyboard(); } return false; case DEBUG: if (record->event.pressed) { debug_enable = true; print("DEBUG: enabled.\n"); } return false; #ifdef FAUXCLICKY_ENABLE case FC_TOG: if (record->event.pressed) { FAUXCLICKY_TOGGLE; } return false; case FC_ON: if (record->event.pressed) { FAUXCLICKY_ON; } return false; case FC_OFF: if (record->event.pressed) { FAUXCLICKY_OFF; } return false; #endif #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) case RGB_TOG: // Split keyboards need to trigger on key-up for edge-case issue #ifndef SPLIT_KEYBOARD if (record->event.pressed) { #else if (!record->event.pressed) { #endif rgblight_toggle(); #ifdef SPLIT_KEYBOARD RGB_DIRTY = true; #endif } return false; case RGB_MODE_FORWARD: if (record->event.pressed) { uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)); if(shifted) { rgblight_step_reverse(); } else { rgblight_step(); } #ifdef SPLIT_KEYBOARD RGB_DIRTY = true; #endif } return false; case RGB_MODE_REVERSE: if (record->event.pressed) { uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)); if(shifted) { rgblight_step(); } else { rgblight_step_reverse(); } #ifdef SPLIT_KEYBOARD RGB_DIRTY = true; #endif } return false; case RGB_HUI: // Split keyboards need to trigger on key-up for edge-case issue #ifndef SPLIT_KEYBOARD if (record->event.pressed) { #else if (!record->event.pressed) { #endif rgblight_increase_hue(); #ifdef SPLIT_KEYBOARD RGB_DIRTY = true; #endif } return false; case RGB_HUD: // Split keyboards need to trigger on key-up for edge-case issue #ifndef SPLIT_KEYBOARD if (record->event.pressed) { #else if (!record->event.pressed) { #endif rgblight_decrease_hue(); #ifdef SPLIT_KEYBOARD RGB_DIRTY = true; #endif } return false; case RGB_SAI: // Split keyboards need to trigger on key-up for edge-case issue #ifndef SPLIT_KEYBOARD if (record->event.pressed) { #else if (!record->event.pressed) { #endif rgblight_increase_sat(); #ifdef SPLIT_KEYBOARD RGB_DIRTY = true; #endif } return false; case RGB_SAD: // Split keyboards need to trigger on key-up for edge-case issue #ifndef SPLIT_KEYBOARD if (record->event.pressed) { #else if (!record->event.pressed) { #endif rgblight_decrease_sat(); #ifdef SPLIT_KEYBOARD RGB_DIRTY = true; #endif } return false; case RGB_VAI: // Split keyboards need to trigger on key-up for edge-case issue #ifndef SPLIT_KEYBOARD if (record->event.pressed) { #else if (!record->event.pressed) { #endif rgblight_increase_val(); #ifdef SPLIT_KEYBOARD RGB_DIRTY = true; #endif } return false; case RGB_VAD: // Split keyboards need to trigger on key-up for edge-case issue #ifndef SPLIT_KEYBOARD if (record->event.pressed) { #else if (!record->event.pressed) { #endif rgblight_decrease_val(); #ifdef SPLIT_KEYBOARD RGB_DIRTY = true; #endif } return false; case RGB_SPI: if (record->event.pressed) { rgblight_increase_speed(); } return false; case RGB_SPD: if (record->event.pressed) { rgblight_decrease_speed(); } return false; case RGB_MODE_PLAIN: if (record->event.pressed) { rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT); #ifdef SPLIT_KEYBOARD RGB_DIRTY = true; #endif } return false; case RGB_MODE_BREATHE: #ifdef RGBLIGHT_EFFECT_BREATHING if (record->event.pressed) { if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) { rgblight_step(); } else { rgblight_mode(RGBLIGHT_MODE_BREATHING); } } #endif return false; case RGB_MODE_RAINBOW: #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD if (record->event.pressed) { if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) { rgblight_step(); } else { rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD); } } #endif return false; case RGB_MODE_SWIRL: #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL if (record->event.pressed) { if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) { rgblight_step(); } else { rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL); } } #endif return false; case RGB_MODE_SNAKE: #ifdef RGBLIGHT_EFFECT_SNAKE if (record->event.pressed) { if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) { rgblight_step(); } else { rgblight_mode(RGBLIGHT_MODE_SNAKE); } } #endif return false; case RGB_MODE_KNIGHT: #ifdef RGBLIGHT_EFFECT_KNIGHT if (record->event.pressed) { if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) { rgblight_step(); } else { rgblight_mode(RGBLIGHT_MODE_KNIGHT); } } #endif return false; case RGB_MODE_XMAS: #ifdef RGBLIGHT_EFFECT_CHRISTMAS if (record->event.pressed) { rgblight_mode(RGBLIGHT_MODE_CHRISTMAS); } #endif return false; case RGB_MODE_GRADIENT: #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT if (record->event.pressed) { if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) && (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) { rgblight_step(); } else { rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT); } } #endif return false; case RGB_MODE_RGBTEST: #ifdef RGBLIGHT_EFFECT_RGB_TEST if (record->event.pressed) { rgblight_mode(RGBLIGHT_MODE_RGB_TEST); } #endif return false; #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) #ifdef PROTOCOL_LUFA case OUT_AUTO: if (record->event.pressed) { set_output(OUTPUT_AUTO); } return false; case OUT_USB: if (record->event.pressed) { set_output(OUTPUT_USB); } return false; #ifdef BLUETOOTH_ENABLE case OUT_BT: if (record->event.pressed) { set_output(OUTPUT_BLUETOOTH); } return false; #endif #endif case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO: if (record->event.pressed) { // MAGIC actions (BOOTMAGIC without the boot) if (!eeconfig_is_enabled()) { eeconfig_init(); } /* keymap config */ keymap_config.raw = eeconfig_read_keymap(); switch (keycode) { case MAGIC_SWAP_CONTROL_CAPSLOCK: keymap_config.swap_control_capslock = true; break; case MAGIC_CAPSLOCK_TO_CONTROL: keymap_config.capslock_to_control = true; break; case MAGIC_SWAP_LALT_LGUI: keymap_config.swap_lalt_lgui = true; break; case MAGIC_SWAP_RALT_RGUI: keymap_config.swap_ralt_rgui = true; break; case MAGIC_NO_GUI: keymap_config.no_gui = true; break; case MAGIC_SWAP_GRAVE_ESC: keymap_config.swap_grave_esc = true; break; case MAGIC_SWAP_BACKSLASH_BACKSPACE: keymap_config.swap_backslash_backspace = true; break; case MAGIC_HOST_NKRO: keymap_config.nkro = true; break; case MAGIC_SWAP_ALT_GUI: keymap_config.swap_lalt_lgui = true; keymap_config.swap_ralt_rgui = true; #ifdef AUDIO_ENABLE PLAY_SONG(ag_swap_song); #endif break; case MAGIC_UNSWAP_CONTROL_CAPSLOCK: keymap_config.swap_control_capslock = false; break; case MAGIC_UNCAPSLOCK_TO_CONTROL: keymap_config.capslock_to_control = false; break; case MAGIC_UNSWAP_LALT_LGUI: keymap_config.swap_lalt_lgui = false; break; case MAGIC_UNSWAP_RALT_RGUI: keymap_config.swap_ralt_rgui = false; break; case MAGIC_UNNO_GUI: keymap_config.no_gui = false; break; case MAGIC_UNSWAP_GRAVE_ESC: keymap_config.swap_grave_esc = false; break; case MAGIC_UNSWAP_BACKSLASH_BACKSPACE: keymap_config.swap_backslash_backspace = false; break; case MAGIC_UNHOST_NKRO: keymap_config.nkro = false; break; case MAGIC_UNSWAP_ALT_GUI: keymap_config.swap_lalt_lgui = false; keymap_config.swap_ralt_rgui = false; #ifdef AUDIO_ENABLE PLAY_SONG(ag_norm_song); #endif break; case MAGIC_TOGGLE_ALT_GUI: keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui; keymap_config.swap_ralt_rgui = !keymap_config.swap_ralt_rgui; #ifdef AUDIO_ENABLE if (keymap_config.swap_ralt_rgui) { PLAY_SONG(ag_swap_song); } else { PLAY_SONG(ag_norm_song); } #endif break; case MAGIC_TOGGLE_NKRO: keymap_config.nkro = !keymap_config.nkro; break; default: break; } eeconfig_update_keymap(keymap_config.raw); clear_keyboard(); // clear to prevent stuck keys return false; } break; case KC_LSPO: { if (record->event.pressed) { shift_interrupted[0] = false; scs_timer[0] = timer_read (); register_mods(MOD_BIT(KC_LSFT)); } else { #ifdef DISABLE_SPACE_CADET_ROLLOVER if (get_mods() & MOD_BIT(KC_RSFT)) { shift_interrupted[0] = true; shift_interrupted[1] = true; } #endif if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) { register_code(LSPO_KEY); unregister_code(LSPO_KEY); } unregister_mods(MOD_BIT(KC_LSFT)); } return false; } case KC_RSPC: { if (record->event.pressed) { shift_interrupted[1] = false; scs_timer[1] = timer_read (); register_mods(MOD_BIT(KC_RSFT)); } else { #ifdef DISABLE_SPACE_CADET_ROLLOVER if (get_mods() & MOD_BIT(KC_LSFT)) { shift_interrupted[0] = true; shift_interrupted[1] = true; } #endif if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) { register_code(RSPC_KEY); unregister_code(RSPC_KEY); } unregister_mods(MOD_BIT(KC_RSFT)); } return false; } case KC_SFTENT: { if (record->event.pressed) { shift_interrupted[1] = false; scs_timer[1] = timer_read (); register_mods(MOD_BIT(KC_RSFT)); } else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) { unregister_mods(MOD_BIT(KC_RSFT)); register_code(SFTENT_KEY); unregister_code(SFTENT_KEY); } else { unregister_mods(MOD_BIT(KC_RSFT)); } return false; } case GRAVE_ESC: { uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT) |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))); #ifdef GRAVE_ESC_ALT_OVERRIDE // if ALT is pressed, ESC is always sent // this is handy for the cmd+opt+esc shortcut on macOS, among other things. if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) { shifted = 0; } #endif #ifdef GRAVE_ESC_CTRL_OVERRIDE // if CTRL is pressed, ESC is always sent // this is handy for the ctrl+shift+esc shortcut on windows, among other things. if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) { shifted = 0; } #endif #ifdef GRAVE_ESC_GUI_OVERRIDE // if GUI is pressed, ESC is always sent if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) { shifted = 0; } #endif #ifdef GRAVE_ESC_SHIFT_OVERRIDE // if SHIFT is pressed, ESC is always sent if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) { shifted = 0; } #endif if (record->event.pressed) { grave_esc_was_shifted = shifted; add_key(shifted ? KC_GRAVE : KC_ESCAPE); } else { del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE); } send_keyboard_report(); return false; } #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING) case BL_BRTG: { if (record->event.pressed) breathing_toggle(); return false; } #endif default: { shift_interrupted[0] = true; shift_interrupted[1] = true; break; } } return process_action_kb(record); } __attribute__ ((weak)) const bool ascii_to_shift_lut[0x80] 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, 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 }; __attribute__ ((weak)) const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = { 0, 0, 0, 0, 0, 0, 0, 0, KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KC_ESC, 0, 0, 0, 0, KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT, KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH, KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH, KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G, KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O, KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W, KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS, KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G, KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O, KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W, KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL }; void send_string(const char *str) { send_string_with_delay(str, 0); } void send_string_P(const char *str) { send_string_with_delay_P(str, 0); } void send_string_with_delay(const char *str, uint8_t interval) { while (1) { char ascii_code = *str; if (!ascii_code) break; if (ascii_code == 1) { // tap uint8_t keycode = *(++str); register_code(keycode); unregister_code(keycode); } else if (ascii_code == 2) { // down uint8_t keycode = *(++str); register_code(keycode); } else if (ascii_code == 3) { // up uint8_t keycode = *(++str); unregister_code(keycode); } else { send_char(ascii_code); } ++str; // interval { uint8_t ms = interval; while (ms--) wait_ms(1); } } } void send_string_with_delay_P(const char *str, uint8_t interval) { while (1) { char ascii_code = pgm_read_byte(str); if (!ascii_code) break; if (ascii_code == 1) { // tap uint8_t keycode = pgm_read_byte(++str); register_code(keycode); unregister_code(keycode); } else if (ascii_code == 2) { // down uint8_t keycode = pgm_read_byte(++str); register_code(keycode); } else if (ascii_code == 3) { // up uint8_t keycode = pgm_read_byte(++str); unregister_code(keycode); } else { send_char(ascii_code); } ++str; // interval { uint8_t ms = interval; while (ms--) wait_ms(1); } } } void send_char(char ascii_code) { uint8_t keycode; keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]); if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) { register_code(KC_LSFT); register_code(keycode); unregister_code(keycode); unregister_code(KC_LSFT); } else { register_code(keycode); unregister_code(keycode); } } 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(1U<<default_layer); default_layer_set(1U<<default_layer); } uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) { uint32_t mask12 = (1UL << layer1) | (1UL << layer2); uint32_t mask3 = 1UL << layer3; return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3); } 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)); } void tap_random_base64(void) { #if defined(__AVR_ATmega32U4__) uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64; #else uint8_t key = rand() % 64; #endif switch (key) { case 0 ... 25: register_code(KC_LSFT); register_code(key + KC_A); unregister_code(key + KC_A); unregister_code(KC_LSFT); break; case 26 ... 51: register_code(key - 26 + KC_A); unregister_code(key - 26 + KC_A); break; case 52: register_code(KC_0); unregister_code(KC_0); break; case 53 ... 61: register_code(key - 53 + KC_1); unregister_code(key - 53 + KC_1); break; case 62: register_code(KC_LSFT); register_code(KC_EQL); unregister_code(KC_EQL); unregister_code(KC_LSFT); break; case 63: register_code(KC_SLSH); unregister_code(KC_SLSH); break; } }
// All processing done at chordUp goes through here bool send_steno_chord_user(steno_mode_t mode, uint8_t chord[6]) { // Check for mousekeys, this is release #ifdef MOUSEKEY_ENABLE if (inMouse) { inMouse = false; mousekey_off(mousePress); mousekey_send(); } #endif // Toggle Serial/QWERTY steno if (cChord == (PWR | FN | ST1 | ST2)) { #ifndef NO_DEBUG uprintf("Fallback Toggle\n"); #endif QWERSTENO = !QWERSTENO; goto out; } // handle command mode if (cChord == (PWR | FN | RD | RZ)) { #ifndef NO_DEBUG uprintf("COMMAND Toggle\n"); #endif if (cMode != COMMAND) { // Entering Command Mode CMDLEN = 0; pMode = cMode; cMode = COMMAND; } else { // Exiting Command Mode cMode = pMode; // Press all and release all for (int i = 0; i < CMDLEN; i++) { register_code(CMDBUF[i]); } clear_keyboard(); } goto out; } // Handle Gaming Toggle, if (cChord == (PWR | FN | ST4 | ST3) && keymapsCount > 1) { #ifndef NO_DEBUG uprintf("Switching to QMK\n"); #endif layer_on(1); goto out; } // Lone FN press, toggle QWERTY #ifndef ONLYQWERTY if (cChord == FN) { (cMode == STENO) ? (cMode = QWERTY) : (cMode = STENO); goto out; } #endif // Check for Plover momentary if (cMode == QWERTY && (cChord & FN)) { cChord ^= FN; goto steno; } // Do QWERTY and Momentary QWERTY if (cMode == QWERTY || (cMode == COMMAND) || (cChord & (FN | PWR))) { processChord(false); goto out; } // Fallback NKRO Steno if (cMode == STENO && QWERSTENO) { processChord(true); goto out; } steno: // Hey that's a steno chord! inChord = false; chordIndex = 0; cChord = 0; return true; out: cChord = 0; inChord = false; chordIndex = 0; clear_keyboard(); repEngaged = false; for (int i = 0; i < 32; i++) chordState[i] = 0xFFFF; return false; }
bool process_record_quantum(keyrecord_t *record) { /* This gets the keycode from the key pressed */ keypos_t key = record->event.key; uint16_t keycode; #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) /* TODO: Use store_or_get_action() or a similar function. */ if (!disable_action_cache) { uint8_t layer; if (record->event.pressed) { layer = layer_switch_get_layer(key); update_source_layers_cache(key, layer); } else { layer = read_source_layers_cache(key); } keycode = keymap_key_to_keycode(layer, key); } else #endif keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key); // This is how you use actions here // if (keycode == KC_LEAD) { // action_t action; // action.code = ACTION_DEFAULT_LAYER_SET(0); // process_action(record, action); // return false; // } if (!( #if defined(KEY_LOCK_ENABLE) // Must run first to be able to mask key_up events. process_key_lock(&keycode, record) && #endif process_record_kb(keycode, record) && #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED) process_midi(keycode, record) && #endif #ifdef AUDIO_ENABLE process_audio(keycode, record) && #endif #ifdef STENO_ENABLE process_steno(keycode, record) && #endif #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC)) process_music(keycode, record) && #endif #ifdef TAP_DANCE_ENABLE process_tap_dance(keycode, record) && #endif #ifndef DISABLE_LEADER process_leader(keycode, record) && #endif #ifndef DISABLE_CHORDING process_chording(keycode, record) && #endif #ifdef COMBO_ENABLE process_combo(keycode, record) && #endif #ifdef UNICODE_ENABLE process_unicode(keycode, record) && #endif #ifdef UCIS_ENABLE process_ucis(keycode, record) && #endif #ifdef PRINTING_ENABLE process_printer(keycode, record) && #endif #ifdef AUTO_SHIFT_ENABLE process_auto_shift(keycode, record) && #endif #ifdef UNICODEMAP_ENABLE process_unicode_map(keycode, record) && #endif #ifdef TERMINAL_ENABLE process_terminal(keycode, record) && #endif true)) { return false; } // Shift / paren setup switch(keycode) { case RESET: if (record->event.pressed) { reset_keyboard(); } return false; case DEBUG: if (record->event.pressed) { debug_enable = true; print("DEBUG: enabled.\n"); } return false; #ifdef FAUXCLICKY_ENABLE case FC_TOG: if (record->event.pressed) { FAUXCLICKY_TOGGLE; } return false; case FC_ON: if (record->event.pressed) { FAUXCLICKY_ON; } return false; case FC_OFF: if (record->event.pressed) { FAUXCLICKY_OFF; } return false; #endif #ifdef RGBLIGHT_ENABLE case RGB_TOG: if (record->event.pressed) { rgblight_toggle(); } return false; case RGB_MOD: if (record->event.pressed) { rgblight_step(); } return false; case RGB_SMOD: // same as RBG_MOD, but if shift is pressed, it will use the reverese direction instead. if (record->event.pressed) { uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)); if(shifted) { rgblight_step_reverse(); } else { rgblight_step(); } } return false; case RGB_HUI: if (record->event.pressed) { rgblight_increase_hue(); } return false; case RGB_HUD: if (record->event.pressed) { rgblight_decrease_hue(); } return false; case RGB_SAI: if (record->event.pressed) { rgblight_increase_sat(); } return false; case RGB_SAD: if (record->event.pressed) { rgblight_decrease_sat(); } return false; case RGB_VAI: if (record->event.pressed) { rgblight_increase_val(); } return false; case RGB_VAD: if (record->event.pressed) { rgblight_decrease_val(); } return false; case RGB_MODE_PLAIN: if (record->event.pressed) { rgblight_mode(1); } return false; case RGB_MODE_BREATHE: if (record->event.pressed) { if ((2 <= rgblight_get_mode()) && (rgblight_get_mode() < 5)) { rgblight_step(); } else { rgblight_mode(2); } } return false; case RGB_MODE_RAINBOW: if (record->event.pressed) { if ((6 <= rgblight_get_mode()) && (rgblight_get_mode() < 8)) { rgblight_step(); } else { rgblight_mode(6); } } return false; case RGB_MODE_SWIRL: if (record->event.pressed) { if ((9 <= rgblight_get_mode()) && (rgblight_get_mode() < 14)) { rgblight_step(); } else { rgblight_mode(9); } } return false; case RGB_MODE_SNAKE: if (record->event.pressed) { if ((15 <= rgblight_get_mode()) && (rgblight_get_mode() < 20)) { rgblight_step(); } else { rgblight_mode(15); } } return false; case RGB_MODE_KNIGHT: if (record->event.pressed) { if ((21 <= rgblight_get_mode()) && (rgblight_get_mode() < 23)) { rgblight_step(); } else { rgblight_mode(21); } } return false; case RGB_MODE_XMAS: if (record->event.pressed) { rgblight_mode(24); } return false; case RGB_MODE_GRADIENT: if (record->event.pressed) { if ((25 <= rgblight_get_mode()) && (rgblight_get_mode() < 34)) { rgblight_step(); } else { rgblight_mode(25); } } return false; #endif #ifdef PROTOCOL_LUFA case OUT_AUTO: if (record->event.pressed) { set_output(OUTPUT_AUTO); } return false; case OUT_USB: if (record->event.pressed) { set_output(OUTPUT_USB); } return false; #ifdef BLUETOOTH_ENABLE case OUT_BT: if (record->event.pressed) { set_output(OUTPUT_BLUETOOTH); } return false; #endif #endif case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO: if (record->event.pressed) { // MAGIC actions (BOOTMAGIC without the boot) if (!eeconfig_is_enabled()) { eeconfig_init(); } /* keymap config */ keymap_config.raw = eeconfig_read_keymap(); switch (keycode) { case MAGIC_SWAP_CONTROL_CAPSLOCK: keymap_config.swap_control_capslock = true; break; case MAGIC_CAPSLOCK_TO_CONTROL: keymap_config.capslock_to_control = true; break; case MAGIC_SWAP_LALT_LGUI: keymap_config.swap_lalt_lgui = true; break; case MAGIC_SWAP_RALT_RGUI: keymap_config.swap_ralt_rgui = true; break; case MAGIC_NO_GUI: keymap_config.no_gui = true; break; case MAGIC_SWAP_GRAVE_ESC: keymap_config.swap_grave_esc = true; break; case MAGIC_SWAP_BACKSLASH_BACKSPACE: keymap_config.swap_backslash_backspace = true; break; case MAGIC_HOST_NKRO: keymap_config.nkro = true; break; case MAGIC_SWAP_ALT_GUI: keymap_config.swap_lalt_lgui = true; keymap_config.swap_ralt_rgui = true; #ifdef AUDIO_ENABLE PLAY_SONG(ag_swap_song); #endif break; case MAGIC_UNSWAP_CONTROL_CAPSLOCK: keymap_config.swap_control_capslock = false; break; case MAGIC_UNCAPSLOCK_TO_CONTROL: keymap_config.capslock_to_control = false; break; case MAGIC_UNSWAP_LALT_LGUI: keymap_config.swap_lalt_lgui = false; break; case MAGIC_UNSWAP_RALT_RGUI: keymap_config.swap_ralt_rgui = false; break; case MAGIC_UNNO_GUI: keymap_config.no_gui = false; break; case MAGIC_UNSWAP_GRAVE_ESC: keymap_config.swap_grave_esc = false; break; case MAGIC_UNSWAP_BACKSLASH_BACKSPACE: keymap_config.swap_backslash_backspace = false; break; case MAGIC_UNHOST_NKRO: keymap_config.nkro = false; break; case MAGIC_UNSWAP_ALT_GUI: keymap_config.swap_lalt_lgui = false; keymap_config.swap_ralt_rgui = false; #ifdef AUDIO_ENABLE PLAY_SONG(ag_norm_song); #endif break; case MAGIC_TOGGLE_NKRO: keymap_config.nkro = !keymap_config.nkro; break; default: break; } eeconfig_update_keymap(keymap_config.raw); clear_keyboard(); // clear to prevent stuck keys return false; } break; case KC_LSPO: { if (record->event.pressed) { shift_interrupted[0] = false; scs_timer[0] = timer_read (); register_mods(MOD_BIT(KC_LSFT)); } else { #ifdef DISABLE_SPACE_CADET_ROLLOVER if (get_mods() & MOD_BIT(KC_RSFT)) { shift_interrupted[0] = true; shift_interrupted[1] = true; } #endif if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) { register_code(LSPO_KEY); unregister_code(LSPO_KEY); } unregister_mods(MOD_BIT(KC_LSFT)); } return false; } case KC_RSPC: { if (record->event.pressed) { shift_interrupted[1] = false; scs_timer[1] = timer_read (); register_mods(MOD_BIT(KC_RSFT)); } else { #ifdef DISABLE_SPACE_CADET_ROLLOVER if (get_mods() & MOD_BIT(KC_LSFT)) { shift_interrupted[0] = true; shift_interrupted[1] = true; } #endif if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) { register_code(RSPC_KEY); unregister_code(RSPC_KEY); } unregister_mods(MOD_BIT(KC_RSFT)); } return false; } case GRAVE_ESC: { uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT) |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))); #ifdef GRAVE_ESC_ALT_OVERRIDE // if ALT is pressed, ESC is always sent // this is handy for the cmd+opt+esc shortcut on macOS, among other things. if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) { shifted = 0; } #endif #ifdef GRAVE_ESC_CTRL_OVERRIDE // if CTRL is pressed, ESC is always sent // this is handy for the ctrl+shift+esc shortcut on windows, among other things. if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) { shifted = 0; } #endif #ifdef GRAVE_ESC_GUI_OVERRIDE // if GUI is pressed, ESC is always sent if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) { shifted = 0; } #endif #ifdef GRAVE_ESC_SHIFT_OVERRIDE // if SHIFT is pressed, ESC is always sent if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) { shifted = 0; } #endif if (record->event.pressed) { grave_esc_was_shifted = shifted; add_key(shifted ? KC_GRAVE : KC_ESCAPE); } else { del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE); } send_keyboard_report(); } default: { shift_interrupted[0] = true; shift_interrupted[1] = true; break; } } return process_action_kb(record); }