void qk_ucis_symbol_fallback (void) { for (uint8_t i = 0; i < qk_ucis_state.count - 1; i++) { uint8_t code = qk_ucis_state.codes[i]; register_code(code); unregister_code(code); wait_ms(UNICODE_TYPE_DELAY); } }
void tap_esc_func_finished(qk_tap_dance_state_t *state, void *user_data) { if(state->pressed){ layer_on(FUNC); }else{ register_code(KC_ESC); unregister_code(KC_ESC); } }
void register_code16 (uint16_t code) { if (IS_MOD(code) || code == KC_NO) { do_code16 (code, qk_register_mods); } else { do_code16 (code, qk_register_weak_mods); } register_code (code); }
void send_unicode(uint16_t unicode) { // For more info on how this works per OS, see here: https://en.wikipedia.org/wiki/Unicode_input#Hexadecimal_code_input // Implemented for Windows: // Pressing ALT followed by + followed by the unicode code point in hex. // Requires registry key HKEY_CURRENT_USER\Control Panel\Input Method\EnableHexNumpad set to String 1 register_code(KC_LALT); register_code(KC_PPLS); unregister_code(KC_PPLS); for (int i = 12; i >= 0; i -= 4) { register_code(hextokeycode((unicode >> i) & 0xF)); unregister_code(hextokeycode((unicode >> i) & 0xF)); } unregister_code(KC_LALT); }
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { switch (id) { case F_PASTE: if (record->event.pressed) { register_code(KC_LCTL); register_code(KC_V); unregister_code(KC_V); unregister_code(KC_LCTL); } break; case RGB_ANI: if (record->event.pressed) { rgb_timer = timer_read(); } else { if (timer_elapsed(rgb_timer) > 300) { rgblight_mode(1); } else { rgblight_step(); } } case CF_EPRM: if (record->event.pressed) { eeconfig_init(); } return false; break; case CF_VERS: if (record->event.pressed) { SEND_STRING(QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); } return false; 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) { #ifdef AUDIO_ENABLE PLAY_NOTE_ARRAY(tone_qwerty, false, 0); #endif persistant_default_layer_set(1UL<<_QWERTY); } break; case _COLEMAK: if (record->event.pressed) { #ifdef AUDIO_ENABLE PLAY_NOTE_ARRAY(tone_colemak, false, 0); #endif persistant_default_layer_set(1UL<<_COLEMAK); } break; case _DVORAK: if (record->event.pressed) { #ifdef AUDIO_ENABLE PLAY_NOTE_ARRAY(tone_dvorak, false, 0); #endif persistant_default_layer_set(1UL<<_DVORAK); } 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; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case MOVE: if (record->event.pressed) { layer_on(_MOVE); update_tri_layer(_MOVE, _SYMB, _FUNC); } else { layer_off(_MOVE); update_tri_layer(_MOVE, _SYMB, _FUNC); } return false; break; case SYMB: if (record->event.pressed) { layer_on(_SYMB); update_tri_layer(_MOVE, _SYMB, _FUNC); } else { layer_off(_SYMB); update_tri_layer(_MOVE, _SYMB, _FUNC); } return false; break; case FUNC: if (record->event.pressed) { layer_on(_FUNC); } else { layer_off(_FUNC); } return false; break; case LOCK: if (record->event.pressed) { register_code(KC_RSFT); register_code(KC_RCTL); register_code(KC_POWER); } else { unregister_code(KC_POWER); unregister_code(KC_RCTL); 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 MACRO_COPY_CUT: if (record->event.pressed) { register_code(KC_LCTL); if (record->tap.count == 1) { register_code(KC_C); unregister_code(KC_C); } else if (record->tap.count == 2) { register_code(KC_X); unregister_code(KC_X); } unregister_code(KC_LCTL); } break; case MACRO_SHIFT_CONTROL: if (record->event.pressed) { if (record->tap.count <= 2) register_mods(MOD_BIT(KC_LSFT)); if (record->tap.count == 2) register_mods(MOD_BIT(KC_LCTL)); if (record->tap.count == 3) register_code(KC_PENT);; } else { unregister_mods(MOD_BIT(KC_LSFT) | MOD_BIT(KC_LCTL)); unregister_code(KC_PENT); } break; case MACRO_CONTROL_ALT: if (record->event.pressed) { if (record->tap.count < 2) register_mods(MOD_BIT(KC_LCTL)); if (record->tap.count >= 2) register_mods(MOD_BIT(KC_LALT)); } else { unregister_mods(MOD_BIT(KC_LCTL) | MOD_BIT(KC_LALT)); } 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_LS); register_code(PV_LH); register_code(PV_RF); register_code(PV_RT); } else { unregister_code(PV_LS); unregister_code(PV_LH); unregister_code(PV_RF); unregister_code(PV_RT); } }
void ccopy(qk_tap_dance_state_t *state, void *user_data) { if (state->count > 1) { register_code(KC_LCTL); register_code(KC_X); unregister_code(KC_X); unregister_code(KC_LCTL); } else { register_code(KC_LCTL); register_code(KC_C); unregister_code(KC_C); unregister_code(KC_LCTL); } reset_tap_dance(state); }
void findreplace(qk_tap_dance_state_t *state, void *user_data) { if (state->count > 1) { register_code(KC_LCTL); register_code(KC_H); unregister_code(KC_H); unregister_code(KC_LCTL); } else { register_code(KC_LCTL); register_code(KC_F); unregister_code(KC_F); unregister_code(KC_LCTL); } reset_tap_dance(state); }
void dance_super_done(qk_tap_dance_state_t *state, void *user_data){ // Called on timeout switch(state->count){ case 2: register_code(KC_LGUI); tap(KC_L); unregister_code(KC_LGUI); break; } }
// Function for the special modifiers actions below, makes it cleaner and yields smaller firmware. static bool special_mods(uint16_t keycode, keyrecord_t *record, uint16_t modifier) { if (record->event.pressed && (keyboard_report->mods & MOD_BIT(modifier))) { register_code(keycode); return false; } else { unregister_code(keycode); return true; } }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case DVORAK: if (record->event.pressed) { set_single_persistent_default_layer(_DVORAK); } return false; break; case BACKLIT: if (record->event.pressed) { register_code(KC_RSFT); #ifdef BACKLIGHT_ENABLE backlight_step(); #endif #ifdef KEYBOARD_planck_rev5 PORTE &= ~(1<<6); #endif } else { unregister_code(KC_RSFT); #ifdef KEYBOARD_planck_rev5 PORTE |= (1<<6); #endif } return false; break; case PLOVER: if (record->event.pressed) { #ifdef AUDIO_ENABLE stop_all_notes(); PLAY_SONG(plover_song); #endif layer_off(_CUSTOM); 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); } return false; break; case EXT_PLV: if (record->event.pressed) { #ifdef AUDIO_ENABLE PLAY_SONG(plover_gb_song); #endif layer_off(_PLOVER); } return false; break; } return true; }
bool process_record_user(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 DVORAK: if (record->event.pressed) { set_single_persistent_default_layer(_DVORAK); } 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 PORTE &= ~(1<<6); } else { unregister_code(KC_RSFT); PORTE |= (1<<6); } return false; break; } return true; };
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 GAME: if (record->event.pressed) { #ifdef AUDIO_ENABLE PLAY_SONG(music_scale); #endif persistant_default_layer_set(1UL<<_GAME); } 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; }
void tap_space_spam_finished(qk_tap_dance_state_t *state, void *user_data) { if(get_mods() & (MOD_BIT(KC_LGUI))){ return; } if(state->pressed){ spam_space = true; } register_code(KC_SPC); unregister_code(KC_SPC); }
void matrix_scan_user() { for (uint8_t index = 0 ; index < TH_EVENTS_COUNT ; ++index ) { tap_hold_t *th_event = &th_events[index]; if ( th_event->is_pressed && timer_elapsed(th_event->timer) > LONGPRESS_DELAY) { register_code(th_event->kc_hold); unregister_code(th_event->kc_hold); th_event->is_pressed = false; } } }
//TD dot to toggle layer 2 void _td_dot_tg_finished (qk_tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code(KC_DOT); } else if (state->count == 2) { backlight_set(1); layer_on(_L2); layer_off(_L1); layer_off(_L3); } }
void send_string(const char *str) { while (1) { uint8_t keycode; uint8_t ascii_code = pgm_read_byte(str); if (!ascii_code) break; keycode = pgm_read_byte(&ascii_to_qwerty_keycode_lut[ascii_code]); if (pgm_read_byte(&ascii_to_qwerty_shift_lut[ascii_code])) { register_code(KC_LSFT); register_code(keycode); unregister_code(keycode); unregister_code(KC_LSFT); } else { register_code(keycode); unregister_code(keycode); } ++str; } }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case MOVE: if (record->event.pressed) { layer_on(_MOVE); update_tri_layer(_MOVE, _SYMB, _MOUSE); } else { layer_off(_MOVE); update_tri_layer(_MOVE, _SYMB, _MOUSE); } return false; break; case SYMB: if (record->event.pressed) { layer_on(_SYMB); update_tri_layer(_MOVE, _SYMB, _MOUSE); } else { layer_off(_SYMB); update_tri_layer(_MOVE, _SYMB, _MOUSE); } return false; break; case FUNC: if (record->event.pressed) { layer_on(_FUNC); } else { layer_off(_FUNC); } return false; break; case BELOW: if (record->event.pressed) { register_code(KC_LGUI); register_code(KC_RGHT); unregister_code(KC_RGHT); unregister_code(KC_LGUI); register_code(KC_ENT); unregister_code(KC_ENT); } return false; break; case ABOVE: if (record->event.pressed) { register_code(KC_LGUI); register_code(KC_LEFT); unregister_code(KC_LEFT); unregister_code(KC_LGUI); register_code(KC_ENT); unregister_code(KC_ENT); register_code(KC_UP); unregister_code(KC_UP); } return false; break; } return true; }
bool process_record_keymap(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case KC_1: if (IS_LAYER_ON(_GAMEPAD) && userspace_config.swapped_numbers) { if (record->event.pressed) { register_code(KC_2); } else { unregister_code(KC_2); } return false; } break; case KC_2: if (IS_LAYER_ON(_GAMEPAD) && userspace_config.swapped_numbers) { if (record->event.pressed) { register_code(KC_1); } else { unregister_code(KC_1); } return false; } break; case KC_SWAP_NUM: if (record->event.pressed) { userspace_config.swapped_numbers ^= 1; eeconfig_update_user(userspace_config.raw); } } //switch (keycode) { // case KC_P00: // if (!record->event.pressed) { // register_code(KC_KP_0); // unregister_code(KC_KP_0); // register_code(KC_KP_0); // unregister_code(KC_KP_0); // } // return false; // break; //} return true; }
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { switch(id) { case 0: if (record->event.pressed) { register_code(KC_RSFT); } else { unregister_code(KC_RSFT); } break; case LWIN: if (record->event.pressed) { register_code(KC_RSFT); unregister_code(KC_RSFT); register_code(KC_LGUI); } else { unregister_code(KC_LGUI); } break; case PC1: if (!record->event.pressed) { return MACRO(T(SLCK), W(50), T(SLCK), W(50), T(1), W(50), T(ENT), END); } break; case PC2: if (!record->event.pressed) { return MACRO(T(SLCK), W(50), T(SLCK), W(50), T(2), W(50), T(ENT), END); } break; case PC3: if (!record->event.pressed) { return MACRO(T(SLCK), W(50), T(SLCK), W(50), T(3), W(50), T(ENT), END); } break; case PC4: if (!record->event.pressed) { return MACRO(T(SLCK), W(50), T(SLCK), W(50), T(4), W(50), T(ENT), END); } break; } return MACRO_NONE; }
void matrix_init_keymap(void) { // set Numlock LED to output and low DDRF |= (1 << 7); PORTF &= ~(1 << 7); if (!(host_keyboard_leds() & (1 << USB_LED_NUM_LOCK))) { register_code(KC_NUMLOCK); unregister_code(KC_NUMLOCK); } }
//TD kp plus to toggle layer 1 void _td_kp_plus_tg_finished (qk_tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code(KC_KP_PLUS); } else if (state->count == 2) { // layer_invert(_L1); backlight_set(2); layer_on(_L1); layer_off(_L2); layer_off(_L3); } }
void BSW_finished (qk_tap_dance_state_t *state, void *user_data) { BSWtap_state.state = cur_dance(state); switch (BSWtap_state.state) { case SINGLE_TAP: register_code(KC_ENTER); break; case SINGLE_HOLD: set_single_persistent_default_layer(0); #ifdef AUDIO_ENABLE stop_all_notes(); PLAY_SONG(lyrdown_song); #endif break; case DOUBLE_TAP: register_code(KC_LCTRL); register_code(KC_C); break; case DOUBLE_HOLD: reset_keyboard(); break; //register this keycode when button is tapped and then held } }
// Runs constantly in the background, in a loop. void matrix_scan_user(void) { uint8_t layer = biton32(layer_state); ergodox_board_led_off(); ergodox_right_led_1_off(); ergodox_right_led_2_off(); ergodox_right_led_3_off(); switch (layer) { // TODO: Make this relevant to the ErgoDox EZ. case 1: ergodox_right_led_1_on(); break; case 2: ergodox_right_led_2_on(); break; default: // none break; } LEADER_DICTIONARY() { leading = false; leader_end(); SEQ_ONE_KEY(KC_W) { register_code(KC_LALT); register_code(KC_F4); unregister_code(KC_F4); unregister_code(KC_LALT); } SEQ_ONE_KEY(KC_O) { register_code(KC_LCTL); register_code(KC_LSFT); register_code(KC_O); unregister_code(KC_O); unregister_code(KC_LSFT); unregister_code(KC_LCTL); } } }
/* Tap Dance function */ void dance_cln_finished( qk_tap_dance_state_t* state, void* user_data ) { if ( state->count == 1 ) { register_code( KC_LSFT ); } else { layer_on( _SYMB ); #ifdef AUDIO_ENABLE PLAY_SONG( tone_taps ); #endif } }
// Macros 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; };
// press `key`, but deactivate `layer` whilst it's held void press_without(int pressed, int key, uint8_t layer) { static bool was_on; if (pressed) { was_on = layer_state_is(layer); layer_off(layer); register_code(key); } else { if (was_on) layer_on(layer); unregister_code(key); } }