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); } else { unregister_code(KC_RSFT); } break; } return MACRO_NONE; };
void dance_cln_reset( qk_tap_dance_state_t* state, void* user_data ) { if ( state->count == 1 ) { unregister_code( KC_LSFT ); }else { uint8_t layer = biton32( layer_state ); if ( layer == _SYMB ) { layer_off( _SYMB ); rgblight_mode( RGB_LAYER0_mode ); } } }
void unicode_action_function(uint16_t hi, uint16_t lo) { switch (unicode_mode) { case UC_MODE_WIN: register_code(KC_LALT); register_code(KC_PPLS); unregister_code(KC_PPLS); register_code(hextokeycode((hi & 0xF0) >> 4)); unregister_code(hextokeycode((hi & 0xF0) >> 4)); register_code(hextokeycode((hi & 0x0F))); unregister_code(hextokeycode((hi & 0x0F))); register_code(hextokeycode((lo & 0xF0) >> 4)); unregister_code(hextokeycode((lo & 0xF0) >> 4)); register_code(hextokeycode((lo & 0x0F))); unregister_code(hextokeycode((lo & 0x0F))); unregister_code(KC_LALT); break; case UC_MODE_LINUX: register_code(KC_LCTL); register_code(KC_LSFT); register_code(KC_U); unregister_code(KC_U); register_code(hextokeycode((hi & 0xF0) >> 4)); unregister_code(hextokeycode((hi & 0xF0) >> 4)); register_code(hextokeycode((hi & 0x0F))); unregister_code(hextokeycode((hi & 0x0F))); register_code(hextokeycode((lo & 0xF0) >> 4)); unregister_code(hextokeycode((lo & 0xF0) >> 4)); register_code(hextokeycode((lo & 0x0F))); unregister_code(hextokeycode((lo & 0x0F))); unregister_code(KC_LCTL); unregister_code(KC_LSFT); break; case UC_MODE_OSX: break; } }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { //revive dead keys #ifndef DONT_REVIVE_DEADKEYS bool shift_active = keyboard_report->mods & (MOD_BIT(KC_LSFT) | MOD_BIT(KC_LSFT)); bool altgr_active = keyboard_report->mods & (MOD_BIT(KC_RALT)); if ((keycode == KC_QUOT && !altgr_active) || keycode == KC_GRV || (keycode == KC_6 && shift_active)) { if (record->event.pressed) { register_code(keycode); unregister_code(keycode); register_code(KC_SPACE); unregister_code(KC_SPACE); } return false; } #endif #if LANGUAGE == GERMAN return process_german(keycode, record); #else return true; #endif }
bool process_record_keymap(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case QWERTY: if (record->event.pressed) { set_single_persistent_default_layer(_QWERTY); } return false; break; case COLEMAK: if (record->event.pressed) { set_single_persistent_default_layer(_COLEMAK); } return false; break; case LOWER: if (record->event.pressed) { //not sure how to have keyboard check mode and set it to a variable, so my work around //uses another variable that would be set to true after the first time a reactive key is pressed. layer_on(_LOWER); } else { layer_off(_LOWER); } return false; break; case RAISE: if (record->event.pressed) { //not sure how to have keyboard check mode and set it to a variable, so my work around //uses another variable that would be set to true after the first time a reactive key is pressed. layer_on(_RAISE); } else { layer_off(_RAISE); } return false; break; case BACKLIT: if (record->event.pressed) { register_code(KC_RSFT); #ifdef BACKLIGHT_ENABLE backlight_step(); #endif } else { unregister_code(KC_RSFT); } return false; break; } return true; }
static void _process_tap_dance_action_pair (qk_tap_dance_state_t *state, uint16_t kc1, uint16_t kc2) { uint16_t kc; if (state->count == 0) return; kc = (state->count == 1) ? kc1 : kc2; register_code (kc); unregister_code (kc); if (state->count >= 2) { reset_tap_dance (state); } }
void matrix_init_user(void) { // set Numlock LED to output and low DDRF |= (1<<7); PORTF &= ~(1<<7); #ifdef RGBLIGHT_ENABLE rgblight_enable(); rgblight_set_teal; rgblight_mode(1); #endif if (!(host_keyboard_leds() & (1 << USB_LED_NUM_LOCK)) ){ register_code(KC_NUMLOCK); unregister_code(KC_NUMLOCK); } }
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); midi_send_noteon(&midi_device, 1, 64, 127); backlight_step(); } else { unregister_code(KC_RSFT); midi_send_noteoff(&midi_device, 1, 64, 127); } break; } return MACRO_NONE; };
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); #ifdef BACKLIGHT_ENABLE backlight_step(); #endif } else { unregister_code(KC_RSFT); } break; } return MACRO_NONE; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case QWERTY: if (record->event.pressed) { #ifdef AUDIO_ENABLE PLAY_SONG(tone_qwerty); #endif persistent_default_layer_set(1UL<<_QWERTY); } return false; break; case LOWER: if (record->event.pressed) { layer_on(_LOWER); update_tri_layer(_LOWER, _RAISE, _ADJUST); } else { layer_off(_LOWER); update_tri_layer(_LOWER, _RAISE, _ADJUST); } return false; break; case RAISE: if (record->event.pressed) { layer_on(_RAISE); update_tri_layer(_LOWER, _RAISE, _ADJUST); } else { layer_off(_RAISE); update_tri_layer(_LOWER, _RAISE, _ADJUST); } return false; break; case BACKLIT: if (record->event.pressed) { register_code(KC_RSFT); #ifdef BACKLIGHT_ENABLE backlight_step(); #endif } else { unregister_code(KC_RSFT); } return false; break; } return true; }
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); } else { unregister_code(KC_RSFT); } case 3: // this would trigger when you hit a key mapped as M(3) if (record->event.pressed) { return MACRO( I(255), D(LALT), T(P1), T(P5), T(P6), U(LALT), END ); } break; } return MACRO_NONE; };
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { switch(id) { case _QWERTY: if (record->event.pressed) { persistent_default_layer_set(1UL<<_QWERTY); } break; case _NUMPAD: if (record->event.pressed) { persistent_default_layer_set(1UL<<_NUMPAD); } break; case _LOWER: if (record->event.pressed) { layer_on(_LOWER); update_tri_layer(_LOWER, _RAISE, _ADJUST); } else { layer_off(_LOWER); update_tri_layer(_LOWER, _RAISE, _ADJUST); } break; case _RAISE: if (record->event.pressed) { layer_on(_RAISE); update_tri_layer(_LOWER, _RAISE, _ADJUST); } else { layer_off(_RAISE); update_tri_layer(_LOWER, _RAISE, _ADJUST); } break; case M_BL: if (record->event.pressed) { register_code(KC_RSFT); #ifdef BACKLIGHT_ENABLE backlight_step(); #endif } else { unregister_code(KC_RSFT); } break; } return MACRO_NONE; };
// Macro actions for each corresponding ID. const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { switch(id) { case _RAISE: // Raised layer. if (record->event.pressed) { layer_on(_RAISE); update_tri_layer(_LOWER, _RAISE, _CUSTOM); } else { layer_off(_RAISE); update_tri_layer(_LOWER, _RAISE, _CUSTOM); } break; case _LOWER: // Lowered layer. if (record->event.pressed) { layer_on(_LOWER); update_tri_layer(_LOWER, _RAISE, _CUSTOM); } else { layer_off(_LOWER); update_tri_layer(_LOWER, _RAISE, _CUSTOM); } break; case _BL:// Backlight if (record->event.pressed) { register_code(KC_RSFT); #ifdef BACKLIGHT_ENABLE backlight_step(); #endif } else { unregister_code(KC_RSFT); } break; case _MOBILE:// Your mobile# here. return MACRODOWN(T(1), T(2), T(3), T(MINS), T(1), T(2), T(3), T(MINS), T(1), T(2), T(3), T(4), END); case _CUSTOM1:// Your custom macro 1 return MACRODOWN(T(E), T(M), T(A), T(C), T(S), T(SPC), END); case _CUSTOM2:// Your custom macro 2 return MACRODOWN(T(L), T(S), T(SPC), T(MINS), T(L), T(ENT), END); }; return MACRO_NONE; }
// Send PHROPB ({PLOVER:RESUME}). void plover_resume(void) { register_code(PV_LP); register_code(PV_LH); register_code(PV_LR); register_code(PV_O); register_code(PV_RP); register_code(PV_RB); unregister_code(PV_LP); unregister_code(PV_LH); unregister_code(PV_LR); unregister_code(PV_O); unregister_code(PV_RP); unregister_code(PV_RB); }
// Send PHROBG ({PLOVER:LOOKUP}). void plover_lookup(void) { register_code(PV_LP); register_code(PV_LH); register_code(PV_LR); register_code(PV_O); register_code(PV_RB); register_code(PV_RG); unregister_code(PV_LP); unregister_code(PV_LH); unregister_code(PV_LR); unregister_code(PV_O); unregister_code(PV_RB); unregister_code(PV_RG); }
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; } }
// TODO: improve feedback void plover_toggle(void) { // Press "PHROLG" register_code(PV_LP); register_code(PV_LH); register_code(PV_LR); register_code(PV_O); register_code(PV_RL); register_code(PV_RG); // Release "PHROLG" unregister_code(PV_LP); unregister_code(PV_LH); unregister_code(PV_LR); unregister_code(PV_O); unregister_code(PV_RL); unregister_code(PV_RG); }
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { switch(id) { case 0: { static uint8_t code; if (record->event.pressed) { code = (keyboard_report->mods & (MOD_BIT(KC_LSFT) | MOD_BIT(KC_RSFT))) ? KC_GRV : KC_ESC; register_code(code); } else { unregister_code(code); } break; } break; case 1: if (record->event.pressed) { return MACRO( I(5), D(LSFT), T(SCLN), U(LSFT), T(W), T(Q), T(ENT), END ); } break; } return MACRO_NONE; };
/* * user defined action function */ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) { if (record->event.pressed) dprint("P"); else dprint("R"); dprintf("%d", record->tap.count); if (record->tap.interrupted) dprint("i"); dprint("\n"); switch (id) { case LSHIFT_LPAREN: // Shift parentheses example: LShft + tap '(' // http://stevelosh.com/blog/2012/10/a-modern-space-cadet/#shift-parentheses // http://geekhack.org/index.php?topic=41989.msg1304899#msg1304899 if (record->event.pressed) { if (record->tap.count > 0 && !record->tap.interrupted) { if (record->tap.interrupted) { dprint("tap interrupted\n"); register_mods(MOD_BIT(KC_LSHIFT)); } } else { register_mods(MOD_BIT(KC_LSHIFT)); } } else { if (record->tap.count > 0 && !(record->tap.interrupted)) { add_weak_mods(MOD_BIT(KC_LSHIFT)); send_keyboard_report(); register_code(KC_9); unregister_code(KC_9); del_weak_mods(MOD_BIT(KC_LSHIFT)); send_keyboard_report(); record->tap.count = 0; // ad hoc: cancel tap } else { unregister_mods(MOD_BIT(KC_LSHIFT)); } } break; } }
bool process_record_cdeq(uint16_t keycode, keyrecord_t *record) { uint8_t shifted; uint16_t s_keycode; bool *k_shifted; switch (keycode) { case KC_COMM: s_keycode = KC_SLSH; k_shifted = &comm_shifted; break; case KC_DOT: s_keycode = KC_1; 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; } }
void send_keystrokes(uint8_t key, ...) { va_list vl; va_start(vl, key); enum next_key_down_up nkdu = NK_DOWN_UP; while (key != KC_NO) { if (key < KC_A) { nkdu = key; } else { switch (nkdu) { case NK_DOWN_UP: register_code(key); case NK_UP: unregister_code(key); break; case NK_DOWN: register_code(key); } nkdu = NK_DOWN_UP; } key = va_arg(vl, int); } va_end(vl); }
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); } else { unregister_code(KC_RSFT); } break; case 1: if (record->event.pressed) { // For resetting EEPROM eeconfig_init(); } break; case 2: if (record->event.pressed) { // For resetting EEPROM api_send_unicode(0x0CA0); } break; } return MACRO_NONE; };
void toggle_steno(int pressed) { uint8_t layer = biton32(layer_state); if (pressed) { if (layer != STEN) layer_on(STEN); else layer_off(STEN); register_code(PV_LP); register_code(PV_LH); register_code(PV_LR); register_code(PV_O); register_code(PV_RL); register_code(PV_RG); } else { unregister_code(PV_LP); unregister_code(PV_LH); unregister_code(PV_LR); unregister_code(PV_O); unregister_code(PV_RL); unregister_code(PV_RG); } }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case QWERTY: if (record->event.pressed) { #ifdef AUDIO_ENABLE PLAY_SONG(tone_qwerty); #endif persistant_default_layer_set(1UL<<_QWERTY); } return false; break; case LOWER: if (record->event.pressed) { //not sure how to have keyboard check mode and set it to a variable, so my work around //uses another variable that would be set to true after the first time a reactive key is pressed. if (RGB_INIT) {} else { RGB_current_mode = rgblight_config.mode; RGB_INIT = true; } if (TOG_STATUS) { //TOG_STATUS checks is another reactive key currently pressed, only changes RGB mode if returns false } else { TOG_STATUS = !TOG_STATUS; rgblight_mode(16); } layer_on(_LOWER); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); } else { rgblight_mode(RGB_current_mode); // revert RGB to initial mode prior to RGB mode change TOG_STATUS = false; layer_off(_LOWER); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); } return false; break; case RAISE: if (record->event.pressed) { //not sure how to have keyboard check mode and set it to a variable, so my work around //uses another variable that would be set to true after the first time a reactive key is pressed. if (RGB_INIT) {} else { RGB_current_mode = rgblight_config.mode; RGB_INIT = true; } if (TOG_STATUS) { //TOG_STATUS checks is another reactive key currently pressed, only changes RGB mode if returns false } else { TOG_STATUS = !TOG_STATUS; rgblight_mode(15); } layer_on(_RAISE); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); } else { rgblight_mode(RGB_current_mode); // revert RGB to initial mode prior to RGB mode change layer_off(_RAISE); TOG_STATUS = false; update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); } return false; break; case BACKLIT: if (record->event.pressed) { register_code(KC_RSFT); #ifdef BACKLIGHT_ENABLE backlight_step(); #endif } else { unregister_code(KC_RSFT); } return false; break; //my attempt for RGB layer lock indication via changing the mode, still have to figure out how to not have other keypress not override this mode case TG_NUMLAY: if (record->event.pressed) { if (RGB_INIT) {} else { RGB_current_mode = rgblight_config.mode; RGB_INIT = true; } NUMLAY_STATUS = !NUMLAY_STATUS; if (NUMLAY_STATUS) { rgblight_mode(4); layer_on(_NUMLAY); } else { rgblight_mode(RGB_current_mode); layer_off(_NUMLAY); } } return false; break; case RGB_MOD: //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 if (record->event.pressed) { rgblight_mode(RGB_current_mode); rgblight_step(); RGB_current_mode = rgblight_config.mode; } return false; break; } return true; }
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 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(); */ }
void stroke(void) { // Send characters for each key family const uint8_t original_mods = get_mods(); del_mods(MOD_LSFT|MOD_RSFT); bool initial_case_1 = false; bool initial_case_2 = false; undo_command_t new_undo_command; memset(&new_undo_command, 0, sizeof(undo_command_t)); // Get *, + and case controls info const uint8_t special_controls_bits = g_family_bits[FAMILY_SPECIAL_CONTROLS]; const uint8_t thumbs_bits = g_family_bits[FAMILY_THUMBS]; const bool has_star = special_controls_bits & (1 << (SC_STAR & 0xF)); const bool has_plus = special_controls_bits & (1 << (SC_PLUS & 0xF)); const bool has_meta_space = special_controls_bits & (1 << (SC_MSPC & 0xF)); const uint8_t case_controls_bits = g_family_bits[FAMILY_CASE_CONTROLS]; if (case_controls_bits) { initial_case_1 = case_controls_bits == 2; initial_case_2 = case_controls_bits == 3; add_mods(MOD_LSFT); } // Evaluate stroke bool undo_allowed = true; bool no_space_code_detected = false; for (int family_id = 0; family_id < NB_FAMILY; ++family_id) { uint8_t family_bits = g_family_bits[family_id]; if (family_bits == 0) { continue; } // Get the lookup table undo_allowed = family_id == FAMILY_SPECIAL_CONTROLS; void* any_table = 0; uint8_t kind = g_family_to_kind_table[family_id]; if (family_id == FAMILY_THUMBS && has_star) { any_table = g_thumbs_bigrams_table; } else if (family_id == FAMILY_LEFT_HAND && has_star && !thumbs_bits) { any_table = g_left_punctuations_table; kind = KIND_PUNCTUATIONS; } else if (family_id == FAMILY_RIGHT_HAND && has_star && !thumbs_bits) { any_table = g_right_punctuations_table; kind = KIND_PUNCTUATIONS; } else { any_table = g_all_tables[family_id]; } if (any_table) { switch (kind) { case KIND_LETTERS: { uint8_t register_count = 0; uint8_t last_byte = 0; letters_table_t* letters_table = (letters_table_t*)any_table; for (int code_pos = 0; code_pos < MAX_LETTERS; ++code_pos) { const uint8_t byte = pgm_read_byte(&(letters_table[family_bits][code_pos])); if (byte) { register_code(byte); unregister_code(byte); last_byte = byte; register_count++; new_undo_command.inserted_chars_count++; if ((initial_case_1 && new_undo_command.inserted_chars_count == 1) || (initial_case_2 && new_undo_command.inserted_chars_count == 2)) { del_mods(MOD_LSFT); } } else { // Double the consonnant for the right hand only if ( has_plus && (register_count == 1) && (family_id == FAMILY_RIGHT_HAND) && (last_byte != 0)) { register_code(last_byte); unregister_code(last_byte); new_undo_command.inserted_chars_count++; } break; } } break; } case KIND_SYMBOLS: { symbols_table_t* symbols_table = (symbols_table_t*)any_table; for (int code_pos = 0; code_pos < MAX_SYMBOLS; ++code_pos) { const uint16_t word = pgm_read_word(&(symbols_table[family_bits][code_pos])); if (word) { const uint8_t code = (uint8_t)word; if (is_letter(code)) { // By doing this the shift mod can be applied on letter code register_code(code); } else { send_mods_and_code(word >> 8, code); } unregister_code(code); if (code == KC_LEFT) { new_undo_command.left_arrow_count++; } else { new_undo_command.inserted_chars_count++; } if ((initial_case_1 && new_undo_command.inserted_chars_count == 1) || (initial_case_2 && new_undo_command.inserted_chars_count == 2)) { del_mods(MOD_LSFT); } } else { break; } } break; } case KIND_PUNCTUATIONS: { punctuations_table_t* punctuations_table = (punctuations_table_t*)any_table; for (int code_pos = 0; code_pos < MAX_PUNCTUATIONS; ++code_pos) { const uint16_t word = pgm_read_word(&(punctuations_table[family_bits][code_pos])); if (word) { if (word == _NOSPC) { no_space_code_detected = true; } else { const uint8_t code = (uint8_t)word; send_mods_and_code(word >> 8, code); unregister_code(code); if (code == KC_LEFT) { new_undo_command.left_arrow_count++; } else { new_undo_command.inserted_chars_count++; } } } else { break; } } break; } } }
SEQ_THREE_KEYS(KC_A, KC_S, KC_D) { register_code(KC_LGUI); register_code(KC_S); unregister_code(KC_S); unregister_code(KC_LGUI); }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case QWERTY: if (record->event.pressed) { #ifdef AUDIO_ENABLE PLAY_NOTE_ARRAY(tone_qwerty, false, 0); #endif persistent_default_layer_set(1UL<<_QWERTY); } break; return false; case COLEMAK: if (record->event.pressed) { #ifdef AUDIO_ENABLE PLAY_NOTE_ARRAY(tone_colemak, false, 0); #endif persistent_default_layer_set(1UL<<_COLEMAK); } break; return false; case DVORAK: if (record->event.pressed) { #ifdef AUDIO_ENABLE PLAY_NOTE_ARRAY(tone_dvorak, false, 0); #endif persistent_default_layer_set(1UL<<_DVORAK); } break; return false; case LOWER: if (record->event.pressed) { layer_on(_LOWER); #ifdef BACKLIGHT_ENABLE breathing_speed_set(2); breathing_pulse(); #endif update_tri_layer(_LOWER, _RAISE, _ADJUST); } else { layer_off(_LOWER); update_tri_layer(_LOWER, _RAISE, _ADJUST); } break; return false; case RAISE: if (record->event.pressed) { layer_on(_RAISE); #ifdef BACKLIGHT_ENABLE breathing_speed_set(2); breathing_pulse(); #endif update_tri_layer(_LOWER, _RAISE, _ADJUST); } else { layer_off(_RAISE); update_tri_layer(_LOWER, _RAISE, _ADJUST); } break; return false; case BACKLIT: if (record->event.pressed) { register_code(KC_RSFT); #ifdef BACKLIGHT_ENABLE backlight_step(); #endif } else { unregister_code(KC_RSFT); } break; return false; case PLOVER: if (record->event.pressed) { #ifdef AUDIO_ENABLE stop_all_notes(); PLAY_NOTE_ARRAY(tone_plover, false, 0); #endif layer_off(_RAISE); layer_off(_LOWER); layer_off(_ADJUST); layer_on(_PLOVER); if (!eeconfig_is_enabled()) { eeconfig_init(); } keymap_config.raw = eeconfig_read_keymap(); keymap_config.nkro = 1; eeconfig_update_keymap(keymap_config.raw); } break; return false; case EXT_PLV: if (record->event.pressed) { #ifdef AUDIO_ENABLE PLAY_NOTE_ARRAY(tone_plover_gb, false, 0); #endif layer_off(_PLOVER); } break; return false; case RGBLED_TOGGLE: //led operations if (record->event.pressed) { rgblight_toggle(); } return false; break; case RGBLED_INCREASE_HUE: if (record->event.pressed) { rgblight_increase_hue(); } return false; break; case RGBLED_DECREASE_HUE: if (record->event.pressed) { rgblight_decrease_hue(); } return false; break; case RGBLED_INCREASE_SAT: if (record->event.pressed) { rgblight_increase_sat(); } return false; break; case RGBLED_DECREASE_SAT: if (record->event.pressed) { rgblight_decrease_sat(); } return false; break; case RGBLED_INCREASE_VAL: if (record->event.pressed) { rgblight_increase_val(); } return false; break; case RGBLED_DECREASE_VAL: if (record->event.pressed) { rgblight_decrease_val(); } return false; break; case RGBLED_STEP_MODE: if (record->event.pressed) { rgblight_step(); } return false; break; } return true; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case QWERTY: if (record->event.pressed) { persistant_default_layer_set(1UL<<_QWERTY); } return false; break; case NUMPAD: if (record->event.pressed) { layer_off(_RAISE); layer_off(_LOWER); layer_off(_ADJUST); layer_on(_NUMPAD); } return false; break; case EXT_NUM: if (record->event.pressed) { layer_off(_NUMPAD); } return false; break; case LOWER: if (record->event.pressed) { layer_on(_LOWER); update_tri_layer(_LOWER, _RAISE, _ADJUST); } else { layer_off(_LOWER); update_tri_layer(_LOWER, _RAISE, _ADJUST); } return false; break; case RAISE: if (record->event.pressed) { layer_on(_RAISE); update_tri_layer(_LOWER, _RAISE, _ADJUST); } else { layer_off(_RAISE); update_tri_layer(_LOWER, _RAISE, _ADJUST); } return false; break; case MOVE: if (record->event.pressed) { layer_on(_MOVE); } else { layer_off(_MOVE); } return false; break; case BACKLIT: if (record->event.pressed) { register_code(KC_RSFT); } else { unregister_code(KC_RSFT); } return false; break; } return true; }