mirrors/qmk_userspace
1
0
Fork 1
mirror of https://github.com/qmk/qmk_userspace.git synced 2025-05-04 22:54:16 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Reverted Keymap and overhauled Tap-Hold Override

Browse source 
- Went back to num pad
- Added function key layer, maybe I'll do override to remove a layer
- Symbol layer is tri layer
- Redid tap-hold so taps can be held for repeating keys
This commit is contained in:
Victor 2024-05-09 22:21:46 -05:00
parent aa2a8463fe
commit d5a94942b8
Failed to generate hash of commit
11 changed files with 336 additions and 177 deletions
Download patch file Download diff file Expand all files Collapse all files

32
keyboards/barbellboards/rollow/keymaps/t4corun/keymap.c
View file

@ -19,13 +19,14 @@ LAYOUT_rollow_wrapper ( \
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_DEFAULT_LAYER_1] = ROLLOW(LAYER_QWERTY),
[_DEFAULT_LAYER_2] = ROLLOW(LAYER_COLEMAK_DH),
[_DEFAULT_LAYER_3] = ROLLOW(LAYER_GAME),
[_NAVIGATION] = ROLLOW(LAYER_NAVIGATION),
[_SYMBOL] = ROLLOW(LAYER_SYMBOL),
[_NUMBER] = ROLLOW(LAYER_NUMBER),
[_CONFIG] = ROLLOW(LAYER_CONFIG)
[_QWERTY] = ROLLOW(LAYER_QWERTY),
[_COLEMAK_DH] = ROLLOW(LAYER_COLEMAK_DH),
[_GAME] = ROLLOW(LAYER_GAME),
[_NAVIGATION] = ROLLOW(LAYER_NAVIGATION),
[_NUMBER] = ROLLOW(LAYER_NUMBER),
[_SYMBOL] = ROLLOW(LAYER_SYMBOL),
[_FUNCTION] = ROLLOW(LAYER_FUNCTION),
[_CONFIG] = ROLLOW(LAYER_CONFIG)
};
@ -34,13 +35,16 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* These are horizontal encoders. Found I have to make it opposite the rotary encoders for it to feel intuitive*/
const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][NUM_DIRECTIONS] = {
[_DEFAULT_LAYER_1] = { ENCODER_CCW_CW(KC_WH_D, KC_WH_U), ENCODER_CCW_CW(KC_VOLU, KC_VOLD) },
[_DEFAULT_LAYER_2] = { ENCODER_CCW_CW(KC_WH_D, KC_WH_U), ENCODER_CCW_CW(KC_VOLU, KC_VOLD) },
[_DEFAULT_LAYER_3] = { ENCODER_CCW_CW(KC_WH_D, KC_WH_U), ENCODER_CCW_CW(KC_VOLU, KC_VOLD) },
[_NAVIGATION] = { ENCODER_CCW_CW(ZOOMIN, ZOOMOUT), ENCODER_CCW_CW(___x___, ___x___) },
[_SYMBOL] = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(KC_RGHT, KC_LEFT) },
[_NUMBER] = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(___x___, ___x___) },
[_CONFIG] = { ENCODER_CCW_CW(BASELYR, RBSELYR), ENCODER_CCW_CW(TR_RMOD, TR_RRMD) }
[_QWERTY] = { ENCODER_CCW_CW(KC_WH_D, KC_WH_U), ENCODER_CCW_CW(KC_VOLU, KC_VOLD) },
[_COLEMAK_DH] = { ENCODER_CCW_CW(KC_WH_D, KC_WH_U), ENCODER_CCW_CW(KC_VOLU, KC_VOLD) },
[_GAME] = { ENCODER_CCW_CW(KC_WH_D, KC_WH_U), ENCODER_CCW_CW(KC_VOLU, KC_VOLD) },
[_NAVIGATION] = { ENCODER_CCW_CW(ZOOMIN, ZOOMOUT), ENCODER_CCW_CW(___x___, ___x___) },
[_NUMBER] = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(KC_RGHT, KC_LEFT) },
[_SYMBOL] = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(___x___, ___x___) },
[_FUNCTION] = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(___x___, ___x___) },
[_CONFIG] = { ENCODER_CCW_CW(BASELYR, RBSELYR), ENCODER_CCW_CW(TR_RMOD, TR_RRMD) }
};
#endif

15
keyboards/bastardkb/charybdis/3x5/keymaps/t4corun/keymap.c
View file

@ -19,12 +19,13 @@ LAYOUT_cnano_wrapper ( \
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_DEFAULT_LAYER_1] = CNANO(LAYER_QWERTY),
[_DEFAULT_LAYER_2] = CNANO(LAYER_COLEMAK_DH),
[_DEFAULT_LAYER_3] = CNANO(LAYER_GAME),
[_NAVIGATION] = CNANO(LAYER_NAVIGATION),
[_SYMBOL] = CNANO(LAYER_SYMBOL),
[_NUMBER] = CNANO(LAYER_NUMBER),
[_CONFIG] = CNANO(LAYER_CONFIG)
[_QWERTY] = CNANO(LAYER_QWERTY),
[_COLEMAK_DH] = CNANO(LAYER_COLEMAK_DH),
[_GAME] = CNANO(LAYER_GAME),
[_NAVIGATION] = CNANO(LAYER_NAVIGATION),
[_NUMBER] = CNANO(LAYER_NUMBER),
[_SYMBOL] = CNANO(LAYER_SYMBOL),
[_FUNCTION] = CNANO(LAYER_FUNCTION),
[_CONFIG] = CNANO(LAYER_CONFIG)
};

32
keyboards/bluebell/swoop/keymaps/t4corun/keymap.c
View file

@ -19,13 +19,14 @@ LAYOUT_swoop_wrapper ( \
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_DEFAULT_LAYER_1] = SWOOP(LAYER_QWERTY),
[_DEFAULT_LAYER_2] = SWOOP(LAYER_COLEMAK_DH),
[_DEFAULT_LAYER_3] = SWOOP(LAYER_GAME),
[_NAVIGATION] = SWOOP(LAYER_NAVIGATION),
[_SYMBOL] = SWOOP(LAYER_SYMBOL),
[_NUMBER] = SWOOP(LAYER_NUMBER),
[_CONFIG] = SWOOP(LAYER_CONFIG)
[_QWERTY] = SWOOP(LAYER_QWERTY),
[_COLEMAK_DH] = SWOOP(LAYER_COLEMAK_DH),
[_GAME] = SWOOP(LAYER_GAME),
[_NAVIGATION] = SWOOP(LAYER_NAVIGATION),
[_NUMBER] = SWOOP(LAYER_NUMBER),
[_SYMBOL] = SWOOP(LAYER_SYMBOL),
[_FUNCTION] = SWOOP(LAYER_FUNCTION),
[_CONFIG] = SWOOP(LAYER_CONFIG)
};
@ -34,13 +35,16 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* The encoder presses are handled in the keymap */
const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][NUM_DIRECTIONS] = {
[_DEFAULT_LAYER_1] = { ENCODER_CCW_CW(KC_WH_U, KC_WH_D), ENCODER_CCW_CW(KC_VOLD, KC_VOLU) },
[_DEFAULT_LAYER_2] = { ENCODER_CCW_CW(KC_WH_U, KC_WH_D), ENCODER_CCW_CW(KC_VOLD, KC_VOLU) },
[_DEFAULT_LAYER_3] = { ENCODER_CCW_CW(KC_WH_U, KC_WH_D), ENCODER_CCW_CW(KC_VOLD, KC_VOLU) },
[_NAVIGATION] = { ENCODER_CCW_CW(ZOOMOUT, ZOOMIN), ENCODER_CCW_CW(___x___, ___x___) },
[_SYMBOL] = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(KC_LEFT, KC_RGHT) },
[_NUMBER] = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(___x___, ___x___) },
[_CONFIG] = { ENCODER_CCW_CW(RBSELYR, BASELYR), ENCODER_CCW_CW(TR_RRMD, TR_RMOD) }
[_QWERTY] = { ENCODER_CCW_CW(KC_WH_U, KC_WH_D), ENCODER_CCW_CW(KC_VOLD, KC_VOLU) },
[_COLEMAK_DH] = { ENCODER_CCW_CW(KC_WH_U, KC_WH_D), ENCODER_CCW_CW(KC_VOLD, KC_VOLU) },
[_GAME] = { ENCODER_CCW_CW(KC_WH_U, KC_WH_D), ENCODER_CCW_CW(KC_VOLD, KC_VOLU) },
[_NAVIGATION] = { ENCODER_CCW_CW(ZOOMOUT, ZOOMIN), ENCODER_CCW_CW(___x___, ___x___) },
[_NUMBER] = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(KC_LEFT, KC_RGHT) },
[_SYMBOL] = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(___x___, ___x___) },
[_FUNCTION] = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(___x___, ___x___) },
[_CONFIG] = { ENCODER_CCW_CW(RBSELYR, BASELYR), ENCODER_CCW_CW(TR_RRMD, TR_RMOD) }
};
#endif //ENCODER_MAP_ENABLE

15
keyboards/crkbd/keymaps/t4corun/keymap.c
View file

@ -19,12 +19,13 @@ LAYOUT_crkbd_wrapper ( \
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_DEFAULT_LAYER_1] = CRKBD(LAYER_QWERTY),
[_DEFAULT_LAYER_2] = CRKBD(LAYER_COLEMAK_DH),
[_DEFAULT_LAYER_3] = CRKBD(LAYER_GAME),
[_NAVIGATION] = CRKBD(LAYER_NAVIGATION),
[_SYMBOL] = CRKBD(LAYER_SYMBOL),
[_NUMBER] = CRKBD(LAYER_NUMBER),
[_CONFIG] = CRKBD(LAYER_CONFIG)
[_QWERTY] = CRKBD(LAYER_QWERTY),
[_COLEMAK_DH] = CRKBD(LAYER_COLEMAK_DH),
[_GAME] = CRKBD(LAYER_GAME),
[_NAVIGATION] = CRKBD(LAYER_NAVIGATION),
[_NUMBER] = CRKBD(LAYER_NUMBER),
[_SYMBOL] = CRKBD(LAYER_SYMBOL),
[_FUNCTION] = CRKBD(LAYER_FUNCTION),
[_CONFIG] = CRKBD(LAYER_CONFIG)
};

15
keyboards/planck/keymaps/t4corun/keymap.c
View file

@ -19,12 +19,13 @@ LAYOUT_planck_wrapper ( \
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_DEFAULT_LAYER_1] = PLANCK(LAYER_QWERTY),
[_DEFAULT_LAYER_2] = PLANCK(LAYER_COLEMAK_DH),
[_DEFAULT_LAYER_3] = PLANCK(LAYER_GAME),
[_NAVIGATION] = PLANCK(LAYER_NAVIGATION),
[_SYMBOL] = PLANCK(LAYER_SYMBOL),
[_NUMBER] = PLANCK(LAYER_NUMBER),
[_CONFIG] = PLANCK(LAYER_CONFIG)
[_QWERTY] = PLANCK(LAYER_QWERTY),
[_COLEMAK_DH] = PLANCK(LAYER_COLEMAK_DH),
[_GAME] = PLANCK(LAYER_GAME),
[_NAVIGATION] = PLANCK(LAYER_NAVIGATION),
[_NUMBER] = PLANCK(LAYER_NUMBER),
[_SYMBOL] = PLANCK(LAYER_SYMBOL),
[_FUNCTION] = PLANCK(LAYER_FUNCTION),
[_CONFIG] = PLANCK(LAYER_CONFIG)
};

11
users/t4corun/features/oled.c
View file

@ -32,12 +32,13 @@ void render_default_layer_state(void) {
void render_layer_state(void) {
oled_write_P(PSTR(OLED_RENDER_LAYER_NAME), false);
oled_write_P(PSTR(OLED_RENDER_LAYER_BASE), get_highest_layer(layer_state) == FIRST_DEFAULT_LAYER);
oled_write_P(PSTR(OLED_RENDER_LAYER_NAME), false);
oled_write_P(PSTR(OLED_RENDER_LAYER_BASE), get_highest_layer(layer_state) == FIRST_DEFAULT_LAYER);
oled_write_P(PSTR(OLED_RENDER_LAYER_NAVIGATION), get_highest_layer(layer_state) == _NAVIGATION);
oled_write_P(PSTR(OLED_RENDER_LAYER_SYMBOL), get_highest_layer(layer_state) == _SYMBOL);
oled_write_P(PSTR(OLED_RENDER_LAYER_NUMBER), get_highest_layer(layer_state) == _NUMBER);
oled_write_P(PSTR(OLED_RENDER_LAYER_CONFIG), get_highest_layer(layer_state) == _CONFIG);
oled_write_P(PSTR(OLED_RENDER_LAYER_NUMBER), get_highest_layer(layer_state) == _NUMBER);
oled_write_P(PSTR(OLED_RENDER_LAYER_SYMBOL), get_highest_layer(layer_state) == _SYMBOL);
oled_write_P(PSTR(OLED_RENDER_LAYER_FUNCTION), get_highest_layer(layer_state) == _FUNCTION);
oled_write_P(PSTR(OLED_RENDER_LAYER_CONFIG), get_highest_layer(layer_state) == _CONFIG);
}

3
users/t4corun/features/oled.h
View file

@ -13,8 +13,9 @@
#define OLED_RENDER_LAYER_NAME "Layer"
#define OLED_RENDER_LAYER_BASE " Def "
#define OLED_RENDER_LAYER_NAVIGATION " Nav "
#define OLED_RENDER_LAYER_SYMBOL " Sym "
#define OLED_RENDER_LAYER_NUMBER " Num "
#define OLED_RENDER_LAYER_SYMBOL " Sym "
#define OLED_RENDER_LAYER_FUNCTION " Fun "
#define OLED_RENDER_LAYER_CONFIG " Cfg "
void render_crkbd_logo(void);

204
users/t4corun/features/taphold.c
View file

@ -1,5 +1,6 @@
#include "taphold.h"
/*
void single_tap(uint16_t key, uint16_t altkey, bool isHold) {
isHold ? tap_code16(altkey) : tap_code16(key);
}
@ -10,7 +11,6 @@ void double_tap(uint16_t key, uint16_t altkey, uint32_t ms) {
isShift ? tap_code16(LSFT(key)) : tap_code16(key);
wait_ms(ms);
isShift ? tap_code16(LSFT(altkey)) : tap_code16(altkey);
}
void insert_brackets(uint16_t left, uint16_t right, uint32_t ms) {
bool isShift = ( (get_mods() & MOD_BIT(KC_LSFT)) || (get_oneshot_mods() & MOD_BIT(KC_LSFT)) );
@ -21,6 +21,79 @@ void insert_brackets(uint16_t left, uint16_t right, uint32_t ms) {
wait_ms(ms);
tap_code16(KC_LEFT);
}
*/
void single_tap(uint16_t key) {
tap_code16(key);
}
void double_tap(uint16_t key, uint32_t ms) {
tap_code16(key);
wait_ms(ms);
tap_code16(key);
}
void insert_brackets(uint16_t left, uint16_t right, uint32_t ms) {
tap_code16(left);
wait_ms(ms);
tap_code16(right);
wait_ms(ms);
tap_code16(KC_LEFT);
}
bool process_tap_hold_key(keyrecord_t* record, uint16_t tap_keycode, uint16_t hold_keycode, int mode) {
// https://getreuer.info/posts/keyboards/triggers/index.html#tap-vs.-long-press
if ( record->tap.count > 0 ) {
// Key is being tapped
if (record->event.pressed) {
// Handle tap press event...
register_code16(tap_keycode);
} else {
// Handle tap release event...
unregister_code16(tap_keycode);
}
} else {
// Key is being held
if (record->event.pressed) {
// Handle tap press event...
switch ( mode ) {
case HOLD_BRACKETS:
insert_brackets(tap_keycode, hold_keycode, WAIT_DELAY);
break;
case HOLD_DOUBLETP:
double_tap(tap_keycode, WAIT_DELAY);
break;
default:
single_tap(tap_keycode);
break;
}
}
}
return false;
}
/*
// here we can have the holds be more complex, like sending "" when you hold "
bool process_tap_hold_key(keyrecord_t* record, uint16_t keycode) {
@ -39,59 +112,42 @@ bool process_tap_hold_key(keyrecord_t* record, uint16_t keycode) {
switch(keycode) {
case TR_LCBR:
single_tap(TAPHOLD_LCBR, isHold);
break;
single_tap(TAPHOLD_LCBR, isHold); break;
case TR_LABK:
single_tap(TAPHOLD_LABK, isHold);
break;
single_tap(TAPHOLD_LABK, isHold); break;
case TR_LBRC:
single_tap(TAPHOLD_LBRC, isHold);
break;
single_tap(TAPHOLD_LBRC, isHold); break;
case TR_LPRN:
single_tap(TAPHOLD_LPRN, isHold);
break;
single_tap(TAPHOLD_LPRN, isHold); break;
case TR_DQUO:
single_tap(TAPHOLD_DQUO, isHold); break;
case TR_SQUO:
single_tap(TAPHOLD_SQUO, isHold);
break;
case TR_EQL:
single_tap(TAPHOLD_EQL, isHold);
break;
single_tap(TAPHOLD_SQUO, isHold); break;
case TR_BSLS:
single_tap(TAPHOLD_BSLS, isHold);
break;
single_tap(TAPHOLD_BSLS, isHold); break;
case TR_SLSH:
single_tap(TAPHOLD_SLSH, isHold);
break;
single_tap(TAPHOLD_SLSH, isHold); break;
case TR_PIPE:
single_tap(TAPHOLD_PIPE, isHold); break;
case TR_COMM:
single_tap(TAPHOLD_COMM, isHold);
break;
single_tap(TAPHOLD_COMM, isHold); break;
case TR_DOT:
single_tap(TAPHOLD_DOT, isHold);
break;
single_tap(TAPHOLD_DOT, isHold); break;
case TR_PERC:
single_tap(TAPHOLD_PERC, isHold);
break;
case TR_EXLM:
single_tap(TAPHOLD_EXLM, isHold);
break;
case TR_AT:
single_tap(TAPHOLD_AT, isHold);
break;
case TR_QUES:
single_tap(TAPHOLD_QUES, isHold);
break;
single_tap(TAPHOLD_PERC, isHold); break;
case TR_EQL:
single_tap(TAPHOLD_EQL, isHold); break;
case TR_MINS:
single_tap(TAPHOLD_MINS, isHold);
break;
single_tap(TAPHOLD_MINS, isHold); break;
case TR_GRV:
single_tap(TAPHOLD_GRV, isHold);
break;
single_tap(TAPHOLD_GRV, isHold); break;
case TR_SCLN:
single_tap(TAPHOLD_SCLN, isHold);
break;
single_tap(TAPHOLD_SCLN, isHold); break;
case TR_QUOT:
single_tap(TAPHOLD_QUOT, isHold);
break;
single_tap(TAPHOLD_QUOT, isHold); break;
}
@ -103,67 +159,47 @@ bool process_tap_hold_key(keyrecord_t* record, uint16_t keycode) {
switch(keycode) {
// Brackets
// Brackets: open and close brackets and put the cursor inside
case TR_LCBR:
insert_brackets(TAPHOLD_LCBR, WAIT_DELAY);
break;
insert_brackets(TAPHOLD_LCBR, WAIT_DELAY); break;
case TR_LABK:
insert_brackets(TAPHOLD_LABK, WAIT_DELAY);
break;
insert_brackets(TAPHOLD_LABK, WAIT_DELAY); break;
case TR_LBRC:
insert_brackets(TAPHOLD_LBRC, WAIT_DELAY);
break;
insert_brackets(TAPHOLD_LBRC, WAIT_DELAY); break;
case TR_LPRN:
insert_brackets(TAPHOLD_LPRN, WAIT_DELAY);
break;
insert_brackets(TAPHOLD_LPRN, WAIT_DELAY); break;
case TR_DQUO:
insert_brackets(TAPHOLD_DQUO, WAIT_DELAY); break;
case TR_SQUO:
insert_brackets(TAPHOLD_SQUO, WAIT_DELAY);
break;
insert_brackets(TAPHOLD_SQUO, WAIT_DELAY); break;
// double tap
case TR_EQL:
double_tap(TAPHOLD_EQL, WAIT_DELAY);
break;
case TR_BSLS:
double_tap(TAPHOLD_BSLS, WAIT_DELAY);
break;
double_tap(TAPHOLD_BSLS, WAIT_DELAY); break;
case TR_SLSH:
double_tap(TAPHOLD_SLSH, WAIT_DELAY);
break;
double_tap(TAPHOLD_SLSH, WAIT_DELAY); break;
case TR_PIPE:
double_tap(TAPHOLD_PIPE, WAIT_DELAY); break;
// custom override without holding shift
case TR_COMM:
single_tap(TAPHOLD_COMM, isHold);
break;
single_tap(TAPHOLD_COMM, isHold); break;
case TR_DOT:
single_tap(TAPHOLD_DOT, isHold);
break;
single_tap(TAPHOLD_DOT, isHold); break;
case TR_PERC:
single_tap(TAPHOLD_PERC, isHold);
break;
case TR_EXLM:
single_tap(TAPHOLD_EXLM, isHold);
break;
case TR_AT:
single_tap(TAPHOLD_AT, isHold);
break;
case TR_QUES:
single_tap(TAPHOLD_QUES, isHold);
break;
single_tap(TAPHOLD_PERC, isHold); break;
// simulates auto-shift
case TR_EQL:
single_tap(TAPHOLD_EQL, isHold); break;
case TR_MINS:
single_tap(TAPHOLD_MINS, isHold);
break;
single_tap(TAPHOLD_MINS, isHold); break;
case TR_GRV:
single_tap(TAPHOLD_GRV, isHold);
break;
single_tap(TAPHOLD_GRV, isHold); break;
case TR_SCLN:
single_tap(TAPHOLD_SCLN, isHold);
break;
single_tap(TAPHOLD_SCLN, isHold); break;
case TR_QUOT:
single_tap(TAPHOLD_QUOT, isHold);
break;
single_tap(TAPHOLD_QUOT, isHold); break;
}
@ -172,4 +208,6 @@ bool process_tap_hold_key(keyrecord_t* record, uint16_t keycode) {
}
return true; // Continue default handling.
}
}
*/

22
users/t4corun/features/taphold.h
View file

@ -1,10 +1,21 @@
#pragma once
#include "t4corun.h"
/*
void single_tap(uint16_t key, uint16_t altkey, bool isHold);
void double_tap(uint16_t key, uint16_t altkey, uint32_t ms);
void insert_brackets(uint16_t left, uint16_t right, uint32_t ms);
void insert_brackets(uint16_t left, uint16_t right, uint32_t ms);
bool process_tap_hold_key(keyrecord_t* record, uint16_t keycode);
*/
void single_tap(uint16_t key);
void double_tap(uint16_t key, uint32_t ms);
void insert_brackets(uint16_t left, uint16_t right, uint32_t ms);
bool process_tap_hold_key(keyrecord_t* record, uint16_t tap_keycode, uint16_t hold_keycode, int mode);
/* the first element is the alt key (tap action)
* the second is altkey (hold action usually)
@ -13,28 +24,29 @@ bool process_tap_hold_key(keyrecord_t* record, uint16_t keycode);
* and easier to maintain
*/
/*
// Brackets: open and close brackets and put the cursor inside
#define TAPHOLD_LCBR KC_LCBR, KC_RCBR
#define TAPHOLD_LABK KC_LABK, KC_RABK
#define TAPHOLD_LBRC KC_LBRC, KC_RBRC
#define TAPHOLD_LPRN KC_LPRN, KC_RPRN
#define TAPHOLD_DQUO KC_DQUO, KC_DQUO
#define TAPHOLD_SQUO KC_QUOT, KC_QUOT
// double tap
#define TAPHOLD_EQL KC_EQL, KC_EQL
#define TAPHOLD_BSLS KC_BSLS, KC_BSLS
#define TAPHOLD_SLSH KC_SLSH, KC_SLSH
#define TAPHOLD_PIPE KC_PIPE, KC_PIPE
// Custom override without holding shift
#define TAPHOLD_COMM KC_COMM, KC_LPRN
#define TAPHOLD_DOT KC_DOT, KC_RPRN
#define TAPHOLD_PERC KC_PERC, KC_CIRC
#define TAPHOLD_EXLM KC_EXLM, KC_DLR
#define TAPHOLD_AT KC_AT, KC_AMPR
#define TAPHOLD_QUES KC_QUES, KC_ASTR
// auto shift
#define TAPHOLD_EQL KC_EQL, KC_PLUS
#define TAPHOLD_MINS KC_MINS, KC_UNDS
#define TAPHOLD_GRV KC_GRV, KC_TILD
#define TAPHOLD_SCLN KC_SCLN, KC_COLN
#define TAPHOLD_QUOT KC_QUOT, KC_DQUO
#define TAPHOLD_QUOT KC_QUOT, KC_DQUO
*/

54
users/t4corun/t4corun.c
View file

@ -4,7 +4,7 @@ static uint8_t current_base_layer = _DEFAULT_LAYER_1;
layer_state_t layer_state_set_user(layer_state_t state) {
state = update_tri_layer_state(state, _NAVIGATION, _SYMBOL, _NUMBER);
state = update_tri_layer_state(state, _NAVIGATION, _NUMBER, _SYMBOL);
return state;
}
@ -30,14 +30,17 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
case PN_DRGS:
if (record->event.pressed) {
//tap numlock twice to toggle ploopy nano drag scroll
double_tap(KC_NUM, KC_NUM, WAIT_DELAY);
// double_tap(KC_NUM, KC_NUM, WAIT_DELAY);
double_tap(KC_NUM, WAIT_DELAY);
}
return false;
case PN_PDPI:
if (record->event.pressed) {
//tap capslock twice to cycle ploopy nano pointer DPI
double_tap(KC_CAPS, KC_CAPS, WAIT_DELAY);
//double_tap(KC_CAPS, KC_CAPS, WAIT_DELAY);
double_tap(KC_CAPS, WAIT_DELAY);
}
return false;
@ -96,6 +99,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
//https://docs.qmk.fm/#/mod_tap?id=changing-both-tasp-and-hold
//https://getreuer.info/posts/keyboards/triggers/index.html#tap-vs.-long-press
//https://www.jonashietala.se/series/t-34/ he focuses on a keymap for programming/VIM
/*
case TR_LCBR:
case TR_LABK:
case TR_LBRC:
@ -115,7 +119,51 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
case TR_SCLN:
case TR_QUOT:
return process_tap_hold_key(record, keycode);
*/
// Brackets: open and close brackets and put the cursor inside
case TR_LCBR:
return process_tap_hold_key(record, KC_LCBR, KC_RCBR, HOLD_BRACKETS);
case TR_LABK:
return process_tap_hold_key(record, KC_LABK, KC_RABK, HOLD_BRACKETS);
case TR_LBRC:
return process_tap_hold_key(record, KC_LBRC, KC_RBRC, HOLD_BRACKETS);
case TR_LPRN:
return process_tap_hold_key(record, KC_LPRN, KC_RPRN, HOLD_BRACKETS);
case TR_DQUO:
return process_tap_hold_key(record, KC_DQUO, KC_DQUO, HOLD_BRACKETS);
case TR_SQUO:
return process_tap_hold_key(record, KC_QUOT, KC_QUOT, HOLD_BRACKETS);
// double tap
case TR_BSLS:
return process_tap_hold_key(record, KC_BSLS, KC_BSLS, HOLD_DOUBLETP);
case TR_SLSH:
return process_tap_hold_key(record, KC_SLSH, KC_SLSH, HOLD_DOUBLETP);
case TR_PIPE:
return process_tap_hold_key(record, KC_PIPE, KC_PIPE, HOLD_DOUBLETP);
// Custom override without holding shift
case TR_COMM:
return process_tap_hold_key(record, KC_COMM, KC_LPRN, HOLD_SINGLETP);
case TR_DOT:
return process_tap_hold_key(record, KC_DOT, KC_RPRN, HOLD_SINGLETP);
case TR_PERC:
return process_tap_hold_key(record, KC_PERC, KC_CIRC, HOLD_SINGLETP);
// auto shift
case TR_EQL:
return process_tap_hold_key(record, KC_EQL, KC_PLUS, HOLD_SINGLETP);
case TR_MINS:
return process_tap_hold_key(record, KC_MINS, KC_UNDS, HOLD_SINGLETP);
case TR_GRV:
return process_tap_hold_key(record, KC_GRV, KC_TILD, HOLD_SINGLETP);
case TR_SCLN:
return process_tap_hold_key(record, KC_SCLN, KC_COLN, HOLD_SINGLETP);
case TR_QUOT:
return process_tap_hold_key(record, KC_QUOT, KC_DQUO, HOLD_SINGLETP);
}
return true;
}

110
users/t4corun/t4corun.h
View file

@ -9,8 +9,9 @@ enum layers {
_COLEMAK_DH,
_GAME,
_NAVIGATION,
_SYMBOL,
_NUMBER,
_SYMBOL,
_FUNCTION,
_CONFIG
};
@ -49,7 +50,9 @@ enum keycodes {
// momentary layer
#define NAV MO(_NAVIGATION)
#define NAV_0 LT(_NAVIGATION, KC_0)
#define SYM MO(_SYMBOL)
#define FUNC MO(_FUNCTION)
#define CONFIG MO(_CONFIG)
// Windows Shortcuts
@ -80,28 +83,64 @@ enum keycodes {
// tap hoLd. These will be intercepted and overridden. The LT will be ignored
#define TR_LCBR LT(_DEFAULT_LAYER_1, TH_LCBR) // bracket behavior
// Brackets: open and close brackets and put the cursor inside
#define TR_LCBR LT(_DEFAULT_LAYER_1, TH_LCBR)
#define TR_LABK LT(_DEFAULT_LAYER_1, TH_LABK)
#define TR_LBRC LT(_DEFAULT_LAYER_1, TH_LBRC)
#define TR_LBRC LT(_DEFAULT_LAYER_1, TH_LBRC) //
#define TR_LPRN LT(_DEFAULT_LAYER_1, TH_LPRN)
#define TR_SQUO LT(_DEFAULT_LAYER_1, TH_SQUO)
#define TR_DQUO LT(_DEFAULT_LAYER_1, TH_DQUO)
#define TR_SQUO LT(_DEFAULT_LAYER_1, TH_SQUO)
#define TR_EQL LT(_DEFAULT_LAYER_1, TH_EQL) // double tap
#define TR_BSLS LT(_DEFAULT_LAYER_1, TH_BSLS)
#define TR_SLSH LT(_DEFAULT_LAYER_1, TH_SLSH)
// double tap
#define TR_BSLS LT(_DEFAULT_LAYER_1, TH_BSLS) //
#define TR_SLSH LT(_DEFAULT_LAYER_1, TH_SLSH) //
#define TR_PIPE LT(_DEFAULT_LAYER_1, TH_PIPE)
#define TR_COMM LT(_DEFAULT_LAYER_1, TH_COMM) // custom behavior
#define TR_DOT LT(_DEFAULT_LAYER_1, TH_DOT)
// Custom override without holding shift
#define TR_COMM LT(_DEFAULT_LAYER_1, TH_COMM) //
#define TR_DOT LT(_DEFAULT_LAYER_1, TH_DOT) //
#define TR_PERC LT(_DEFAULT_LAYER_1, TH_PERC)
#define TR_EXLM LT(_DEFAULT_LAYER_1, TH_EXLM)
#define TR_AT LT(_DEFAULT_LAYER_1, TH_AT)
#define TR_QUES LT(_DEFAULT_LAYER_1, TH_QUES)
#define TR_MINS LT(_DEFAULT_LAYER_1, TH_MINS) // auto shift
#define TR_GRV LT(_DEFAULT_LAYER_1, TH_GRV)
#define TR_SCLN LT(_DEFAULT_LAYER_1, TH_SCLN)
#define TR_QUOT LT(_DEFAULT_LAYER_1, TH_QUOT)
// auto shift
#define TR_EQL LT(_DEFAULT_LAYER_1, TH_EQL) //
#define TR_MINS LT(_DEFAULT_LAYER_1, TH_MINS) //
#define TR_GRV LT(_DEFAULT_LAYER_1, TH_GRV) //
#define TR_SCLN LT(_DEFAULT_LAYER_1, TH_SCLN) //
#define TR_QUOT LT(_DEFAULT_LAYER_1, TH_QUOT) //
#define HOLD_SINGLETP 0
#define HOLD_DOUBLETP 1
#define HOLD_BRACKETS 2
/*
// tap hoLd. These will be intercepted and overridden. The LT will be ignored
// Brackets: open and close brackets and put the cursor inside
#define TR_LCBR LT(_DEFAULT_LAYER_1, TH_LCBR)
#define TR_LABK LT(_DEFAULT_LAYER_1, TH_LABK)
#define TR_LBRC LT(_DEFAULT_LAYER_1, TH_LBRC) //
#define TR_LPRN LT(_DEFAULT_LAYER_1, TH_LPRN)
#define TR_DQUO LT(_DEFAULT_LAYER_1, TH_DQUO)
#define TR_SQUO LT(_DEFAULT_LAYER_1, TH_SQUO)
// double tap
#define TR_BSLS LT(_DEFAULT_LAYER_1, TH_BSLS) //
#define TR_SLSH LT(_DEFAULT_LAYER_1, TH_SLSH) //
#define TR_PIPE LT(_DEFAULT_LAYER_1, TH_PIPE)
// Custom override without holding shift
#define TR_COMM LT(_DEFAULT_LAYER_1, TH_COMM) //
#define TR_DOT LT(_DEFAULT_LAYER_1, TH_DOT) //
#define TR_PERC LT(_DEFAULT_LAYER_1, TH_PERC)
// auto shift
#define TR_EQL LT(_DEFAULT_LAYER_1, TH_EQL) //
#define TR_MINS LT(_DEFAULT_LAYER_1, TH_MINS) //
#define TR_GRV LT(_DEFAULT_LAYER_1, TH_GRV) //
#define TR_SCLN LT(_DEFAULT_LAYER_1, TH_SCLN) //
#define TR_QUOT LT(_DEFAULT_LAYER_1, TH_QUOT) //
*/
#if defined(KEYBOARD_bastardkb_charybdis_3x5)
//these mouse codes are defined in charybdis.h
@ -156,8 +195,9 @@ enum keycodes {
#define _SCAG_MODS________________________ TR_LSFT, TR_LCTL, TR_LALT, TR_LGUI
#define _UCCPR_L___________________________________ SC_UNDO, SC_CUT, SC_COPY, SC_PAST, SC_REDO
#define _BASE_L4_________________ ___x___, SYM, TR_LSFT
#define _BASE_L4_________________ ___x___, NUM, TR_LSFT
#define _BASE_R4_________________ KC_SPC, NAV, KC_MUTE
#define _BASE_R4_ZERO____________ KC_SPC, NAV_0, KC_MUTE
#define _LAYER_TRANS_____________ ___x___, _______, ___x___
@ -185,32 +225,40 @@ enum keycodes {
#define LAYER_NAVIGATION \
___x___, KC_HOME, KC_UP, KC_END, KC_PGUP, ___x___, ___x___, KC_CAPS, KC_PSCR, CONFIG, \
___x___, KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN, ___x___, _SCAG_MODS________________________, \
_UCCPR_L___________________________________, ___x___, KC_APP, TR_SNIP, TR_SDPI, TR_PDPI, \
ZOOMRST, SYM, KC_ENT, _LAYER_TRANS_____________
#define LAYER_SYMBOL \
KC_ESC, KC_BTN3, KC_BTN2, KC_BTN1, TR_GRV, TR_EQL, KC_HASH, TR_LABK, KC_RABK, TR_PERC, \
_GACS_MODS________________________, TR_SCLN, TR_AT, TR_QUES, TR_LBRC, KC_RBRC, TR_SQUO, \
_UCCPR_L___________________________________, TR_BSLS, TR_SLSH, TR_LPRN, KC_RPRN, TR_MINS, \
_LAYER_TRANS_____________, TR_EXLM, _______, ___x___
KC_ESC, KC_HOME, KC_UP, KC_END, KC_PGUP, KC_VOLU, KC_MNXT, KC_MPLY, ___x___, CONFIG, \
___x___, KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN, KC_VOLD, _SCAG_MODS________________________, \
_UCCPR_L___________________________________, KC_MUTE, KC_APP, TR_SNIP, TR_SDPI, TR_PDPI, \
ZOOMRST, NUM, KC_ENT, _LAYER_TRANS_____________
#define LAYER_NUMBER \
KC_F7, KC_F5, KC_F3, KC_F1, KC_F9, KC_F8, KC_F10, KC_F2, KC_F4, KC_F6, \
KC_7, KC_5, KC_3, KC_1, KC_9, KC_8, KC_0, KC_2, KC_4, KC_6, \
KC_MUTE, KC_VOLD, KC_VOLU, KC_MNXT, KC_MPLY, KC_F11, KC_F12, TR_COMM, TR_DOT, TR_MINS, \
KC_ESC, KC_BTN3, KC_BTN2, KC_BTN1, KC_PSCR, ___x___, KC_7, KC_8, KC_9, KC_COMM, \
_GACS_MODS________________________, FUNC, ___x___, KC_4, KC_5, KC_6, KC_DOT, \
_UCCPR_L___________________________________, ___x___, KC_1, KC_2, KC_3, TR_MINS, \
_LAYER_TRANS_____________, _BASE_R4_ZERO____________
#define LAYER_SYMBOL \
___x___, ___x___, KC_AMPR, TR_PERC, TR_GRV, TR_EQL, KC_HASH, KC_ASTR, ___x___, TR_DQUO, \
KC_CAPS, TR_LCBR, KC_RCBR, KC_EXLM, TR_SCLN, KC_AT, KC_QUES, TR_LBRC, KC_RBRC, TR_SQUO, \
___x___, TR_LABK, KC_RABK, KC_BSLS, TR_PIPE, KC_DLR, KC_SLSH, TR_LPRN, KC_RPRN, TR_MINS, \
_LAYER_TRANS_____________, _LAYER_TRANS_____________
#define LAYER_FUNCTION \
_NONE_5____________________________________, ___x___, KC_F7, KC_F8, KC_F9, KC_F10, \
___x___, ___x___, ___x___, ___x___, _______, KC_CAPS, KC_F4, KC_F5, KC_F6, KC_F11, \
_NONE_5____________________________________, ___x___, KC_F1, KC_F2, KC_F3, KC_F12, \
_LAYER_TRANS_____________, _NONE_3__________________
#define LAYER_CONFIG \
_NONE_5____________________________________, ___x___, ___x___, EE_CLR, QK_BOOT, _______, \
_NONE_5____________________________________, ___x___, TR_LSFT, ___x___, ___x___, TR_RMOD, \
_NONE_5____________________________________, TR_RTOG, TR_RHUI, TR_RSAI, TR_RVAI, TR_RSPI, \
BASELYR, ___x___, ___x___, TR_DMP1, TR_DMR1, TR_RTOG
/*
If I was going to combine number and symbols together, it'd look like this