void matrix_scan_user(void) { uint8_t layer = biton32(layer_state); if (keyboard_report->mods & MOD_BIT(KC_LSFT) || ((get_oneshot_mods() & MOD_BIT(KC_LSFT)) && !has_oneshot_mods_timed_out())) { ergodox_right_led_1_set(LED_BRIGHTNESS_HI); ergodox_right_led_1_on(); } else if (layer == RAISE || layer == AUX) { ergodox_right_led_1_set(LED_BRIGHTNESS_LO); ergodox_right_led_1_on(); } else { ergodox_right_led_1_off(); } if (keyboard_report->mods & MOD_BIT(KC_LCTL) || ((get_oneshot_mods() & MOD_BIT(KC_LCTL)) && !has_oneshot_mods_timed_out())) { ergodox_right_led_2_set(LED_BRIGHTNESS_HI); ergodox_right_led_2_on(); } else if (layer == LOWER || layer == AUX) { ergodox_right_led_2_set(LED_BRIGHTNESS_LO); ergodox_right_led_2_on(); } else { ergodox_right_led_2_off(); } if (keyboard_report->mods & MOD_BIT(KC_LALT) || ((get_oneshot_mods() & MOD_BIT(KC_LALT)) && !has_oneshot_mods_timed_out())) { ergodox_right_led_3_set(LED_BRIGHTNESS_HI); ergodox_right_led_3_on(); } else if (layer == COLE || layer == AUX) { ergodox_right_led_3_set(LED_BRIGHTNESS_LO); ergodox_right_led_3_on(); } else { ergodox_right_led_3_off(); } LEADER_DICTIONARY() { leading = false; leader_end(); SEQ_THREE_KEYS(KC_W, KC_I, KC_N) { os_type = OS_WIN; }; SEQ_THREE_KEYS(KC_O, KC_S, KC_X) { os_type = OS_OSX; }; SEQ_THREE_KEYS(KC_L, KC_I, KC_N) { os_type = OS_LIN; }; SEQ_ONE_KEY(KC_A) { switch (os_type) { case OS_WIN: tap(KC_NLCK); register_code(KC_RALT); tap(KC_KP_0); tap(KC_KP_2); tap(KC_KP_2); tap(KC_KP_8); unregister_code(KC_RALT); tap(KC_NLCK); break; case OS_OSX: register_code(KC_RALT); register_code(KC_RSFT); register_code(KC_SCLN); unregister_code(KC_SCLN); unregister_code(KC_RSFT); unregister_code(KC_RALT); tap(KC_A); break; case OS_LIN: tap(KC_RALT); tap(KC_DQT); tap(KC_A); break; } } SEQ_TWO_KEYS(KC_A, KC_A) { switch (os_type) { case OS_WIN: tap(KC_NLCK); register_code(KC_RALT); tap(KC_KP_0); tap(KC_KP_1); tap(KC_KP_9); tap(KC_KP_6); unregister_code(KC_RALT); tap(KC_NLCK); break; case OS_OSX: register_code(KC_RALT); register_code(KC_RSFT); register_code(KC_SCLN); unregister_code(KC_SCLN); unregister_code(KC_RSFT); unregister_code(KC_RALT); register_code(KC_LSFT); register_code(KC_A); unregister_code(KC_A); unregister_code(KC_LSFT); break; case OS_LIN: tap(KC_RALT); tap(KC_DQT); register_code(KC_LSFT); register_code(KC_A); unregister_code(KC_A); unregister_code(KC_LSFT); break; } } SEQ_ONE_KEY(KC_O) { switch (os_type) { case OS_WIN: tap(KC_NLCK); register_code(KC_RALT); tap(KC_KP_0); tap(KC_KP_2); tap(KC_KP_4); tap(KC_KP_6); unregister_code(KC_RALT); tap(KC_NLCK); break; case OS_OSX: register_code(KC_RALT); register_code(KC_RSFT); register_code(KC_SCLN); unregister_code(KC_SCLN); unregister_code(KC_RSFT); unregister_code(KC_RALT); tap(KC_O); break; case OS_LIN: tap(KC_RALT); tap(KC_DQT); tap(KC_O); break; } } SEQ_TWO_KEYS(KC_O, KC_O) { switch (os_type) { case OS_WIN: tap(KC_NLCK); register_code(KC_RALT); tap(KC_KP_0); tap(KC_KP_2); tap(KC_KP_1); tap(KC_KP_4); unregister_code(KC_RALT); tap(KC_NLCK); break; case OS_OSX: register_code(KC_RALT); register_code(KC_RSFT); register_code(KC_SCLN); unregister_code(KC_SCLN); unregister_code(KC_RSFT); unregister_code(KC_RALT); tap(LSFT(KC_O)); break; case OS_LIN: tap(KC_RALT); tap(KC_DQT); register_code(KC_LSFT); register_code(KC_O); unregister_code(KC_O); unregister_code(KC_LSFT); break; } } SEQ_ONE_KEY(KC_U) { switch (os_type) { case OS_WIN: tap(KC_NLCK); register_code(KC_RALT); tap(KC_KP_0); tap(KC_KP_2); tap(KC_KP_5); tap(KC_KP_2); unregister_code(KC_RALT); tap(KC_NLCK); break; case OS_OSX: register_code(KC_RALT); register_code(KC_RSFT); register_code(KC_SCLN); unregister_code(KC_SCLN); unregister_code(KC_RSFT); unregister_code(KC_RALT); tap(KC_U); break; case OS_LIN: tap(KC_RALT); tap(KC_DQT); tap(KC_U); break; } } SEQ_TWO_KEYS(KC_U, KC_U) { switch (os_type) { case OS_WIN: tap(KC_NLCK); register_code(KC_RALT); tap(KC_KP_0); tap(KC_KP_2); tap(KC_KP_2); tap(KC_KP_0); unregister_code(KC_RALT); tap(KC_NLCK); break; case OS_OSX: register_code(KC_RALT); register_code(KC_RSFT); register_code(KC_SCLN); unregister_code(KC_SCLN); unregister_code(KC_RSFT); unregister_code(KC_RALT); tap(LSFT(KC_U)); break; case OS_LIN: tap(KC_RALT); tap(KC_DQT); register_code(KC_LSFT); register_code(KC_U); unregister_code(KC_U); unregister_code(KC_LSFT); break; } } SEQ_ONE_KEY(KC_S) { switch (os_type) { case OS_WIN: tap(KC_NLCK); register_code(KC_RALT); tap(KC_KP_0); tap(KC_KP_2); tap(KC_KP_2); tap(KC_KP_3); unregister_code(KC_RALT); tap(KC_NLCK); break; case OS_OSX: register_code(KC_RALT); tap(KC_S); unregister_code(KC_RALT); break; case OS_LIN: tap(KC_RALT); tap(KC_S); tap(KC_S); break; } } } }
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); }
// convert keycode into ascii charactor static uint8_t code2asc(uint8_t code) { bool shifted = (get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RCTL))) ? true : false; switch (code) { case KC_A: return (shifted ? 'A' : 'a'); case KC_B: return (shifted ? 'B' : 'b'); case KC_C: return (shifted ? 'C' : 'c'); case KC_D: return (shifted ? 'D' : 'd'); case KC_E: return (shifted ? 'E' : 'e'); case KC_F: return (shifted ? 'F' : 'f'); case KC_G: return (shifted ? 'G' : 'g'); case KC_H: return (shifted ? 'H' : 'h'); case KC_I: return (shifted ? 'I' : 'i'); case KC_J: return (shifted ? 'J' : 'j'); case KC_K: return (shifted ? 'K' : 'k'); case KC_L: return (shifted ? 'L' : 'l'); case KC_M: return (shifted ? 'M' : 'm'); case KC_N: return (shifted ? 'N' : 'n'); case KC_O: return (shifted ? 'O' : 'o'); case KC_P: return (shifted ? 'P' : 'p'); case KC_Q: return (shifted ? 'Q' : 'q'); case KC_R: return (shifted ? 'R' : 'r'); case KC_S: return (shifted ? 'S' : 's'); case KC_T: return (shifted ? 'T' : 't'); case KC_U: return (shifted ? 'U' : 'u'); case KC_V: return (shifted ? 'V' : 'v'); case KC_W: return (shifted ? 'W' : 'w'); case KC_X: return (shifted ? 'X' : 'x'); case KC_Y: return (shifted ? 'Y' : 'y'); case KC_Z: return (shifted ? 'Z' : 'z'); case KC_1: return (shifted ? '!' : '1'); case KC_2: return (shifted ? '@' : '2'); case KC_3: return (shifted ? '#' : '3'); case KC_4: return (shifted ? '$' : '4'); case KC_5: return (shifted ? '%' : '5'); case KC_6: return (shifted ? '^' : '6'); case KC_7: return (shifted ? '&' : '7'); case KC_8: return (shifted ? '*' : '8'); case KC_9: return (shifted ? '(' : '9'); case KC_0: return (shifted ? ')' : '0'); case KC_ENTER: return '\n'; case KC_ESCAPE: return 0x1B; case KC_BSPACE: return '\b'; case KC_TAB: return '\t'; case KC_SPACE: return ' '; case KC_MINUS: return (shifted ? '_' : '-'); case KC_EQUAL: return (shifted ? '+' : '='); case KC_LBRACKET: return (shifted ? '{' : '['); case KC_RBRACKET: return (shifted ? '}' : ']'); case KC_BSLASH: return (shifted ? '|' : '\\'); case KC_NONUS_HASH: return (shifted ? '|' : '\\'); case KC_SCOLON: return (shifted ? ':' : ';'); case KC_QUOTE: return (shifted ? '"' : '\''); case KC_GRAVE: return (shifted ? '~' : '`'); case KC_COMMA: return (shifted ? '<' : ','); case KC_DOT: return (shifted ? '>' : '.'); case KC_SLASH: return (shifted ? '?' : '/'); case KC_DELETE: return '\0'; // Delete to disconnect default: return ' '; } }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case ADJUST: if (record->event.pressed) { layer_on(_ADJUST); } else { layer_off(_ADJUST); } return false; break; //led operations - RGB mode change now updates the RGB_current_mode to allow the right RGB mode to be set after reactive keys are released case RGBRST: #ifdef RGBLIGHT_ENABLE if (record->event.pressed) { eeconfig_update_rgblight_default(); rgblight_enable(); rgblight_mode(14); } #endif break; case KC_SCLN: if (keyboard_report->mods & MOD_BIT(KC_LSFT)) { if (record->event.pressed) { unregister_code(KC_LSFT); register_code(KC_SCLN); unregister_code(KC_SCLN); register_code(KC_LSFT); } } else if (keyboard_report->mods & MOD_BIT(KC_RSFT)) { if (record->event.pressed) { unregister_code(KC_RSFT); register_code(KC_SCLN); unregister_code(KC_SCLN); register_code(KC_RSFT); } } else { if (record->event.pressed) { register_code(KC_LSFT); register_code(KC_SCLN); unregister_code(KC_SCLN); unregister_code(KC_LSFT); } } return false; break; case KC_QUOT: if (keyboard_report->mods & MOD_BIT(KC_LSFT)) { if (record->event.pressed) { unregister_code(KC_LSFT); register_code(KC_QUOT); unregister_code(KC_QUOT); register_code(KC_LSFT); } } else if (keyboard_report->mods & MOD_BIT(KC_RSFT)) { if (record->event.pressed) { unregister_code(KC_RSFT); register_code(KC_QUOT); unregister_code(KC_QUOT); register_code(KC_RSFT); } } else { if (record->event.pressed) { register_code(KC_LSFT); register_code(KC_QUOT); unregister_code(KC_QUOT); unregister_code(KC_LSFT); } } return false; break; case KC_00: if (record->event.pressed) { SEND_STRING("00"); } return false; break; case RGB_RIPPLE: // if (record->event.pressed) { // ripple = true; // } return false; break; } return true; }
bool process_record_user (uint16_t keycode, keyrecord_t *record) { uint16_t root_note = MIDI_INVALID_NOTE; // Starting value for the root note of each chord switch(keycode) { // Miscellaneous Keycodes case MAGSYS: //Magic SysRq function - Toggles key on and off depending on state of LALT key if (record->event.pressed) { if (keyboard_report->mods & (MOD_BIT(KC_LALT))) { unregister_code(KC_PSCR); unregister_code(KC_LALT); } else { register_code(KC_LALT); register_code(KC_PSCR); } } break; case MC_LSFT ... MC_RSFT: if (record->event.pressed) { mc_shift_on = true; } else { mc_shift_on = false; } break; // MIDI Chord Keycodes case MI_CH_C ... MI_CH_B: // Major Chords root_note = keycode - MI_CH_C + MI_C; process_midi(root_note, record); process_midi(root_note + 4, record); // Major Third Note process_midi(root_note + 7, record); // Fifth Note break; case MI_CH_Cm ... MI_CH_Bm: // Minor Chord root_note = keycode - MI_CH_Cm + MI_C; process_midi(root_note, record); process_midi(root_note + 3, record); // Minor Third Note process_midi(root_note + 7, record); // Fifth Note break; case MI_CH_CDom7 ... MI_CH_BDom7: // Dominant 7th Chord root_note = keycode - MI_CH_CDom7 + MI_C; process_midi(root_note, record); process_midi(root_note + 4, record); // Major Third Note process_midi(root_note + 10, record); // Minor Seventh Note break; case MI_CH_CDim7 ... MI_CH_BDim7: // Diminished 7th Chord root_note = keycode - MI_CH_CDim7 + MI_C; process_midi(root_note, record); process_midi(root_note + 3, record); // Minor Third Note process_midi(root_note - 3, record); // Diminished 7th Note break; } return true; }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { static bool lshift = false; static bool rshift = false; static uint8_t layer = 0; lshift = keyboard_report->mods & MOD_BIT(KC_LSFT); rshift = keyboard_report->mods & MOD_BIT(KC_RSFT); layer = biton32(layer_state); #ifdef DOUBLESPACE_LAYER_ENABLE // double-space: send space immediately if any other key depressed before space is released if ((lspace_active ^ rspace_active) && keycode != LSPACE && keycode != RSPACE && record->event.pressed) { if (lspace_active) { if (!lspace_emitted) { register_code(KC_SPC); unregister_code(KC_SPC); } lspace_emitted = true; } if (rspace_active) { if (!rspace_emitted) { register_code(KC_SPC); unregister_code(KC_SPC); } rspace_emitted = true; } } if (layer == _SPACE && keycode != S(KC_TAB) && keycode != KC_TAB && keycode != KC_ESC && keycode != XXXXXXX) { if (record->event.pressed) { unregister_code(KC_LALT); } else { register_code(KC_LALT); } } #endif switch (keycode) { #ifdef DOUBLESPACE_LAYER_ENABLE // double-space enter space layer case LSPACE: process_doublespace(record->event.pressed, &lspace_active, &rspace_active, &lspace_emitted); return false; break; case RSPACE: process_doublespace(record->event.pressed, &rspace_active, &lspace_active, &rspace_emitted); return false; break; #endif // handle greek layer shift case KC_LSFT: case KC_RSFT: ; if (layer == _GREEKU || layer == _GREEKL) { if (record->event.pressed) { layer_on(_GREEKU); layer_off(_GREEKL); } else { if (lshift ^ rshift) { // if only one shift was pressed layer_on(_GREEKL); layer_off(_GREEKU); } } } return true; break; // press both ctrls to activate SYS layer case KC_LCTL: case KC_RCTL: ; bool lctrl = keyboard_report->mods & MOD_BIT(KC_LCTL); bool rctrl = keyboard_report->mods & MOD_BIT(KC_RCTL); if (record->event.pressed) { if (lctrl ^ rctrl) { // if only one ctrl was pressed layer_on(_SYS); } } else { layer_off(_SYS); } return true; break; // QWERTZ style comma and dot: semicolon and colon when shifted case KC_COMM: if (record->event.pressed) { if (lshift || rshift) { if (lshift) unregister_code(KC_LSFT); if (rshift) unregister_code(KC_RSFT); register_code(KC_SCLN); unregister_code(KC_SCLN); if (lshift) register_code(KC_LSFT); if (rshift) register_code(KC_RSFT); } else { register_code(KC_COMM); unregister_code(KC_COMM); } } return false; break; case KC_DOT: if (record->event.pressed) { if ((keyboard_report->mods & MOD_BIT(KC_LSFT)) || (keyboard_report->mods & MOD_BIT(KC_RSFT))) { register_code(KC_SCLN); unregister_code(KC_SCLN); } else { register_code(KC_DOT); unregister_code(KC_DOT); } } return false; break; // layout switchers case QWERTY: if (record->event.pressed) { persistent_default_layer_set(1UL<<_QWERTY); } return false; break; #ifdef LAYOUT_DVORAK case DVORAK: if (record->event.pressed) { persistent_default_layer_set(1UL<<_DVORAK); } return false; break; #endif #ifdef LAYOUT_COLEMAK case COLEMAK: if (record->event.pressed) { persistent_default_layer_set(1UL<<_COLEMAK); } return false; break; #endif #ifdef LAYOUT_WORKMAN case WORKMAN: if (record->event.pressed) { persistent_default_layer_set(1UL<<_WORKMAN); } return false; break; #endif #ifdef LAYOUT_NORMAN case NORMAN: if (record->event.pressed) { persistent_default_layer_set(1UL<<_NORMAN); } return false; break; #endif // only process Fnumber on key release, and only when layer switcher is still pressed. // this is to avoid accidental presses on potentially destructive keys case KC_F1 ... KC_F12: case KC_PAUS: case KC_PSCR: case KC_INS: if (!record->event.pressed && layer == _FUN) { // key released and still in FUN layer register_code(keycode); unregister_code(keycode); } return false; break; // layer switcher // case GREEK: if (record->event.pressed) { if (lshift || rshift) { layer_on(_GREEKU); layer_off(_GREEKL); } else { layer_on(_GREEKL); layer_off(_GREEKU); } } else { layer_off(_GREEKU); layer_off(_GREEKL); } return false; break; // OS switchers case LINUX: set_unicode_input_mode(UC_LNX); #ifdef RGBSPS_ENABLE led_set_unicode_input_mode(); #endif return false; break; case WIN: set_unicode_input_mode(UC_WINC); #ifdef RGBSPS_ENABLE led_set_unicode_input_mode(); #endif return false; break; case OSX: set_unicode_input_mode(UC_OSX); #ifdef RGBSPS_ENABLE led_set_unicode_input_mode(); #endif return false; break; // glow mode changer #ifdef RGBSPS_ENABLE case GLOW: if (record->event.pressed) { glow_mode++; if (glow_mode > GLOW_FULL) { glow_mode = GLOW_NONE; } led_reset(); rgbsps_send(); } return false; break; #endif // faux clicky indicator #ifdef FAUXCLICKY_ENABLE case FC_TOG: #ifdef RGBSPS_ENABLE if (fauxclicky_enabled) { rgbsps_set(LED_IND_AUDIO, THEME_COLOR_AUDIO); } else { rgbsps_set(LED_IND_AUDIO, COLOR_BLANK); } rgbsps_send(); #endif return true; break; #endif #ifdef RGBSPS_DEMO_ENABLE case RGBDEMO: led_demo(); return false; break; #endif } return true; }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { #ifdef CFQ_USE_DYNAMIC_MACRO if (!process_record_dynamic_macro(keycode, record)) { return false; } #endif switch (keycode) { /* dynamically generate these. */ case RGB_SLD: if (record->event.pressed) { #ifdef RGBLIGHT_ENABLE rgblight_mode(1); #endif } return false; break; case M_BRACKET_IN_CBR: /* {} */ if (record->event.pressed) { SEND_STRING("{}" SS_TAP(X_LEFT)); return false; } break; case M_BRACKET_IN_PRN: /* () */ if (record->event.pressed) { SEND_STRING("()" SS_TAP(X_LEFT)); return false; } break; case M_BRACKET_IN_BRC: /* [] */ if (record->event.pressed) { SEND_STRING("[]" SS_TAP(X_LEFT)); return false; } break; case M_BRACKET_IN_ANG: /* <> */ if (record->event.pressed) { SEND_STRING("<>" SS_TAP(X_LEFT)); return false; } break; case M_BRACKET_OUT_CBR: /* }{ */ if (record->event.pressed) { SEND_STRING("}{" SS_TAP(X_LEFT)); return false; } break; case M_BRACKET_OUT_PRN: /* )( */ if (record->event.pressed) { SEND_STRING(")(" SS_TAP(X_LEFT)); return false; } break; case M_BRACKET_OUT_BRC: /* ][ */ if (record->event.pressed) { SEND_STRING("][" SS_TAP(X_LEFT)); return false; } break; case M_BRACKET_OUT_ANG: /* >< */ if (record->event.pressed) { SEND_STRING("><" SS_TAP(X_LEFT)); return false; } break; case M_ARROW_LMINUS: /* <- */ if (record->event.pressed) { SEND_STRING("<-"); return false; } break; case M_ARROW_RMINUS: /* -> */ if (record->event.pressed) { SEND_STRING("->"); return false; } break; case M_ARROW_LEQL: /* <= */ if (record->event.pressed) { SEND_STRING("<="); return false; } break; case M_ARROW_REQL: /* => */ if (record->event.pressed) { SEND_STRING("=>"); return false; } break; #ifdef CFQ_USE_SHIFT_QUOTES case KC_LSHIFT: /* '' */ if (record->event.pressed && (keyboard_report->mods & (MOD_BIT(KC_RSFT)))) { WITHOUT_MODS({ SEND_STRING("''" SS_TAP(X_LEFT) SS_DOWN(X_RSHIFT) SS_DOWN(X_LSHIFT)); }); 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(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; } }
void matrix_scan_user(void) { if(spam_space && !(get_mods() & (MOD_BIT(KC_LGUI)))){ register_code(KC_SPC); unregister_code(KC_SPC); } }
void action_macro_play(const macro_t *macro_p) { macro_t macro = END; uint8_t interval = 0; uint8_t mod_storage = 0; if (!macro_p) return; while (true) { switch (MACRO_READ()) { case KEY_DOWN: MACRO_READ(); dprintf("KEY_DOWN(%02X)\n", macro); if (IS_MOD(macro)) { add_weak_mods(MOD_BIT(macro)); send_keyboard_report(); } else { register_code(macro); } break; case KEY_UP: MACRO_READ(); dprintf("KEY_UP(%02X)\n", macro); if (IS_MOD(macro)) { del_weak_mods(MOD_BIT(macro)); send_keyboard_report(); } else { unregister_code(macro); } break; case WAIT: MACRO_READ(); dprintf("WAIT(%u)\n", macro); { uint8_t ms = macro; while (ms--) wait_ms(1); } break; case INTERVAL: interval = MACRO_READ(); dprintf("INTERVAL(%u)\n", interval); break; case MOD_STORE: mod_storage = get_mods(); break; case MOD_RESTORE: set_mods(mod_storage); send_keyboard_report(); break; case MOD_CLEAR: clear_mods(); send_keyboard_report(); break; case 0x04 ... 0x73: dprintf("DOWN(%02X)\n", macro); register_code(macro); break; case 0x84 ... 0xF3: dprintf("UP(%02X)\n", macro); unregister_code(macro&0x7F); break; case END: default: return; } // interval { uint8_t ms = interval; while (ms--) wait_ms(1); } } }
void action_function(keyrecord_t *event, uint8_t id, uint8_t opt) { #ifdef AUDIO_ENABLE int8_t sign = 1; #endif if(id == LFK_ESC_TILDE){ // Send ~ on shift-esc void (*method)(uint8_t) = (event->event.pressed) ? &add_key : &del_key; uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)); if(layer_state == 0){ method(shifted ? KC_GRAVE : KC_ESCAPE); }else{ method(shifted ? KC_ESCAPE : KC_GRAVE); } send_keyboard_report(); }else if(event->event.pressed){ switch(id){ case LFK_SET_DEFAULT_LAYER: // set/save the current base layer to eeprom, falls through to LFK_CLEAR eeconfig_update_default_layer(1UL << opt); default_layer_set(1UL << opt); case LFK_CLEAR: // Go back to default layer layer_clear(); break; #ifdef ISSI_ENABLE case LFK_LED_TEST: led_test(); break; #endif #ifdef AUDIO_ENABLE case LFK_CLICK_FREQ_LOWER: sign = -1; // continue to next statement case LFK_CLICK_FREQ_HIGHER: click_hz += sign * 100; click(click_hz, click_time); break; case LFK_CLICK_TOGGLE: if(click_toggle){ click_toggle = 0; click(4000, 100); click(1000, 100); }else{ click_toggle = 1; click(1000, 100); click(4000, 100); } break; case LFK_CLICK_TIME_SHORTER: sign = -1; // continue to next statement case LFK_CLICK_TIME_LONGER: click_time += sign; click(click_hz, click_time); break; #endif case LFK_DEBUG_SETTINGS: dprintf("Click:\n"); dprintf(" toggle: %d\n", click_toggle); dprintf(" freq(hz): %d\n", click_hz); dprintf(" duration(ms): %d\n", click_time); break; } } }
bool process_record_user( uint16_t keycode, keyrecord_t *record ){ /* Start of key tap RGB effect */ if ( RGB_TAP_STATE ==true ) { key_index=(record->event.key.col)+(record->event.key.row)*12; /* Change the Hue of the RGB color with the type speed */ if (timer_elapsed(TAP_RGB_timer) >10000){ TAP_RGB_timer=timer_read(); Type_Hue=270; }else if (timer_elapsed(TAP_RGB_timer) >1000){ Type_Hue+=30; if (Type_Hue>270) { Type_Hue=270;} }else{ TAP_RGB_timer=timer_read(); Type_Hue-=10; if (Type_Hue<10) { Type_Hue=10;} } if (key_index>42){ //fix the RGB index of the MIT layout position key_index=key_index-1; } if ( record->event.pressed ) { rgblight_sethsv_at(Type_Hue,255,255,key_index); } else { rgblight_setrgb_at(RGB_TAP_Base_Color,key_index); } } /* End of key tap RGB effect */ switch ( keycode ) { /* save the RGB state when set the new */ case RGB_M_R: save_rgbmode = true; break; case RGB_M_SW: save_rgbmode = true; break; case RGB_M_X: save_rgbmode = true; break; case RGB_M_G: save_rgbmode = true; break; case RGB_MODE_KNIGHT: save_rgbmode = true; break; /* Define a New Keycode: double zero */ case KC_00: if (record->event.pressed) { // Do something when pressed } else { tap_code( KC_0 ); // send 0 tap_code( KC_0 ); // send 0 twice without macro } return false; // Skip all further processing of this key /* when the REST key is pressed the 'R' key will RED,the "Bottom Left"(esc of qmk-dfu) will be GREEN */ case RESET: rgblight_mode( 1 ); rgblight_setrgb( 0, 0, 0 ); rgblight_setrgb_at(128, 0, 0,4); // R rgblight_setrgb_at(6, 128, 24,36); // Bottom Left key break; /* Define a New Keycode: key tap RGB effect toggle */ case RGB_TAP: if ( !(record->event.pressed)) { /* If enable,the 'On' key will be green */ if (RGB_TAP_STATE) { RGB_TAP_STATE=false; rgblight_mode( 1 ); rgblight_setrgb( RGB_TAP_Base_Color ); rgblight_setrgb_at(RGB_TAP_Off_Color,16); // O - on }else{ /* If disenable,the 'oFf' key will be red */ RGB_TAP_STATE=true; rgblight_mode( 1 ); rgblight_setrgb( RGB_TAP_Base_Color ); rgblight_setrgb_at(RGB_TAP_On_Color,9); // F - off } } break; /* special shift keys */ case KC_ENT: s_keycode = KC_QUOT; k_shifted = &ques_shifted; break; case KC_UP: s_keycode = KC_SLSH; k_shifted = &ques_shifted; break; case KC_DOWN: s_keycode = KC_BSLS; k_shifted = &ques_shifted; break; default: return(true); } shifted = get_mods() & (MOD_BIT( KC_LSHIFT ) | MOD_BIT( KC_RSHIFT ) ); /* Keydown. If shift is currently pressed, register its alternate keycode. */ if ( record->event.pressed && shifted ) { *k_shifted = true; register_code( s_keycode ); return(false); /* * Keyup. If shift was pressed back when the key was pressed, unregister * its alternate keycode. */ } else if ( !(record->event.pressed) && *k_shifted ) { *k_shifted = false; unregister_code( s_keycode ); return(false); /* Otherwise, behave as normal. */ } else { return(true); } } // End ofprocess_record_user
void process_register_key(uint8_t code) { dprintf("process_register_key: code=%X\n", code); if (code == KC_LAMBDA) { dprintf(" lambda\n"); lambda_pressed = 1; } else if (code == KC_TILDE) { dprintf(" tilde\n"); add_mods(MOD_BIT(KC_LSFT)); add_key(KC_TLDE_S); send_keyboard_report(); } else if (code == KC_EXCLAM) { dprintf(" exclam\n"); add_mods(MOD_BIT(KC_LSFT)); add_key(KC_EXCL_S); send_keyboard_report(); } else if (code == KC_AT_SIGN) { dprintf(" at_sign\n"); add_mods(MOD_BIT(KC_LSFT)); add_key(KC_ATSI_S); send_keyboard_report(); } else if (code == KC_NUMBER_SIGN) { dprintf(" num_sign\n"); add_mods(MOD_BIT(KC_LSFT)); add_key(KC_NUSI_S); send_keyboard_report(); } else if (code == KC_DOLLAR_SIGN) { add_mods(MOD_BIT(KC_LSFT)); add_key(KC_DOSI_S); send_keyboard_report(); } else if (code == KC_PERCENT) { add_mods(MOD_BIT(KC_LSFT)); add_key(KC_PCNT_S); send_keyboard_report(); } else if (code == KC_CARET) { add_mods(MOD_BIT(KC_LSFT)); add_key(KC_CART_S); send_keyboard_report(); } else if (code == KC_AMPERSTAND) { add_mods(MOD_BIT(KC_LSFT)); add_key(KC_AMPT_S); send_keyboard_report(); } else if (code == KC_ASTERISK) { add_mods(MOD_BIT(KC_LSFT)); add_key(KC_ASTK_S); send_keyboard_report(); } else if (code == KC_LPARENT) { add_mods(MOD_BIT(KC_LSFT)); add_key(KC_LPAR_S); send_keyboard_report(); } else if (code == KC_RPARENT) { add_mods(MOD_BIT(KC_LSFT)); add_key(KC_RPAR_S); send_keyboard_report(); } else if (code == KC_UNDERSCORE) { add_mods(MOD_BIT(KC_LSFT)); add_key(KC_UNDS_S); send_keyboard_report(); } else if (code == KC_PLUS) { add_mods(MOD_BIT(KC_LSFT)); add_key(KC_PLUS_S); send_keyboard_report(); } else if (code == KC_LCBRACKET) { add_mods(MOD_BIT(KC_LSFT)); add_key(KC_LCBR_S); send_keyboard_report(); } else if (code == KC_RCBRACKET) { add_mods(MOD_BIT(KC_LSFT)); add_key(KC_RCBR_S); send_keyboard_report(); } else if (code == KC_PIPE) { add_mods(MOD_BIT(KC_LSFT)); add_key(KC_PIPE_S); send_keyboard_report(); } else if (code == KC_DOUBLE_QUOTE) { add_mods(MOD_BIT(KC_LSFT)); add_key(KC_DQUO_S); send_keyboard_report(); } else { add_key(code); send_keyboard_report(); } }
void mod_reset_fn(qk_tap_dance_state_t *state, void *user_data) { layer_off(_L1); layer_off(_L2); unregister_mods(MOD_BIT(tap_dance_keys[state->keycode - QK_TAP_DANCE])); send_keyboard_report(); }
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 (!( 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 #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 UNICODEMAP_ENABLE process_unicode_map(keycode, record) && #endif true)) { return false; } // Shift / paren setup switch(keycode) { case RESET: if (record->event.pressed) { reset_keyboard(); } return false; break; case DEBUG: if (record->event.pressed) { print("\nDEBUG: enabled.\n"); debug_enable = true; } return false; break; #ifdef FAUXCLICKY_ENABLE case FC_TOG: if (record->event.pressed) { FAUXCLICKY_TOGGLE; } return false; break; case FC_ON: if (record->event.pressed) { FAUXCLICKY_ON; } return false; break; case FC_OFF: if (record->event.pressed) { FAUXCLICKY_OFF; } return false; break; #endif #ifdef RGBLIGHT_ENABLE case RGB_TOG: if (record->event.pressed) { rgblight_toggle(); } return false; break; case RGB_MOD: if (record->event.pressed) { rgblight_step(); } return false; break; case RGB_HUI: if (record->event.pressed) { rgblight_increase_hue(); } return false; break; case RGB_HUD: if (record->event.pressed) { rgblight_decrease_hue(); } return false; break; case RGB_SAI: if (record->event.pressed) { rgblight_increase_sat(); } return false; break; case RGB_SAD: if (record->event.pressed) { rgblight_decrease_sat(); } return false; break; case RGB_VAI: if (record->event.pressed) { rgblight_increase_val(); } return false; break; case RGB_VAD: if (record->event.pressed) { rgblight_decrease_val(); } return false; break; #endif #ifdef PROTOCOL_LUFA case OUT_AUTO: if (record->event.pressed) { set_output(OUTPUT_AUTO); } return false; break; case OUT_USB: if (record->event.pressed) { set_output(OUTPUT_USB); } return false; break; #ifdef BLUETOOTH_ENABLE case OUT_BT: if (record->event.pressed) { set_output(OUTPUT_BLUETOOTH); } return false; break; #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; 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; 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; // break; } 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; // break; } case GRAVE_ESC: { void (*method)(uint8_t) = (record->event.pressed) ? &add_key : &del_key; uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT) |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))); method(shifted ? KC_GRAVE : KC_ESCAPE); send_keyboard_report(); } default: { shift_interrupted[0] = true; shift_interrupted[1] = true; break; } } return process_action_kb(record); }
void kput_char(char c) { uint8_t code = 0; uint8_t mods = 0; if ('a' <= c && c <= 'z') { code = (c - 'a') + KC_A; } else if ('A' <= c && c <= 'Z') { code = (c - 'A') + KC_A; mods = MOD_BIT(KC_LSHIFT); } else if ('0' <= c && c <= '9') { code = (c == '0') ? KC_0 : (c - '1') + KC_1; } else { switch (c) { case ' ': code = KC_SPACE; break; case '\n': code = KC_ENTER; break; case '\t': code = KC_TAB; break; case ';': code = KC_SCOLON; break; case ',': code = KC_COMMA; break; case '.': code = KC_DOT; break; case '/': code = KC_SLASH; break; case '\\': code = KC_BSLASH; break; case '[': code = KC_LBRACKET; break; case ']': code = KC_RBRACKET; break; case '-': code = KC_MINUS; break; case '=': code = KC_EQUAL; break; case '`': code = KC_GRAVE; break; case '\'': code = KC_QUOTE; break; } if (!code) { switch (c) { case ':': code = KC_SCOLON; break; case '<': code = KC_COMMA; break; case '>': code = KC_DOT; break; case '?': code = KC_SLASH; break; case '|': code = KC_BSLASH; break; case '{': code = KC_LBRACKET; break; case '}': code = KC_RBRACKET; break; case '_': code = KC_MINUS; break; case '+': code = KC_EQUAL; break; case '~': code = KC_GRAVE; break; case '"': code = KC_QUOTE; break; case '!': code = KC_1; break; case '@': code = KC_2; break; case '#': code = KC_3; break; case '$': code = KC_4; break; case '%': code = KC_5; break; case '^': code = KC_6; break; case '&': code = KC_7; break; case '*': code = KC_8; break; case '(': code = KC_9; break; case ')': code = KC_0; break; } mods = code ? MOD_BIT(KC_LSHIFT) : 0; } } if (!code) { code = KC_SLASH; mods = MOD_BIT(KC_LSHIFT); } // key down add_weak_mods(mods); register_code(code); wait_ms(KPRINT_DELAY); // key up del_weak_mods(mods); unregister_code(code); /* send_keyboard_report(); */ }
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 (!( process_record_kb(keycode, record) && #ifdef MIDI_ENABLE process_midi(keycode, record) && #endif #ifdef AUDIO_ENABLE 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 UNICODE_ENABLE process_unicode(keycode, record) && #endif #ifdef UCIS_ENABLE process_ucis(keycode, record) && #endif true)) { return false; } // Shift / paren setup switch(keycode) { case RESET: if (record->event.pressed) { reset_keyboard(); } return false; break; case DEBUG: if (record->event.pressed) { print("\nDEBUG: enabled.\n"); debug_enable = true; } return false; break; #ifdef RGBLIGHT_ENABLE case RGB_TOG: if (record->event.pressed) { rgblight_toggle(); } return false; break; case RGB_MOD: if (record->event.pressed) { rgblight_step(); } return false; break; case RGB_HUI: if (record->event.pressed) { rgblight_increase_hue(); } return false; break; case RGB_HUD: if (record->event.pressed) { rgblight_decrease_hue(); } return false; break; case RGB_SAI: if (record->event.pressed) { rgblight_increase_sat(); } return false; break; case RGB_SAD: if (record->event.pressed) { rgblight_decrease_sat(); } return false; break; case RGB_VAI: if (record->event.pressed) { rgblight_increase_val(); } return false; break; case RGB_VAD: if (record->event.pressed) { rgblight_decrease_val(); } return false; break; #endif case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_UNSWAP_ALT_GUI: if (record->event.pressed) { // MAGIC actions (BOOTMAGIC without the boot) if (!eeconfig_is_enabled()) { eeconfig_init(); } /* keymap config */ keymap_config.raw = eeconfig_read_keymap(); if (keycode == MAGIC_SWAP_CONTROL_CAPSLOCK) { keymap_config.swap_control_capslock = 1; } else if (keycode == MAGIC_CAPSLOCK_TO_CONTROL) { keymap_config.capslock_to_control = 1; } else if (keycode == MAGIC_SWAP_LALT_LGUI) { keymap_config.swap_lalt_lgui = 1; } else if (keycode == MAGIC_SWAP_RALT_RGUI) { keymap_config.swap_ralt_rgui = 1; } else if (keycode == MAGIC_NO_GUI) { keymap_config.no_gui = 1; } else if (keycode == MAGIC_SWAP_GRAVE_ESC) { keymap_config.swap_grave_esc = 1; } else if (keycode == MAGIC_SWAP_BACKSLASH_BACKSPACE) { keymap_config.swap_backslash_backspace = 1; } else if (keycode == MAGIC_HOST_NKRO) { keymap_config.nkro = 1; } else if (keycode == MAGIC_SWAP_ALT_GUI) { keymap_config.swap_lalt_lgui = 1; keymap_config.swap_ralt_rgui = 1; } /* UNs */ else if (keycode == MAGIC_UNSWAP_CONTROL_CAPSLOCK) { keymap_config.swap_control_capslock = 0; } else if (keycode == MAGIC_UNCAPSLOCK_TO_CONTROL) { keymap_config.capslock_to_control = 0; } else if (keycode == MAGIC_UNSWAP_LALT_LGUI) { keymap_config.swap_lalt_lgui = 0; } else if (keycode == MAGIC_UNSWAP_RALT_RGUI) { keymap_config.swap_ralt_rgui = 0; } else if (keycode == MAGIC_UNNO_GUI) { keymap_config.no_gui = 0; } else if (keycode == MAGIC_UNSWAP_GRAVE_ESC) { keymap_config.swap_grave_esc = 0; } else if (keycode == MAGIC_UNSWAP_BACKSLASH_BACKSPACE) { keymap_config.swap_backslash_backspace = 0; } else if (keycode == MAGIC_UNHOST_NKRO) { keymap_config.nkro = 0; } else if (keycode == MAGIC_UNSWAP_ALT_GUI) { keymap_config.swap_lalt_lgui = 0; keymap_config.swap_ralt_rgui = 0; } eeconfig_update_keymap(keymap_config.raw); return false; } break; case KC_LSPO: { if (record->event.pressed) { shift_interrupted[0] = false; 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]) { register_code(LSPO_KEY); unregister_code(LSPO_KEY); } unregister_mods(MOD_BIT(KC_LSFT)); } return false; break; } case KC_RSPC: { if (record->event.pressed) { shift_interrupted[1] = false; 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]) { register_code(RSPC_KEY); unregister_code(RSPC_KEY); } unregister_mods(MOD_BIT(KC_RSFT)); } return false; break; } default: { shift_interrupted[0] = true; shift_interrupted[1] = true; break; } } return process_action_kb(record); }
static inline void qk_register_weak_mods(uint8_t kc) { add_weak_mods(MOD_BIT(kc)); send_keyboard_report(); }
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) 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 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key); #endif // 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 (!( process_record_kb(keycode, record) && #ifdef MIDI_ENABLE process_midi(keycode, record) && #endif #ifdef AUDIO_ENABLE 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 UNICODE_ENABLE process_unicode(keycode, record) && #endif true)) { return false; } // Shift / paren setup switch(keycode) { case RESET: if (record->event.pressed) { 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(); return false; } break; case DEBUG: if (record->event.pressed) { print("\nDEBUG: enabled.\n"); debug_enable = true; return false; } break; case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_UNSWAP_ALT_GUI: if (record->event.pressed) { // MAGIC actions (BOOTMAGIC without the boot) if (!eeconfig_is_enabled()) { eeconfig_init(); } /* keymap config */ keymap_config.raw = eeconfig_read_keymap(); if (keycode == MAGIC_SWAP_CONTROL_CAPSLOCK) { keymap_config.swap_control_capslock = 1; } else if (keycode == MAGIC_CAPSLOCK_TO_CONTROL) { keymap_config.capslock_to_control = 1; } else if (keycode == MAGIC_SWAP_LALT_LGUI) { keymap_config.swap_lalt_lgui = 1; } else if (keycode == MAGIC_SWAP_RALT_RGUI) { keymap_config.swap_ralt_rgui = 1; } else if (keycode == MAGIC_NO_GUI) { keymap_config.no_gui = 1; } else if (keycode == MAGIC_SWAP_GRAVE_ESC) { keymap_config.swap_grave_esc = 1; } else if (keycode == MAGIC_SWAP_BACKSLASH_BACKSPACE) { keymap_config.swap_backslash_backspace = 1; } else if (keycode == MAGIC_HOST_NKRO) { keymap_config.nkro = 1; } else if (keycode == MAGIC_SWAP_ALT_GUI) { keymap_config.swap_lalt_lgui = 1; keymap_config.swap_ralt_rgui = 1; } /* UNs */ else if (keycode == MAGIC_UNSWAP_CONTROL_CAPSLOCK) { keymap_config.swap_control_capslock = 0; } else if (keycode == MAGIC_UNCAPSLOCK_TO_CONTROL) { keymap_config.capslock_to_control = 0; } else if (keycode == MAGIC_UNSWAP_LALT_LGUI) { keymap_config.swap_lalt_lgui = 0; } else if (keycode == MAGIC_UNSWAP_RALT_RGUI) { keymap_config.swap_ralt_rgui = 0; } else if (keycode == MAGIC_UNNO_GUI) { keymap_config.no_gui = 0; } else if (keycode == MAGIC_UNSWAP_GRAVE_ESC) { keymap_config.swap_grave_esc = 0; } else if (keycode == MAGIC_UNSWAP_BACKSLASH_BACKSPACE) { keymap_config.swap_backslash_backspace = 0; } else if (keycode == MAGIC_UNHOST_NKRO) { keymap_config.nkro = 0; } else if (keycode == MAGIC_UNSWAP_ALT_GUI) { keymap_config.swap_lalt_lgui = 0; keymap_config.swap_ralt_rgui = 0; } eeconfig_update_keymap(keymap_config.raw); return false; } break; case KC_LSPO: { if (record->event.pressed) { shift_interrupted[0] = false; register_mods(MOD_BIT(KC_LSFT)); } else { if (!shift_interrupted[0]) { register_code(LSPO_KEY); unregister_code(LSPO_KEY); } unregister_mods(MOD_BIT(KC_LSFT)); } return false; break; } case KC_RSPC: { if (record->event.pressed) { shift_interrupted[1] = false; register_mods(MOD_BIT(KC_RSFT)); } else { if (!shift_interrupted[1]) { register_code(RSPC_KEY); unregister_code(RSPC_KEY); } unregister_mods(MOD_BIT(KC_RSFT)); } return false; break; } default: { shift_interrupted[0] = true; shift_interrupted[1] = true; break; } } return process_action_kb(record); }